PHP之数组和函数的基本教程

[PHP数组的分类]

按照下标的不同，PHP数组分为关联数组与索引数组

索引数组：下标从0开始，依次增长；

关联数组：下标为字符串格式，每个下标字符串与数字的值一一关联对应(有点像对象的键值对)

[关于关联数组和索引数组]

1、数组中可以同时存在关联数组和索引数组
     array(1,2,3,"one"=>4)
  2、数组所有的索引数组如果不加指定，会去掉关联向，默认增长(即关联数组不占索引位)
     array(1,2,"one"=>4,4,5);//1,2,4,5的索引--->0/1/2/3
  3、如果关联数组的key;是纯十进制整数字符串，则会将此数字转化为索引数组的索引值("10.0"/"08"等格式，仍然为关联数组，不转为索引)
     array(1,2,"on3"=>4,"9"=>4,"010"=>5);//1,2,4的索引--->0/1/9
  4、如果手动指定关联数组的key，索引数组的下标，如果与前面已有的key或下标重复，则后指定的值会覆盖之前的值；   array(1,"one"=>2,0=>5,"one"=>6);-->打印数组 0=>5,"one"=>6;
  5、如果手动指定索引数组下标，则后续自增长下标，会按照之前下标最大值，依次增长。
    array(1,2,7=>3,4);   1,2,3,4的下标--->0,1,7,8

$arr1 = [1,2,3,4,5,6]//索引数组
var_dump($arr1);
print_r($arr1);
 
$arr2 = array("one"=>1,"two"=>2,"three"=>3);//关联数组
var_dump($arr2);
 
$arr3 = array(1,"one"=>2,3,5=>4,5,6,"9"=>7,8,"haha"=>9);
var_dump($arr3);

 [数组的声明方式]
 1、直接赋值声明；
 2、[]字面量声明(PHP5.4版本之后能用)
 3、Array()声明，没有new关键字

        //1
          $arr[]=;
        $arr[]=;
        $arr[]=;
        $arr[]=;
        $arr[]=;
        $arr[]=;
        var_dump($arr);
        //
        $arr = [,,,"one"=>,];
        var_dump($arr);
        //
        $arr = array(,,,,);
        var_dump($arr);

[数组元素的读取]
PHP中数组支持[]和{}读取下标

$arr = [,,,"one"=>];
   echo $arr[];
   echo $arr["one"];
  echo $arr{"one"};
   echo $arr{};

[多维数组]
数组的一个值，依然是一个数组，我们称这种数组为多维数组
多维数组，不要求所有的项都为数组，可以是数组与普通值的混合
多维数组，也不要求每个子数组的限制个数
使用多维数组，一定要注意，数组中分隔用逗号
原则上，多维数组一般不超过3层使用

 $h51701 =array(
        "gruop1"=>array(
     array("name"=>"张三","age"=>,"sex"=>"男"),
       array("name"=>"张三","age"=>,"sex"=>"男"),
         array("name"=>"张三","age"=>,"sex"=>"男"),
         "groupName"=>"一组"
         ),
         "gruop2"=>array(
     array("name"=>"张三","age"=>,"sex"=>"男"),
       array("name"=>"张三","age"=>,"sex"=>"男"),
         array("name"=>"张三","age"=>,"sex"=>"男")
         ),
         "gruop3"=>array(
     array("name"=>"张三","age"=>,"sex"=>"男"),
       array("name"=>"张三","age"=>,"sex"=>"男"),
         array("name"=>"张三","age"=>,"sex"=>"男")
         )
        );
        var_dump($h51701);

遍历数组

使用for循环遍历数组

count($arr);用于统计数组元素的个数；
for循环只能用于遍历纯索引数组，！！！如果存在关联数组，count统计时会统计两种数组的总个数，使用for循环遍历混合数组，可能会导致数组越界

$arr = array(,,,,,);
  $num = count($arr);//count最好放到for外面，可以让函数只执行一次。
  for($i=;$i<$num;$i++){
      echo "{$i}==>{$arr[$i]}";
  }

foeEach循环遍历数组
foreach可以便利任何类型的数组
写法如下：

$arr = array(,,,"one"=>,,,);
   foreach($arr as  $item){
        echo  "{$item}<br/>";
   };
   $arr = array(,,,"one"=>,,,);
   foreach($arr as $key=> $item){
        echo  "{$key}==>{$item}<br/>";
   }

实例

