PHP数组常用方法

                                                            PHP数组常用方法
【写在前面】

• 为了方便大家阅读，我用Markdown写了一篇，请移步：PHP数组常用方法（优化版）

 

目录结构：
    ----|-判断/查找：
    |        |_ is_array — 检测变量是否是数组
    |        |_ in_array — 检查数组中是否存在某个值
    |        |_ array_key_exists — 检查数组里是否有指定的键名或索引
    |        |_ array_search — 在数组中搜索给定的值，如果成功则返回首个相应的键名
    |        |_ array_keys — 返回数组中部分的或所有的键名
    |        |_ array_values — 返回数组中所有的值
    |        |_ count — 计算数组中的单元数目，或对象中的属性个数 别名 sizeof()
    |        
    |---|-合并/增加：
    |        |_array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
    |        |_array_shift — 将数组开头的单元移出数组
    |        |_array_pop — 弹出数组最后一个单元（出栈）
    |        |_array_unshift — 在数组开头插入一个或多个单元
    |        |_array_push — 将一个或多个单元压入数组的末尾（入栈）
    |        
    |---|-截取/重组：
    |        |_array_slice — 从数组中取出一段
    |        |_array_column — 返回数组中指定的一列
    |        
    |---|-排序：
    |        |_一维数组排序
    |            |_sort() -  根据值，以升序对数组排序[索引重置]
    |            |_rsort() - 根据值，以降序对数组排序[索引重置]
    |            |_asort() - 根据值，以升序对关联数组进行排序[保持索引关系]
    |            |_ksort() - 根据键，以升序对关联数组进行排序[保持索引关系]
    |            |_arsort() - 根据值，以降序对关联数组进行排序[保持索引关系]
    |            |_krsort() - 根据键，以降序对关联数组进行排序[保持索引关系]
    |        |_多维数组排序
    |            |_array_multisort — 对多个数组或多维数组进行排序
    |
    |---|-并集/交集/差集：
    |        |_array_merge — 合并一个或多个数组(索引重置)
    |        |_array_intersect — 计算数组的交集
    |        |_array_intersect_assoc — 带索引检查计算数组的交集
    |        |_array_diff — 计算数组的差集
    |        |_array_diff_assoc — 带索引检查计算数组的差集
    |
    |---|-循环：
    |        |_foreach()循环：foreach 仅能够应用于数组和对象
    |        |_for循环数组自增
    |    