$h51701 =array(
        "gruop1"=>array(
     array("name"=>"张三","age"=>,"sex"=>"男"),
       array("name"=>"张三","age"=>,"sex"=>"男"),
         array("name"=>"张三","age"=>,"sex"=>"男")
         ),
         "gruop2"=>array(
     array("name"=>"张三","age"=>,"sex"=>"男"),
       array("name"=>"张三","age"=>,"sex"=>"男"),
         array("name"=>"张三","age"=>,"sex"=>"男")
         ),
         "gruop3"=>array(
     array("name"=>"张三","age"=>,"sex"=>"男"),
       array("name"=>"张三","age"=>,"sex"=>"男"),
         array("name"=>"张三","age"=>,"sex"=>"男")
         )
        );
   foreach ($h51701 as $key => $value) {
        echo "{$key}<br/>";
          foreach ($value as $key1 => $value1) {
              echo "{$key1}<br/>";
                 foreach ($value1 as $key2 => $value2) {
                      echo "{$key2}==>{$value2}<br/>";
                 }
 
          }
 
   };

3、使用list()  each()  while()遍历数组
   list():用于将数组的每一个值，赋值给list函数的每一个参数。(list函数的参数，必须小于等于数组的元素个数)。
      eg($a,$b,$c)=[1,2,3];-->$a=1; $b=2; $c=3;
     注意：①list()在解析数组时，只解析索引数组。
        ②list可以通过空参数，选择性的解析数组的值
        list($a,,$b)=[1,2,3]--->$a=1,$b=3
     each():用于返回数组当前指针所在位的键值对，并将指针后移一位。
     返回值：如果数组由下一位，返回一个数组。包含一个索引数组(0-键，1-值)和一个关联数组("key"-键，"value"-值)；如果指针没有下一位，返回false
     [使用list()/each()/while()配合遍历数组]

while(list($key,$value)= each($arr)){
        echo "{$key}-->{$value}<br/>";
      };
      reset($arr);

数组使用完each()遍历完一遍后，指针始终处于最后一位的下一位，即再用each(),返回false

 $arr = [,,,,,];
   list($a,$b,$c,$d,$e,$f) = $arr;