内容：
一、判断/查找：
    1、is_array — 检测变量是否是数组
        语法：bool is_array ( mixed $var )    //如果 var 是 array，则返回 TRUE，否则返回 FALSE。
        使用：
            $arr = [];
            $arr1 = 99;
            var_dump(is_array($arr));    //输出 bool(true)
            var_dump(is_array($arr1));    //输出 bool(false)
        类似的方法：
            1)、is_int — 检测变量是否是整数
                bool is_int ( mixed $var )        //如果 var 是 integer 则返回 TRUE，否则返回 FALSE。
                is_integer — is_int() 的别名
            2)、is_numeric — 检测变量是否为数字或数字字符串
                bool is_numeric ( mixed $var )    //如果 var 是数字和数字字符串则返回 TRUE，否则返回 FALSE。
                Note:若想测试一个变量是否是数字或数字字符串（如表单输入，它们通常为字符串），必须使用 is_numeric()。
            3)、is_bool — 检测变量是否是布尔型
                bool is_bool ( mixed $var )        //如果 var 是 boolean 则返回 TRUE。
            4)、is_float — 检测变量是否是浮点型
                bool is_float ( mixed $var )    //如果 var 是 float 则返回 TRUE，否则返回 FALSE。
                is_real — is_float() 的别名            
            5)、is_string — 检测变量是否是字符串
                bool is_string ( mixed $var )    //如果 var 是 string 则返回 TRUE，否则返回 FALSE。
            6)、is_object — 检测变量是否是一个对象
                bool is_object ( mixed $var )    //如果 var 是一个 object 则返回 TRUE，否则返回 FALSE。
                
    2、in_array — 检查数组中是否存在某个值
        语法：bool in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] )    //大海捞针，在大海（haystack）中搜索针（ needle），如果没有设置 strict 则使用宽松的比较。
        参数说明：
            参数        说明
            needle        待搜索的值。 (如果 needle 是字符串，则比较是区分大小写的。)
            haystack    待搜索的数组。
            strict         如果第三个参数 strict 的值为 TRUE 则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同。
        返回值：
            如果找到 needle 则返回 TRUE，否则返回 FALSE。
        使用：
            代码：
                //区分大小写
                $fruits = [ "Apple", "Pear", "Bana", "Orange" ];
                if (in_array("Apple", $fruits)) {
                    echo "Apple ";
                }
                if (in_array("apple", $fruits)) {
                    echo "apple ";
                }
                //开启严格检查
                $number = [ 13, 14, 15, 16 ];
                if (in_array("13", $number, true)) {
                    echo "string 13";
                }
                if (in_array(13, $number, true)) {
                    echo "int 13";
                }
            返回：Apple int 13
            
    3、array_key_exists — 检查数组里是否有指定的键名或索引
        语法：bool array_key_exists ( mixed $key , array $array )        // 数组里有键 key 时，array_key_exists() 返回 TRUE。 key 可以是任何能作为数组索引的值。
        参数说明：
            参数    说明
            key        要检查的键
            array    一个数组，包含待检查的键
        返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
        Note:array_key_exists() 仅仅搜索第一维的键。 多维数组里嵌套的键不会被搜索到。
        使用：
            $array = [ 1,2,3,4 ];
            var_dump(array_key_exists(0, $array));    //输出 bool(true)
        注意：isset() 对于数组中为 NULL 的值不会返回 TRUE，而 array_key_exists() 会。
            $search_array = array('first' => null, 'second' => 4);
            var_dump(isset($search_array['first']));            //输出 bool(false)  
            var_dump(array_key_exists('first', $search_array));    //输出 bool(true)
            
    4、array_search — 在数组中搜索给定的值，如果成功则返回首个相应的键名
        语法：mixed array_search ( mixed $needle , array $haystack [, bool $strict = false ] )        //大海捞针，在大海（haystack）中搜索针（ needle 参数）。
        参数说明：
            参数        说明
            needle         搜索的值。 (如果 needle 是字符串，则比较以区分大小写的方式进行。 )
            haystack    这个数组。
            strict         如果可选的第三个参数 strict 为 TRUE，则 array_search() 将在 haystack 中检查完全相同的元素。
                        这意味着同样严格比较 haystack 里 needle 的 类型，并且对象需是同一个实例。
        返回值：
             如果找到了 needle 则返回它的键，否则返回 FALSE。
             如果 needle 在 haystack 中出现不止一次，则返回第一个匹配的键。要返回所有匹配值的键，应该用 array_keys() 加上可选参数 search_value 来代替。
        使用：
            $array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
            $key = array_search('green', $array); // $key = 2;
            $key = array_search('red', $array);   // $key = 1;
            
    5、array_keys — 返回数组中部分的或所有的键名
        语法：
            array array_keys ( array $array [, mixed $search_value = null [, bool $strict = false ]] )
                array_keys() 返回 input 数组中的数字或者字符串的键名。
                如果指定了可选参数 search_value，则只返回该值的键名。否则 input 数组中的所有键名都会被返回。
        参数说明：
            参数                    说明
            input             一个数组，包含了要返回的键。
            search_value     如果指定了这个参数，只有包含这些值的键才会返回。
            strict             判断在搜索的时候是否该使用严格的比较（===）。
        返回值：返回 input 里的所有键。
        使用：
            代码：
                $array = array(0 => 100, "color" => "red");
                print_r(array_keys($array));

                $array = array("blue", "red", "green", "blue", "blue");
                print_r(array_keys($array, "blue"));

                $array = array("color" => array("blue", "red", "green"),
                               "size"  => array("small", "medium", "large"));
                print_r(array_keys($array));
            返回：
                Array
                (
                    [0] => 0
                    [1] => color
                )
                Array
                (
                    [0] => 0
                    [1] => 3
                    [2] => 4
                )
                Array
                (
                    [0] => color
                    [1] => size
                )
            
        6、array_values — 返回数组中所有的值
            语法：array array_values ( array $array )    //array_values() 返回 input 数组中所有的值并给其建立数字索引。
            使用：
                $array = [
                    [1,2],
                    [3,4]
                ];
                var_export(array_values($array));
            返回：array ( 0 => array ( 0 => 1, 1 => 2, ), 1 => array ( 0 => 3, 1 => 4, ), )
            
        7、count — 计算数组中的单元数目，或对象中的属性个数 别名 sizeof()
            语法：int count ( mixed $array_or_countable [, int $mode = COUNT_NORMAL ] )
            
            