echo "a-->{$a}<br/>";
   echo "b-->{$b}<br/>";
   echo "c-->{$c}<br/>";
   echo "d-->{$d}<br/>";
   echo "e-->{$e}<br/>";
   echo "f-->{$f}<br/>";*/
  
      while($a = each($arr)
     ① each($arr)  返回数组或false‘
     ② 把数组或false赋值给$a
     ③ while判断$a如果是数组，继续执行下一次、
      如果$a是false，终止循环

  while($a = each($arr)){
        echo "{$a[0]}-->{$a[1]}<br/>";
       echo "{$a['key']}-->{$a['value']}<br/>";
   }
   while(true){
       $a = each($arr);
       if($a){
            echo "{$a[0]}-->{$a[1]}<br/>";
         echo "{$a['key']}-->{$a['value']}<br/>";
       }else{
           break;
       }
   }
 while(list($key,$value)= each($arr)){
 
       echo "{$key}-->{$value}<br/>";
   };
   reset($arr);
    while(list($key,$value)= each($arr)){
 
       echo "{$key}-->{$value}<br/>";
   } 

4、使用数组指针遍历数组
    ①next()：将数组指针后移一位，并返回后一位的值,没有返回false
    ②prev():将数组指针前移一位，并返回前一位的值,没有返回false
    ③end():将数组指针移至最后一位，并返回最后一位的值，空数组返回false
    ④reset():将数组指针恢复到第一位，并返回第一位的值。空数组返回false
    ⑤key():返回当前指针所在位的键；
    ⑥current():返回当前指针所在位的值；

  $arr = [,,,,"one"=>];
    while(true){
        echo key($arr);
         echo current($arr);
          echo "<br/>";
           if(!echo next($arr)){
               break;
           }
    }
      reset($arr);
      do{
              echo key($arr);
         echo current($arr);
           echo "<br/>";
      }while(echo next($arr));
    reset($arr)

[超全局数组]
 超全局数组，超全局变量、预定义数组、预定义变量说的都是他。
  PHP给我们提供了一组包含强大功能的超全局数组，可以再任何地方，任何作用域不许声明，直接使用，不受任何作用域限制。
        1  服务器变量： $_SERVER
            2  环境变量：$_ENV
            3  HTTP GET变量：$_GET
            4  HHTP POST变量：$_POST
            5  request变量：$_REQUEST
            6  HTTP文件上传变量：$_FILES
            7  HTTP Cookies:$_COOKIE
            8  Session变量：$_SESSION
            9  Global变量：$GLOBALS
      1服务器变量： $_SERVER
       $_SERVER是返回包含浏览器头信息，路径、脚本以及服务器系统等信息

  var_dump($_SERVER);
        var_dump($_SERVER{'HTTP_USER_AGENT'});

2  环境变量：$_ENV
              将系统环境变量，转变为PHP中的数组，就是$_ENV；
             PHP默认是关闭此全局数组的。如需使用，需修改php.ini文件中的variables_order = "GPSC",改为variables_order = "EGPSC";
             但是，修改后会有系统性能损失，官方并不推荐使用
             可以使用getenv()函数取代全局变量，取出每个系统环境变量的值
             phpinfo();函数：包含了有关PHP的各种信息，其中Environment板块是系统环境变量，可以使用getenv()取出其中的每一个值；

      phpinfo();
          echo getenv("System");

3  HTTP GET变量：$_GET
             获取前台通过Get方式提交的数据；

           var_dump($_GET);
        if(isset($_GET["submit"])){
                 if($_GET["username"]==""&&$_GET["pwd"]==""){
                echo  "登陆成功";
               }else{
                   echo "登陆失败";
               }
             }

4  HHTP POST变量：$_POST
             获取前台通过POST提交的数据

 if(isset($_POST["submit"])){
                 if($_POST["username"]==""&&$_POST["pwd"]==){
                echo  "POST登陆成功";
               }else{
                   echo "POST登陆失败";
               };
             }

var_dump($_POST);
            5  request变量：$_REQUEST
             包含了$_POST，$_GET和$_COOKIE的数组
              由于request同时包含get和post，可能导致get与post键的冲突，并且效率也不高，所以，并不使用request。
            var_dump($_REQUEST);
            6  HTTP文件上传变量：$_FILES
            7  HTTP Cookies:$_COOKIE
              取到页面中的cookie信息

  setcookie("cookie","haha");
            $_COOKIE["hehe"]="haha";
            var_dump($_COOKIE);            

8  Session变量：$_SESSION
              取到保存在Session中的信息

  session_start();
            $_SESSION["haha"]="hehe";
            var_dump($_SESSION);

9  Global变量：$GLOBALS
          $GLOBALS包含了上述8个全局数组，可以通过$GLOBALS["_SERVER"]收到$_SERVER
          还可以通过给$GLOBALS数组追加下标，创建全局变量，可以再函数里函数外随意访问:

  $GLOBALS["name"]="zhangsan";
            var_dump($GLOBALS);

返回数组所有的值，返回数组

var_dump(array_values($arr));

返回数组所有的键，返回数组

var_dump(array_keys($arr));

数组中是否包含某个值，返回真假
 参数：需要查询的值，数组，true(===)/false(==)

var_dump(in_array(, $arr,true));

交换数组中的键和值，返还新数组

var_dump(array_flip($arr));

反转数组，返回新数组
  参数：①需要反转的数组
      ②true：保留原有索引数组的下标与值的匹配
       false：只反转值，键不保留。默认。
       无论true/false都不会影响关联数组，关联数组总会保留，键值永远是一对。

var_dump(array_reverse($arr,true));

统计数组元素个数
count($arr);
统计数组中，所有值出现的次数，返回一个新数组
  新数组格式：建--> 元数组的值(去重 后的值)
           值--> 元数组对应的值出现的次数

var_dump(array_count_values($arr));

$arr = array(,,,,,,"a"=>,"b"=>,"c"=>,);
$arr1 = array('J. Karjalainen', 'J. Karjalainen', , '', 'J. Karjalainen', 'j. karjalainen', 'Fastway', 'FASTWAY', 'Fastway', 'fastway', 'YUP');
$arr2 = array();

1、有一个空数组arr2，键-->原数组去重的值，值-->原数组每个值出现的次数。
2、遍历原数组arr1，并去除arr1中的每一个值。
3、检测新取出的这个值，是否在arr2中，有一个同名的键。
  如果有：说明找到了与现在新数组想重复的值，那么就把arr2中的这个键对应的值+1
如果没有：说明截止现在，还没有与新取值重复的项，那么就在arr2中 新建一个同名的键，让值为1；

foreach($arr1 as $key1 => $value1) {
          $isHas = false;
        foreach($arr2 as $key2 => $value2) {
            if($key2 == $value1) {
                $rarr2[$value1]++;
                $isHas = true;
            }
        }
       if(!isHas) $arr2[$value1] = ;
        }

移除数祖中重复的值
var_dump(array_unique($arr));
过滤数祖中的每一个值
 ①不传回调函数，过滤掉所有的空值，(0/""/false/"0"/[])
 ②传回调函数，需要给回调函数传递一个参数，判断参数是否符合要求，如果符合，return  true;否则，return false;

var_dump(array_filter($arr，function($num){
      if($num>){
          return  true;
      }else{
          return false;
      }
}))

通过回调函数，对数组的每一给值进行处理操作。直接修改原数组并返回bool类型的是否成功
执行时，会给回调函数传递两个参数，分别是数组的value，key。然后可以再回调函数中，对值和减进行处理。
但是！！！牵扯到修改值的时候，必需要传递地址！！！

$fruits = array("a"=>"lemon","b"=>"orange","c"=>"apple");
 var_dump(array_walk($fruits,function(&$item,$key){
      echo "{$key}-->{$item}<br/>";
     $item =$key;
 },""));
 var_dump($fruits)；

将数组的每个值，交由回调函数进行映射处理
     array_map();第一个参数是一个回调函数，第二个参数起是>=1个数组
     有几个数组可以给回调函数传几个参数，表示每个数组的一个value；
     可以对value进行处理，处理完以后通过return返回，那么新数组的对应的值就是return回去的值
     【array_map与array_walk的异同】
     相同点：都能遍历数组，通过回调函数，重新处理数组的每一个值
     不同点：
     ①walk只能传一个数组，回调函数接受这个数组的值和键
              map可以传多个数组，回调函数接受每个数组的值
     ②walk直接修改原数组，而map不修改原数组，将新数组返回；
     ③walk可以给回调函数传递一个其余参数，map只能传数组的值
     ④处理方式上，walk如果需要改掉原数组的值，需在回调函数中传递地址，直接修改变量的值；
                      map是通过将新的值，用return返回，即可修改新数组的值

   $a = [,,,,];
    $b = [,,,];
    $arr2 = array_map(function($value1,$value2){
        return $value1+$value2;
    },$a,$b);
    var_dump($arr2);

sort -- 对数组排序(升序),可传入第二个参数，控制以何排序，第二个参数传1，表示按照数字排序，2表示按字符串排序，自动检测
    rsort -- 对数组逆向排序（降序）
    usort --  使用用户自定义的比较函数对数组中的值进行排序
     usort($arr,function($a,$b){
        //return $a-$b;升序
        //return $b-$a;降序
       })；
     下述3个函数，常用于（关联数组排序），用法同上
    asort -- 对数组进行排序并保持索引关系
    arsort --  对数组进行逆向排序并保持索引关系
    uasort --  用户自定义的比较函数对数组进行排序并保持索引关联
    ksort -- 对数组按照键名排序
    krsort -- 对数组按照键名逆向排序
    uksort --  使用用户自定义的比较函数对数组中的键名进行排序
    自然排序 ：数字按照0-9，字母按照a-z进行排序
    下面两个函数，都是按照自然排序，并且排序时会保留键值关联  
    natsort --  用“自然排序”算法对数组排序
    natcasesort --  用“自然排序”算法对数组不区分大小写字母排序
    array_multisort -- 对多个数组或多维数组进行排序
    第一个参数时第一个数组，
    之后都是可选参数，SORT_ASC - 按照上升顺序排序 /SORT_DESC - 按照下降顺序排序 ,SORT_NUMERIC - 将项目按照数字比较/SORT_STRING - 将项目按照字符串比较 、
    在之后，就是多个可选数组。
     排序规则：先排第一个数组，之后的数组，按照与第一个数组对应的关系：一列一列的移动！！！
     如果对多个数祖排序，需保持多个数组长度一致，否则会报警告。

$arr = array[,,,,,,];
    echo SORT_STRING;
    sort($arr,SORT_STRING);
    usort($arr,function($a,$b){
        //return $a-$b;升序
        //return $b-$a;降序
    })；
    var_dump($arr);

   $arr1 = [,,,,,,];
    $arr2 = [,,,,,,];
    array_multisort($arr1,SORT_DESC,SORT_NUMERIC,$arr2);
    var_dump($arr1);
    var_dump($arr2);

   $arr = array[,,,,,,"one"=>,,,"haha"];
   array array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = false ]] )

①数组，必须
      ②从第几位开始截取，必选，负数表示，从右边数第几位(按照数组的默认顺序，包括关联，索引，而不是按照下标)
      ③截取的长度，可选，默认，截到最后
      ④Boolean类是否保持键值关联，可选，默认，索引重新排序，传true保持索引关联

  $arr1 = array_slice($arr,,);
    var_dump($arr1);
    

array array_splice ( array &$input , int $offset [, int $length = 0 [, mixed $replacement ]] )
     返回值：被删掉的数组；
     参数：
     ①数组的地址，会修改原数组
     ②从第几位开始删，替换
     ③删除或替换的长度
     ④为空，表示删除操作，传入内容，表示替换操作的新值

   $arr = array[,,,,,,"one"=>,,,"haha"];
    $arr1 = array_splice($arr,,,[,,,]);
    var_dump($arr1);
    var_dump($arr);

array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
    array_combine(作为键的数组，作为值的数组)
      两个数组必须保持一致，否则警告，返回false；

  $arr1 = [,,,,];
     $arr2 = [,,,,];
     $arr3 =array_combine($arr1, $arr2);
     var_dump($arr3);

合并数组
      array array_merge ( array $array1 [, array $... ] )
      合并多个数组，将后面的数组拼接到前面的数组的后面
      如果多个数组中，出现同名的关联键值，则后面的会覆盖前面