二、合并/增加：
    1、array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
        语法：array array_combine ( array $keys , array $values )    //返回一个 array，用来自 keys 数组的值作为键名，来自 values 数组的值作为相应的值。
        参数说明：
            参数    说明
            keys    将被作为新数组的键。非法的值将会被转换为字符串类型（string）
            values    将被作为 Array 的值。
        返回值：返回合并的array，如果两个数组的单元数不同则返回 FALSE。
        错误/异常：如果作为keys的数组和作为values的数组的元素个数不一样，将会抛出一个警告错误（E_WARNING）。
        使用：
            $a = [ 1,2,3, 4,5,6 ];
            $b = ['one', 'tow', 'three', 'four', 'five', 'six'];
            $c = array_combine($a, $b);
            var_export($c);    //array ( 1 => 'one', 2 => 'tow', 3 => 'three', 4 => 'four', 5 => 'five', 6 => 'six', )
    
    2、array_shift — 将数组开头的单元移出数组
        语法：mixed array_shift ( array &$array )        //array_shift() 将 array 的第一个单元移出并作为结果返回，将 array 的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数，文字键名将不变。
        Note: 使用此函数后会重置（reset()）array 指针。
        返回值：返回移出的值，如果 array 为 空或不是一个数组则返回 NULL
        使用：
            $stack = array("orange", "banana", "apple", "raspberry");
            $fruit = array_shift($stack);
            var_export($stack);    //array ( 0 => 'banana', 1 => 'apple', 2 => 'raspberry', )
            var_export($fruit);    //'orange'
            
    3、array_pop — 弹出数组最后一个单元（出栈）
        语法：mixed array_pop ( array &$array )        //弹出并返回 array 数组的最后一个单元，并将数组 array 的长度减一。
        Note：使用此函数后会重置（reset()）array 指针。
        返回值：返回 array 的最后一个值。如果 array 是空（如果不是一个数组），将会返回 NULL 。
        使用：
            $stack = array("orange", "banana", "apple", "raspberry");
            $fruit = array_pop($stack);
            var_export($stack);    //array ( 0 => 'orange', 1 => 'banana', 2 => 'apple', )
            var_export($fruit);    //'raspberry'
            
    4、array_unshift — 在数组开头插入一个或多个单元
        语法：int array_unshift ( array &$array , mixed $value1 [, mixed $... ] )    //array_unshift() 将传入的单元插入到 array 数组的开头。注意单元是作为整体被插入的，因此传入单元将保持同样的顺序。所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变。
        参数说明：
            参数    说明
            array     输入的数组。
            value1     开头插入的变量。
        返回：返回 array 数组新的单元数目。
        使用：
            $queue = array("orange", "banana");
            $cnt = array_unshift($queue, "apple", "raspberry");
            var_export($queue);    //array ( 0 => 'apple', 1 => 'raspberry', 2 => 'orange', 3 => 'banana', )
            var_export($cnt);    //4
            
    5、array_push — 将一个或多个单元压入数组的末尾（入栈）
        语法：
            int array_push ( array &$array , mixed $value1 [, mixed $... ] )
                array_push() 将 array 当成一个栈，并将传入的变量压入 array 的末尾。array 的长度将根据入栈变量的数目增加。和如下效果相同：
                $array[] = $var;
                如果用 array_push() 来给数组增加一个单元，还不如用 $array[] = ，因为这样没有调用函数的额外负担。
        参数说明：
            参数        说明
            array     输入的数组。
            value1     要压入 array 末尾的第一个值。
        返回值：返回处理之后数组的元素个数。
        使用：
            $queue = array("orange", "banana");
            $cnt = array_push($queue, "apple", "raspberry");
            var_export($queue);    //array ( 0 => 'orange', 1 => 'banana', 2 => 'apple', 3 => 'raspberry', )
            var_export($cnt);    //4

            
三、截取/重组：
    1、array_slice — 从数组中取出一段
        语法：array array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = false ]] )    //array_slice() 返回根据 offset 和 length 参数所指定的 array 数组中的一段序列。
        参数说明：
            参数                说明
            array            输入的数组。
            offset            如果 offset 非负，则序列将从 array 中的此偏移量开始。如果 offset 为负，则序列将从 array 中距离末端这么远的地方开始。
            length            如果给出了 length 并且为正，则序列中将具有这么多的单元。如果给出了 length 并且为负，则序列将终止在距离数组末端这么远的地方。如果省略，则序列将从 offset 开始一直到 array 的末端。
            preserve_keys   array_slice默认会重新排序并重置数组的数字索引。你可以通过将 preserve_keys 设为 TRUE 来改变此行为。
        返回值：
            返回其中一段。 如果 offset 参数大于 array 尺寸，就会返回空的 array。
        使用：
            $input = array( 3=>"a", 2=>"c", 5=>"b", 1=>"e", 4=>"d");
            $output1 = array_slice($input, 2);                 //array ( 0 => 'b', 1 => 'e', 2 => 'd', )
            $output2 = array_slice($input, -2, 1);          //array ( 0 => 'e', )
            $output3 = array_slice($input, 0, 3);           //array ( 0 => 'a', 1 => 'c', 2 => 'b', )
            $output4 = array_slice($input, -2, 1, true);      //array ( 1 => 'e', )
            $output5 = array_slice($input, 0, 3, true);       //array ( 3 => 'a', 2 => 'c', 5 => 'b', )
            
    2、array_column — 返回数组中指定的一列
        语法：array array_column ( array $input , mixed $column_key [, mixed $index_key = null ] )    //array_column() 返回input数组中键值为column_key的列， 如果指定了可选参数index_key，那么input数组中的这一列的值将作为返回数组中对应值的键。
        参数说明：
            参数        说明
            input        被操作数组
            column_key     需要返回值的列
            index_key    作为返回数组的索引/键的列
        使用：
            $array = [
                ['id'=>999, 'name'=>'aaa'],
                ['id'=>777, 'name'=>'ccc'],
                ['id'=>888, 'name'=>'bbb'],
            ];
            $arr =  array_column($array, 'name');
            $arr1 = array_column($array, 'name', 'id');
            var_export($arr);    //array ( 0 => 'aaa', 1 => 'ccc', 2 => 'bbb', )
            var_export($arr1);    //array ( 999 => 'aaa', 777 => 'ccc', 888 => 'bbb', )
    
    
四、排序：
    1、一维数组排序：以sort为例：
        语法：bool sort ( array &$array [, int $sort_flags = SORT_REGULAR ] )
        参数说明：
            参数            说明
            array         要排序的数组。
            sort_flags     
                        可选的第二个参数 sort_flags 可以用以下值改变排序的行为：
                            SORT_REGULAR - 正常比较单元（不改变类型）
                            SORT_NUMERIC - 单元被作为数字来比较
                            SORT_STRING - 单元被作为字符串来比较
                            SORT_LOCALE_STRING - 根据当前的区域（locale）设置来把单元当作字符串比较，可以用 setlocale() 来改变。
                            SORT_NATURAL - 和 natsort() 类似对每个单元以“自然的顺序”对字符串进行排序。 PHP 5.4.0 中新增的。
                            SORT_FLAG_CASE - 能够与 SORT_STRING 或 SORT_NATURAL 合并（OR 位运算），不区分大小写排序字符
        返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
    
        类似函数：
            sort() -  根据值，以升序对数组排序[索引重置]
            rsort() - 根据值，以降序对数组排序[索引重置]
            asort() - 根据值，以升序对关联数组进行排序[保持索引关系]
            ksort() - 根据键，以升序对关联数组进行排序[保持索引关系]
            arsort() - 根据值，以降序对关联数组进行排序[保持索引关系]
            krsort() - 根据键，以降序对关联数组进行排序[保持索引关系]
        使用：
            代码：
                $array1 = [ 3=>'three', 5=>'five', 4=>'four', 1=>'one', 2=>'two' ];
                $array = $array1; sort($array);     var_export($array);    echo '