$arr1 = [,,,"a"=>,""=>];
      $arr2 = [,,,"a"=>,""=>];
      $arr3 = array_merge($arr1,$arr2);
      var_dump($arr3);

数组取交集
       array array_intersect ( array $array1 , array $array2 [, array $ ... ] )
       *多个数组取交集，结果会保留第一个数组的键值关联匹配。

  $arr1 = [,,,"a"=>,];
      $arr2 = [,,,"a"=>,""=>];
      $arr3 = array_intersect($arr1, $arr2);
      var_dump($arr3);      

数组取差集
       array array_diff ( array $array1 , array $array2 [, array $... ] )
       取出多个数组中，在第一个数组中包含，但是在其他数组中不包含的值，保留第一个数组的键值关联

 $arr1 = [,,,"a"=>,];
      $arr2 = [,,,"a"=>,""=>];
      $arr3 = array_diff($arr1, $arr2);
      var_dump($arr3);      

array_pop 删除数组的最后一个值，并且返回这个值
       array_push 数组的最后，放入1-多个值，返回处理之后的数组元素个数
       array_shift 删除数组的第一个只，并且返回这个值
       array_unshift 数组的开头，放入1-多个值，返回处理之后的数组元素个数   
         array_rand:随机抽取数组中的1到多个键名，第二个参数为空，表示抽一个，传入数字，表示抽N个。

     $arr1 = [,,,,,,];
      var_dump(array_rand($arr1,));