';
                $array = $array1; rsort($array);    var_export($array); echo '
';
                $array = $array1; asort($array);    var_export($array); echo '
';
                $array = $array1; ksort($array);    var_export($array); echo '
';
                $array = $array1; arsort($array);    var_export($array); echo '
';
                $array = $array1; krsort($array);    var_export($array); echo '
';
            打印：
                array ( 0 => 'five', 1 => 'four', 2 => 'one', 3 => 'three', 4 => 'two', )
                array ( 0 => 'two', 1 => 'three', 2 => 'one', 3 => 'four', 4 => 'five', )
                array ( 5 => 'five', 4 => 'four', 1 => 'one', 3 => 'three', 2 => 'two', )
                array ( 1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four', 5 => 'five', )
                array ( 2 => 'two', 3 => 'three', 1 => 'one', 4 => 'four', 5 => 'five', )
                array ( 5 => 'five', 4 => 'four', 3 => 'three', 2 => 'two', 1 => 'one', )

    2、多维数组排序
        array_multisort — 对多个数组或多维数组进行排序
        语法：
            bool array_multisort ( array &$array1 [, mixed $array1_sort_order = SORT_ASC [, mixed $array1_sort_flags = SORT_REGULAR [, mixed $... ]]] )
            array_multisort() 可以用来一次对多个数组进行排序，或者根据某一维或多维对多维数组进行排序。
        参数说明：
            参数                    说明
            array1                 要排序的 array。
            array1_sort_order     之前 array 参数要排列的顺序。 SORT_ASC 按照上升顺序排序， SORT_DESC 按照下降顺序排序。
                                [此参数可以和 array1_sort_flags 互换]，也可以完全删除，默认是 SORT_ASC 。
            array1_sort_flags    为 array 参数设定选项(同一维数组)
        返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
        使用：
            1)、多个数组排序
                $arr = [ 3, 7, 6, 1 ];
                $arr2 = [ 'three', 'seven', 'six', 'one' ];
                $arr3 = [ 6, 14, 12, 2 ];
                array_multisort($arr, $arr2, $arr3);
                var_export($arr); echo '
';        //array ( 0 => 1, 1 => 3, 2 => 6, 3 => 7, )
                var_export($arr2); echo '
';    //array ( 0 => 'one', 1 => 'three', 2 => 'six', 3 => 'seven', )
                var_export($arr3); echo '
';    //array ( 0 => 2, 1 => 6, 2 => 12, 3 => 14, )
                分析：
                    如果多个数组的元素个数不同，则报错；
                    第一个项目排序之后，其他的项目的位置也跟随第一个项目的位置移动了。
            2)、排序多维数组
                $arr = [
                    [ 9, '7', 6, 1, 3 ],
                    [ 'nine', 'seven', '6', 1, 3 ],
                ];
                array_multisort($arr[0], SORT_ASC, SORT_STRING,    //array1_sort_order与array1_sort_flags参数位置可互换
                        $arr[1], SORT_NUMERIC, SORT_DESC);
                var_export($arr);    //array ( 0 => array ( 0 => 1, 1 => 3, 2 => 6, 3 => '7', 4 => 9, ), 1 => array ( 0 => 1, 1 => 3, 2 => '6', 3 => 'seven', 4 => 'nine', ), )
                分析：
                    $arr[0]被当作字符串以升序排列；$arr[1]被当作数字以降序排列。
                    [返回的怎么还是和1)、一样的，$arr[1]的顺序完全取决于$arr[0]]...???
            3、对数据库查询结果进行排序
                代码：
                    //先根据like降序，然后根据age升序
                    $arr = [
                            ['like'=>99, 'age'=>18],
                            ['like'=>77, 'age'=>23],
                            ['like'=>111, 'age'=>8],
                            ['like'=>66, 'age'=>24],
                            ['like'=>33, 'age'=>21],
                            ['like'=>99, 'age'=>31],
                    ];
                    $likeArr = array_column($arr, 'like');
                    $ageArr = array_column($arr, 'age');
                    array_multisort($likeArr, SORT_DESC, $ageArr, SORT_ASC, $arr);
                    var_export($arr);
                打印：
                    array ( 0 => array ( 'like' => 111, 'age' => 8, ),
                            1 => array ( 'like' => 99, 'age' => 18, ),
                            2 => array ( 'like' => 99, 'age' => 31, ),
                            3 => array ( 'like' => 77, 'age' => 23, ),
                            4 => array ( 'like' => 66, 'age' => 24, ),
                            5 => array ( 'like' => 33, 'age' => 21, ),
                    )


                    
五、并集/交集/差集：
    1、array_merge — 合并一个或多个数组(索引重置)
        语法：
            array array_merge ( array $array1 [, array $... ] )    
                将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。
                如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。
                然而，如果数组包含相同的数字键名，后面的值将不会覆盖原来的值，而是附加到后面。
        参数说明：
            参数    说明
            array1    要合并的第一个数组
            ...        要合并的n个数组
        返回值：返回结果数组
        使用：
            1)、字符串键名相同
                $arr1 = ['color'=>'red', 1, 3, 1=>'one'];
                $arr2 = ['color'=>'blue', 'hobby'=>'eat', 2 ];
                $arr3 = array_merge($arr1, $arr2);
                var_export($arr3);    //array ( 'color' => 'blue', 0 => 1, 1 => 'one', 'hobby' => 'eat', 2 => 2, )
                                //$arr1 0=>1, 1=>3, 1=>'one' 后面的one覆盖了前面的3
            2)、数组键名相同
                $arr1 = [1=>'one', 1, 3, ];
                $arr2 = [1=>'nine', 'hobby'=>'eat', 2 ];
                $arr3 = array_merge($arr1, $arr2);
                var_export($arr3);    //array ( 0 => 'one', 1 => 1, 2 => 3, 3 => 'nine', 'hobby' => 'eat', 4 => 2, )
            3)、正常合并
                $arr1 = [1=>'one', 1, 3, ];
                $arr3 = array_merge($arr1, ['age'=>99]);
                var_export($arr3);    //array ( 0 => 'one', 1 => 1, 2 => 3, 'age' => 99, )
            4)、如果你想完全保留原有数组并只想新的数组附加到后面，用 + 运算符： 在两个数组中存在相同的键名时，第一个数组中的同键名的元素将会被保留，第二个数组中的元素将会被忽略
                $arr1 = ['color'=>'red', 1, 3, 1=>'one'];
                $arr2 = ['color'=>'blue', 'hobby'=>'eat', 1=>'nine', 2 ];
                $arr3 = $arr1 + $arr2;
                var_export($arr3);    //array ( 'color' => 'red', 0 => 1, 1 => 'one', 'hobby' => 'eat', 2 => 2, )
            5)、其他类型
                (1)、合并空数组
                    $arr1 = [];
                    $arr2 = [99=>'abc'];
                    $arr3 = array_merge($arr1,$arr2);
                    var_export($arr3);    // array ( 0 => 'abc', )
                (2)、合并非数组
                    $str = 'aaa';
                    $arr2 = [99=>'bbb'];
                    $arr3 = array_merge( (array)$str,$arr2 );
                    var_export($arr3);    // array ( 0 => 'aaa', 1 => 'bbb', )
                    
    2、array_intersect — 计算数组的交集
        语法：array array_intersect ( array $array1 , array $array2 [, array $... ] )    //返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意array1键名保留不变。
        参数说明：
            参数        说明
            array1         要检查的数组，作为主值。
            array2         要被对比的数组。
            ...           要对比的数组列表。
        返回：返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。
        使用：
            1)、
                $arr1 = ['color'=>'blue', 1, 2, 1=>'one'];
                $arr2 = ['attr'=>'blue', 2 ];
                $arr3 = array_intersect($arr1, $arr2);
                var_export($arr3);    //array ( 'color' => 'blue', )
                分析：为什么输出的结果中没有2，原因：因为$arr1中的2的键是1，被后面的'one'给覆盖了...
            2)、改一下1)、中的 1=>'one'  为  2=>'one'
                $arr1 = ['color'=>'blue', 1, 2, 2=>'one'];
                $arr2 = ['attr'=>'blue', 2 ];
                $arr3 = array_intersect($arr1, $arr2);
                var_export($arr3);    //array ( 'color' => 'blue', 1 => 2, )
        
    3、array_intersect_assoc — 带索引检查计算数组的交集
        (同2[array_intersect]，只是键名也要比较)
    
    4、array_diff — 计算数组的差集
        语法：array array_diff ( array $array1 , array $array2 [, array $... ] )        //对比 array1 和其他一个或者多个数字，返回在 array1 中但是不在其他 array 里的值。
        参数说明：
            参数        说明
            array1     要被对比的数组
            array2     和这个数组进行比较
            ...     更多相比较的数组
        返回值：返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意array1键名保留不变。
        使用：
            $arr1 = ['color'=>'blue', 1, 2, 2=>'one'];
            $arr2 = ['attr'=>'blue', 2 ];
            $arr3 = array_diff($arr1, $arr2);
            var_export($arr3);    //array ( 0 => 1, 2 => 'one', )
        Note:注意本函数只检查了多维数组中的一维。当然可以用 array_diff($array1[0], $array2[0]); 检查更深的维度。
        
    5、array_diff_assoc — 带索引检查计算数组的差集
        (同4[array_diff]，只是键名也要比较)

        