shuffle：随机打乱数组顺序，直接修改原数组

 $arr1 = [,,,,,,];
      shuffle($arr1);
      var_dump($arr1);

   [函数的声明与使用]
 1、函数名是标志符之一，只能有字母，数字，下划线，开头不能使数字
    函数名的命名：须符合小驼峰法则，：myNameIsJh   my_name_is_jh
    函数名不区分大小写，func();  FUNC();  Func();
    函数名不能与已有函数名重复，，不能与系统函数名重复
  2、function_exists("func");用于函数是否以声明
  注意：传入的函数名，必须是字符串格式，返回的结果为true/false;
 [PHP中变量的作用域]
  1、局部变量：声明在函数内的变量，称为局部变量，只能在函数内部使用，函数外部如需使用，需在函数中使用return关键字返回。
  2、全局变量：声明函数外部的变量，称为全局变量。
  3、函数中，使用变量。默认使用内部局部变量，如果，需在函数中使用全局变量，需要使用global关键字，将全局变量引入函数，才能使用
    函数中的变量名：如果与全局变量重复，global语句之上，为函数局部变量。global语句之下，为系统全局变量
  4、$GOLBALS[]全局数组
    $GOLBALS[]数组，是PHP给我们内置的全局数组，可以直接给数组添加值，无论寒暑内外声明，均可在任何地方直接使用
   $GLOBALS["a3"]=40;  echo $GLOBALS["a3"]； //任何位置直接使用
  5、函数中使用全局变量还有一种方式，通过给函数传参，可以在函数内部使用全局变量
  但是，传递以后的参数势函数的局部变量，内部改变，外部不会变。
  除非。传递的参数是地址 function  func($a1,$a2){}// 函数内部修改a1，则全局a1不会变，函数内部修改a2，则全局a2会变。
  如果函数的形参，出现了取址符号，则调用函数时，实参必须是变量，而不能使自变量，例如func($a1,$a2);√   func($a1,2);×
  6、使用require与include包含不会影响作用域
  [静态变量]
  1、静态变量使用static关键字声明， static  $num=1;
  2、静态变量的特点：静态变量在函数的第一次加载的时候进行声明，函数使用完不会立即释放静态变量，静态变量在整个脚本过程中，只会声明一次。
  同一函数，多次调用，共享同一个静态变量。 
  [函数的参数传递]
  0、在PHP中，设计参数传递时，实参列表只能
  1、常规参数传递   function func($a){}   func($a);
  2、引用参数传递   function func(&$a){}   func($a);
     ①  通过&引用参数传递，函数内修改变量，函数外同步变化
     ②  形参为引用参数，实参只能是变量，不能是自变量  func(10);
  3、默认参数:function  func($a=10,$b){};  func(20);//$a的量不变，默认为10；$b必须赋值，否则就会未定义报错。
 function func($b,$a=10){return  $a+$b;}      func(30);
     如果参数中既有默认参数，又有非默认参数，那么。默认参数要在非默认参数的后面，及调用是，要保证非默认参数列表的先赋
  4可变参数列表：由于PHP实参可以比形参多，那么我们可以传递n个实参，并通过PHP内置参数取到对应参数
  var_dump(func_get_args());//区所有参数列表
    var_dump(func_num_args());//返回参数的总个数
    var_dump(  func_get_arg());//根据下标。取每个参数
 
  [变量函数]
 1、将一个函数名，转为字符串后，赋给一个变量，这个变量，就是我们所说的变量函数，可以加()调用函数，
     function  func(){}--->$fun = "func"--->$func()
  [回调函数]
  1、使用变量函数，自定义回调函数
    function func($func){$func();} -->function f(){};-->func("f");
 2、使用call_user_func_array和call_user_func自定义回调函数
    两个函数的第一个参数，均为回调函数，表示执行当前回调
    不通电在于：call_user_func_array()第二个参数维数组，并将数组的每一个值赋给回调函数的参数列表，，相当于JS中的apply();
    而：call_user_func() 是将回调函数的参数列表，直接展开写到第二个到多个参数中，相当于JS中的call();  eg:call_user_func_array("func",array(1,2,3))；-->func(1,2,3)
       call_user_func("func",1,2,3);-->func(1,2,3)

// 简单的函数声明
  function func(){
      echo "jianghao";
  }
  func();
  FUNC();
 // 检测函数是否存在
  var_dump(function_exists("func"));
  //变量的作用域
  $a1=;
  $haha1=;
  $haha2 = ;
  $GLOBALS["a3"]=;
  function func($haha1,&$haha2){
       $a1 = ;
    echo "0.{a1}<br/>";//global之上使用局部变量
    echo  $GLOBALS["a3"]."<br/>";//使用$GLOBALS["a3"]数组
     $GLOBALS["a4"]=;
      global  $a1;
      $a2 =;
      echo "1.{a1}<br/>";//global之下使用全局变量
    echo "2.{a2}<br/>"; //使用函数内部局部变量
    $haha1=;//是通过全局haha1赋值而来
    $haha2 = ;//是通过全局haha2赋地址而来
    return  $a2;
  }
  $a2 = func($haha1,$haha2);
  echo "3.{a1}<br/>";//使用全局变量
    echo "4.{a2}<br/>";//通过return返回，通过变量接受
  echo "5.{$GLOBALS["a4"]}<br/>";//函数中使用$GLOBALS[]声明，函数外使用。
  echo "6.{$haha1}<br/>";//形参为传值，函数内改变，全局不变
  echo "7.{$haha2}<br/>";//形参为传地址，函数内改变，全局也变

静态变量

  function func(){
      static  $num = ;
    $num++;
    echo  $num."<br/>";
  }
  func();

常规参数传参
  功能：将传入的参数，+10后返回

   Number  func(Number  params)