六、循环：            
1、foreach()循环：foreach 仅能够应用于数组和对象
    1)、语法：
        1)、foreach (array_expression as $value)
                statement
        2)、foreach (array_expression as $key => $value)
                statement
    2)、使用：
        $arr = [1, 2, 3, 4, 5];
        foreach ($arr as &$value) {
            $value = $value * 2;
        }
        //array is [2,4,6,8,10]
        unset($value); // 最后取消掉引用
    3)、foreach与list异曲同工
        (1)、功能完全相同
            $arr = array("one", "two", "three");
            reset($arr);
            while (list(, $value) = each($arr)) {
                echo "Value: $value
\n";
            }

            foreach ($arr as $value) {
                echo "Value: $value
\n";
            }
        (2)、功能完全相同
            $arr = array("one", "two", "three");
            reset($arr);
            while (list($key, $value) = each($arr)) {
                echo "Key: $key; Value: $value
\n";
            }

            foreach ($arr as $key => $value) {
                echo "Key: $key; Value: $value
\n";
            }
    4)、用 list() 给嵌套的数组解包
            (1)、list单元等于嵌套数组的
                $array = [
                    [1,2],
                    [3,4]
                ];
                foreach($array as list($a, $b)){
                    echo "A:{$a}; B:{$b}
";
                }
                打印：
                    A:1; B:2
                    A:3; B:4
            (2)、list单元少于嵌套数组的，多出来的被忽略
                $array = [
                    [1,2],
                    [3,4]
                ];
                foreach($array as list($a)){
                    echo "A:{$a};
";
                }
                打印：
                    A:1;
                    A:3;
            (3)、list单元多于嵌套数组则会发出一条消息级别的错误信息
                $array = [
                    [1,2],
                    [3,4]
                ];
                foreach($array as list($a, $b, $c)){
                    echo "A:{$a}; B:{$b}; C:{$c}
";
                }
                打印：
                    Notice: Undefined offset: 2 in Test.php on line 17
                    A:1; B:2; C:

                    Notice: Undefined offset: 2 in Test.php on line 17
                    A:3; B:4; C:
    
    2、for循环数组自增
        $data = [];
        for($x=0;$x<4;$x++){
            $data[] = ['id'=>$x+1, 'val'=>mt_rand(10,99)];
        }
        var_export($data);    //array ( 0 => array ( 'id' => 1, 'val' => 70, ), 1 => array ( 'id' => 2, 'val' => 81, ), 2 => array ( 'id' => 3, 'val' => 27, ), 3 => array ( 'id' => 4, 'val' => 63, ), )