function func($a){
    $a +=;
    return  $a;
}
echo  func();

引用类型参数

 function func(&$a){
      $a +=;
  }
 
  func($a);  //通过取值符号，可以直接将传入的$a的之改掉
  echo $a;
  

默认参数

function func($b,$a=){
      return  $a+$b;
  }
  func();

可变参数列表

  function  func(){
      $arr =func_get_args();
      var_dump(func_get_args());//区所有参数列表
    var_dump(func_num_args());//返回参数的总个数
    var_dump(  func_get_arg());//根据下标。取每个参数
    var_dump(&arr[]);//同上
    for($i=;$i<func_num_args();$i++){
        $num = func_num_args($i)
    }
    return $sum；
  }
  echo  func(,,,,)；

变量函数

 function func($a){
      echo "杰瑞教育!{$a}<br/>";
  }
  func();
  $fun  = "func";
  $fun();
    //自定义回调函数
  function func($start,$end,$func){
      for($i=$start;$i<=$end;$i++){
          $func($i)
          if($func($i)){
              echo  "{$i}<br/>";
          }
      }
  }
  function fliter($num){
      if($num%!=){
          return true;
      }else {
          return false;
      }
  }
  function fliter1($num){
      if($num>&&$num%==){
          return true;
      }else {
          return false;
      }
  }
  func(,,"fliter1");
  func(,,function($num){
       return  true;
  });

使用call_user_func_array和call_user_func自定义回调函数

 function func(){
      $arr = func_get_args();
    $str = "";
    for($i=;$i<count($arr);$i++){
        $str.= $arr[$i];
    }
    return $str;
  }
 
 //apply
 echo call_user_func_array("func",array("jierui","edu","h51701","web"));
  //相当于，执行func函数，并且把数组中的每一项作为参数传入。
 
  echo "<br/>";
 
  //call
 echo call_user_func("func","jierui","h51701","edu")

[匿名函数]
 1、由于变量函数在调用时存在多种调用方式，(func()/$Fun();)
 所以为了让函数的调用更为同一，才产生了匿名函数
  ！！！声明匿名函数，函数体后面的分号必不可少。
  ！！！匿名函数本身也是变量，用var_dump()检测为object类型。

$func =function($param){
      echo "我是匿名函数{$param}<br/>";
  };
  $func();
 
  var_dump($func);

   [递归函数]
    1、所谓递归，指的是在函数内部，调用函数自身的操作
    2、递归分为两步：递、归
       递：从最外层函数依次往里调用自身
       归：最内层函数执行完后，在逐步向外调用外层函数的后半部分
      当最外层函数体中，遇到自身函数调用，继续进入内层函数执行，而最外层函数的后半部分暂不执行，指导最内层函数执行完毕后，在逐步向外执行

 function func($num){
         echo $num."<br/>";
         if($num>){
               func($num-);
         }
          echo $num."<br/>";
   }
   func();

  使用递归求1-10的阶乘

function func($num){
      static $jie=;
        if($num>){
            $jie *=$num;
              func(--$num);
        }
        return $jie;
   }
  echo func();

   [include&rquire]
   1、两者的作用，都是用于引入外部的PHP文件到当前文件中；
   2、两者的区别：当引入的文件错误时，include会产生警报，并不影响后续代码执行，而require会产生致命错误，后续代码全部不再执行。
   3、一般，应用于在文件最上方导入某些文件时使用require导入，如果导入失败，则不执行文件。而，如果在某些分支条件中，导入某些分支结构。一般使用include导入。一旦出错，分支不执行。
   4、include_once和require_once表示：文件只能导入一次，如果多次调用此函数，则后面的语句会判断文件是否导入，在决定是否导入新文件。
   (检测文件是否导入时，只关心文件是否已经导入，并不关心使用何种方式导入的。)
   include('text.txt')
   require_once('text.txt');//由于include进来了，require不在导入
5、include和require可以导入各种类型的文件，相当于在当前文件copy一份，但是在copy过程中，PHP引擎会进行适当的编译，确保不会出错。 
   6、include和require势函数，也是指令，PHP对于很多常用函数，会提供执行的写法，例如echo("11");//函数写法   echo  "11"//指令写法

require 'function.php';
   include 'function.php';
   func1();
   func2();
   func3();

[PHP闭包]
   在PHP中，子函数无法直接访问父函数的局部变量，必须使用use关键字向下传递。