《PHP 7从零基础到项目实战》学习笔记5——数组

悠悠 2023-02-14 03:07 37阅读 0赞

### 第5章 数组 ###

*   *  5.1 使用数组
     *   *  5.1.1 数组类型
         *  5.1.2 创建数组
     *  5.2 二维数组和多维数组
     *   *  5.2.1 二维数组
         *  5.2.2 多维数组
     *  5.3 数组操作
     *   *  5.3.1 检查数组中是否存在某个值
         *  5.3.2 数组转换成字符串
         *  5.3.3 计算数组中的单元数目
         *  5.3.4 数组当前单元和数组指针
         *  5.3.5 数组中的键名和值
         *  5.3.6 填补数组
         *  5.3.7 从数组中随机取出一个或多个单元
         *  5.3.8 数组排序与打乱数组
         *  5.3.9 遍历数组
         *  5.3.10 数组的拆分与合并
         *  5.3.11 增加/删除数组中的元素
         *  5.3.12 其他常用数组函数
     *  5.4 系统预定义函数
     *   *  5.4.1 $\_SERVER
         *  5.4.2 $\_GET和\\$\_POST数组
         *  5.4.3 $\_FILES数组
         *  5.4.4 $\_SESSION和\\$\_COOKIE数组
         *  5.4.5 $\_REQUEST\[\]数组

> 数组的本质是用来存储、管理和操作一组变量的。PHP中的数组实际上是一个有序映射，映射是一种把values关联到keys的类型。

## 5.1 使用数组 ##

> 数组是把一些列数据组织起来，形成一个可操作的整体，数组的实体由键和值组成，键值是成对出现的，是一一对应的关系。一维数组只能保存一列数据内容，从表现形式来看，就是这个数组的所有值只能是标量数据类型和除数组之外的复合数据类型。而当数组的元素有一个或多个一维数组时，便是二维数组，以此类推。数组的指针是数组内部指向数组元素的标记。

### 5.1.1 数组类型 ###

> PHP中有两种类型的数组，即索引数组和关联数组。索引数组的键由数字组成，在没有特别制定时，数组默认为索引数组。关联数组的键由字符串和数字混合组成。

（1）关联数组

$array = array('a' => 'foo', 'b' => 'bar')

（2）索引数组

$array = array(1=>'foo', 2=>'bar')

在数组中，如果未指定键，PHP就将自动使用之前用过的最大的数字键加上1作为新的键。

<?php
    $array1 = array("foo", "bar", "hello", "world");
    var_dump($array1);
    echo "\n";
    $array2 = array("a", "b", 6=>"c", "d");
    var_dump($array2);
    ?>

array(4) {
      [0]=>
      string(3) "foo"
      [1]=>
      string(3) "bar"
      [2]=>
      string(5) "hello"
      [3]=>
      string(5) "world"
    }
    
    array(4) {
      [0]=>
      string(1) "a"
      [1]=>
      string(1) "b"
      [6]=>
      string(1) "c"
      [7]=>
      string(1) "d"
    }

### 5.1.2 创建数组 ###

可以使用array()创建数组，除此之外还可以使用方括号“\[\]”创建数组。

<?php
    $arr['a'] = 'red';
    $arr['b'] = 'green';
    $arr['c'] = 'blue';
    var_dump($arr);
    echo "\n";
    $array = ['dog', 'cat', 'wolf', 'fish'];
    var_dump($array);
    $bar[] = 'a';
    $bar[] = 'b';
    $bar[] = 'c';
    var_dump($bar);
    ?>

array(3) {
      ["a"]=>
      string(3) "red"
      ["b"]=>
      string(5) "green"
      ["c"]=>
      string(4) "blue"
    }
    
    array(4) {
      [0]=>
      string(3) "dog"
      [1]=>
      string(3) "cat"
      [2]=>
      string(4) "wolf"
      [3]=>
      string(4) "fish"
    }
    array(3) {
      [0]=>
      string(1) "a"
      [1]=>
      string(1) "b"
      [2]=>
      string(1) "c"
    }

还可以使用range()来建立一个包含指定范围单元的数组。语法如下：

array range(mixed $start, mixed $limit [, number $step = 1])

> start是序列的第一个值，序列结束于limit的值。如果给出了step的值，它将被作为单元之间的步进值。step应该为正值，如果未指定，step默认为1。该函数将会创建一个元素值在start和limit之间的数组。

<?php
    $a = range(0, 5);
    $b = range(0, 5, 2);
    $c = range(a, g);
    $d = range(a, g, 2);
    echo "\n";
    print_r($a);
    print_r($b);
    print_r($c);
    print_r($d);
    ?>

Array
    (
        [0] => 0
        [1] => 1
        [2] => 2
        [3] => 3
        [4] => 4
        [5] => 5
    )
    Array
    (
        [0] => 0
        [1] => 2
        [2] => 4
    )
    Array
    (
        [0] => a
        [1] => b
        [2] => c
        [3] => d
        [4] => e
        [5] => f
        [6] => g
    )
    Array
    (
        [0] => a
        [1] => c
        [2] => e
        [3] => g
    )

## 5.2 二维数组和多维数组 ##

### 5.2.1 二维数组 ###

将两个一维数组组合起来就可以构成一个二维数组，使用二维数组可以保存较为复杂的数据，在一些场合经常用到。

<?php
    $person = array(
        'Tom'=>array('age'=>18, 'weight'=>'50kg', 'hobby'=>'study'),
        'Jack'=>array('age'=>16, 'weight'=>'60kg', 'hobby'=>'music')
        );
    print_r($person);
    ?>

Array
    (
        [Tom] => Array
            (
                [age] => 18
                [weight] => 50kg
                [hobby] => study
            )
    
        [Jack] => Array
            (
                [age] => 16
                [weight] => 60kg
                [hobby] => music
            )
    
    )

### 5.2.2 多维数组 ###

<?php
    $arr = array(
        '安徽'=>array(
            '阜阳'=>array('阜南县', '临泉县', '颍川区'),
            '宿州'=>array('墉桥区', '灵璧县', '泗县'),
            '合肥'=>array('蜀山区', '长丰县', '肥东')),
        '广东'=>array(
            '广州'=>array('天河区', '白云区', '黄埔区'),
            '湛江'=>array('赤坎区', '霞山区', '麻章区')
        )
    );
    print_r($arr);
    echo $arr['安徽']['宿州'][0]; // 墉桥区
    var_dump($arr['广东']['广州']);
    ?>

Array
    (
        [安徽] => Array
            (
                [阜阳] => Array
                    (
                        [0] => 阜南县
                        [1] => 临泉县
                        [2] => 颍川区
                    )
    
                [宿州] => Array
                    (
                        [0] => 墉桥区
                        [1] => 灵璧县
                        [2] => 泗县
                    )
    
                [合肥] => Array
                    (
                        [0] => 蜀山区
                        [1] => 长丰县
                        [2] => 肥东
                    )
    
            )
    
        [广东] => Array
            (
                [广州] => Array
                    (
                        [0] => 天河区
                        [1] => 白云区
                        [2] => 黄埔区
                    )
    
                [湛江] => Array
                    (
                        [0] => 赤坎区
                        [1] => 霞山区
                        [2] => 麻章区
                    )
    
            )
    
    )
    墉桥区
    array(3) {
      [0]=>
      string(9) "天河区"
      [1]=>
      string(9) "白云区"
      [2]=>
      string(9) "黄埔区"
    }

## 5.3 数组操作 ##

### 5.3.1 检查数组中是否存在某个值 ###

PHP中可使用in\_array()函数判断数组中是否存在某个值，语法如下：

bool in_array(mixed $needle, array $haystack [, bool $strict = FALSE])

\*\*说明：\*\*在haystack中搜索needle，如果没有设置strict，就使用宽松的比较。如果strict的值为true，则in\_array()函数还会检查needle的类型是否与haystack中的一致。注意，in\_array()函数只能在当前维度数组中检查是否存在某个元素。

<?php
    $arr = array(
        '安徽'=>array(
            '阜阳'=>array('阜南县', '临泉县', '颍川区'),
            '宿州'=>array('墉桥区', '灵璧县', '泗县'),
            '合肥'=>array('蜀山区', '长丰县', '肥东')),
        '广东'=>array(
            '广州'=>array('天河区', '白云区', '黄埔区'),
            '湛江'=>array('赤坎区', '霞山区', '麻章区')
        )
    );
    var_dump(in_array('阜南县', $arr)); // bool(false)
    $arr1 = ['red', 'green', 'blue'];
    var_dump(in_array('green', $arr1)); // bool(true)
    ?>

### 5.3.2 数组转换成字符串 ###

使用implode()函数可将一个一维数组转换成字符串。语法如下：

string implode(string $glue, array $pieces)

\*\*说明：\*\*该函数返回一个由glue分割后的数组的值组成的字符串。

<?php
    // 声明数组
    $array = array('a', 'b', 'c', 'd', 'e');
    $str = implode(',', $array); // 分割数组
    echo $str; // a,b,c,d,e
    ?>

### 5.3.3 计算数组中的单元数目 ###

使用count()函数可计算数组中的单元数目，count()函数还可以计算对象中的属性个数。语法如下：

int count(mixed $var [, int $mode = COUNT_NORMAL])

\*\*说明：\*\*如果可选的mode参数设置为COUNT\_RECURSIVE或1，count()将递归对数组计数，对计算多维数组的所有单元尤其有用。mode的默认值为0.注意，count()识别不了无限递归。

<?php
    $food = array(
        'fruits'=>array('orange', 'banana', 'apple'),
        'veggie'=>array('carrot', 'collard', 'pea')
        );
    echo count($food, 1); // 8
    echo count($food); // 2
    ?>

### 5.3.4 数组当前单元和数组指针 ###

使用current()函数可返回数组的当前单元，语法如下：

mixed current(array &$array)

\*\*说明：\*\*每个数组中都有一个内部的指针指向它“当前的”单元，初始指向插入数组的第一个单元。

<?php
    $food = array('orange', 'banana', 'apple');
    var_dump(current($food)); // string(5) "orange"
    ?>

可以移动数组内部指针的4个函数：

*  end()：将数组的内部指针指向最后一个单元并返回其值。
 *  prev()：将数组的内部指针倒回一位，返回内部指针指向前一个单元的值，当没有更多单元时返回false。
 *  reset()：将数组的内部指针指向第一个单元并返回第一个数组单元的值。
 *  next()：将数组中的内部指针向前移动一位，返回数组内部指针指向的下一个单元的值，当没有更多单位时返回false。

<?php
    $food = array('orange', 'banana', 'apple'); // 声明数组
    var_dump(current($food)); // string(5) "orange"
    // 将数组内部指针向前移动一位
    echo next($food)."\n"; // banana
    // 输出当前数组指针指向的单元值
    echo current($food)."\n"; // banana
    // 将数组指针倒回一位
    echo prev($food)."\n"; // orange
    // 将数组指针指向最后一个单元
    echo end($food)."\n"; // apple
    // 将数组指针指向第一个单元
    echo reset($food)."\n"; // orange
    ?>

### 5.3.5 数组中的键名和值 ###

1.从关联数组中取得键名

使用key()函数可从关联数组中返回键名，语法如下：

mixed key(array &$array)

\*\*说明：\*\*key()函数返回数组中内部指针指向的当前单元的键名，但它不会移动指针。如果内部指针超过了元素列表尾部，或者数组是空的，key()就会返回NULL。

<?php
    $array = array(
        'fruit1' => 'apple',
        'fruit2' => 'orange',
        'fruit3' => 'grape',
        'fruit4' => 'pear'
    );
    // 循环数组
    for($i = 0; $i < count($array); $i++) { 
        // 输出指针指向当前单元的键
        echo key($array)."\n";
        next($array); // 将数组指针向前移动一位
    }
    ?>

fruit1
    fruit2
    fruit3
    fruit4

1.  检查给定键名或索引是否存在于数组中

> PHP中使用array\_key\_exists()函数检查给定键名或索引是否存在于数组中。语法如下：

bool array_key_exists(mixed $key, array $search)

\*\*说明：\*\*key可以是任何能作为数组索引的值。array\_key\_exists()也可用于对象。

<?php
    $search_array = array('first' => 1, 'second' => 4);
    // 检测数组中是否存在键first
    if(array_key_exists('first', $search_array)) { 
        echo "true\n";
    } else { 
        echo "false\n";
    }
    // true
    ?>

1.  获取数组中部分或所有的键名

> 使用array\_keys()函数可获得数组中部分或所有键名，语法如下：

array array_keys(array $array [, mixed $search_value [, bool $strict = false]])

\*\*说明：\*\*如果指定了可选参数search\_value，则只返回值为search\_value的键名，否则返回数组中所有的键名。$strict设为true时，搜索时使用严格的比较（===）。

<?php
    $array = array(0 => 100, 'color'=> 'green');
    print_r(array_keys($array));
    // Array
    // (
    // [0] => 0
    // [1] => color
    // )
    $array = array('java', 'c/c++', 'c#', 'python', 'php');
    // 返回数组中值为python的键
    print_r(array_keys($array, 'python'));
    // Array
    // (
    // [0] => 3
    // )
    $array = array(
        'color'=> array('red', 'green', 'blue'),
        'course'=> array('Math', 'English', 'Music', 'Art'));
    print_r(array_keys($array)); // 只返回当前维度的数组的键
    // Array
    // (
    // [0] => color
    // [1] => course
    // )
    ?>

1.  获取数组中所有的值

> 使用array\_values()函数可获得数组中所有的值，语法如下：

array array_values(array $input)

\*\*说明：\*\*array\_values()返回数组中所有的值并为其建立数字索引。

<?php
    $array = array('red', 'green', 'blue');
    print_r(array_values($array)); // 返回数组$array中所有的值
    ?>

Array
    (
        [0] => red
        [1] => green
        [2] => blue
    )

1.  搜索给定值返回键名

> 使用array\_search()函数可以在数组中搜索给定的值，值存在则返回相应的键名。语法如下：

mixed array_search(mixed $needle, array $haystack [, bool $strict = false])

**说明：**

*  如果在haystack中搜索到了needle，就返回它的键，否则返回false。
 *  如果needle在haystack中不止一次出现，就返回第一个匹配的键。
 *  要返回所有匹配值的键，应该用array\_keys()加上可选参数search\_value来代替。
 *  如果可选参数strict为true，那么array\_search()将在haystack中检查完全相同的元素。

<?php
    $array = array(0 => 'red', 1 => 'green', 2 => 'blue');
    $key = array_search('green', $array); // 查找数组中值为green的键
    echo $key; // 1
    $key = array_search('red', $array); // 查找数组中值为red的键
    echo $key; // 0
    ?>

### 5.3.6 填补数组 ###

1.  array\_pad()
    
    array\_pad()函数可用值将数组填补到指定长度，其语法如下：
    
        array array_pad(array $input, int $pad_size, mixed $pad_value)
    
    \*\*说明：\*\*array\_pad()返回数组的一个备份，并用 p a d v a l u e 将 其 填 补 到 pad\_value将其填补到 padvalue将其填补到pad\_size指定的长度。
    
     *  如果pad\_size为正，则填补到数组的右侧；若为负，则从左侧开始填充。
     *  如果pad\_size的绝对值小于或等于input数组的长度，则不做填充。
     *  一次最多可以填补1048576个单元。
    
        <?php
        $input = array(12, 10, 9);
        $result = array_pad($input, 5, 0); // 从数组右侧开始，用0填补数组到含有5个元素
        print_r($result);
        $result = array_pad($input , -7, -1); // 从数组左侧开始，用-1填补数组到含有7个元素
        print_r($result);
        $result = array_pad($input, 2, 'oo');
        print_r($result);
        ?>
    
        Array
        (
            [0] => 12
            [1] => 10
            [2] => 9
            [3] => 0
            [4] => 0
        )
        Array
        (
            [0] => -1
            [1] => -1
            [2] => -1
            [3] => -1
            [4] => 12
            [5] => 10
            [6] => 9
        )
        Array
        (
            [0] => 12
            [1] => 10
            [2] => 9
        )
2.  array\_fill()

> array\_fill()函数可以用给定的值填充数组。语法如下：

array array_fill(int $start_index, int $num, mixed $value)

<?php
    $a = array_fill(5, 6, 'banana'); // 使用banana填充数组到6个元素，索引键由数字5开始
    $b = array_fill(-2, 4, 'pear'); // 使用pear填充数组到4个元素，索引键由-2开始
    $c = array_fill(3, 2, array('red', 'green', 'blue')); // 用一个数组填充成一个二维数组
    print_r($a);
    print_r($b);
    print_r($c);
    ?>

Array
    (
        [5] => banana
        [6] => banana
        [7] => banana
        [8] => banana
        [9] => banana
        [10] => banana
    )
    Array
    (
        [-2] => pear
        [0] => pear
        [1] => pear
        [2] => pear
    )
    Array
    (
        [3] => Array
            (
                [0] => red
                [1] => green
                [2] => blue
            )
    
        [4] => Array
            (
                [0] => red
                [1] => green
                [2] => blue
            )
    
    )

1.  array\_fill\_keys()

array\_fill\_keys()函数使用指定的键和值填充数组。语法如下：

array array_fill_keys(array $keys, mixed $value)

\*\*说明：\*\*使用 v a l u e 参 数 的 值 作 为 值 ， 使 用 value参数的值作为值，使用 value参数的值作为值，使用keys数组的值作为键，填充数组，并返回填充后的数组。

<?php
    $keys = array('foo', 5, 10, 'bar');
    $a = array_fill_keys($keys, 'banana'); // 使用$keys数组的值作为键，banana作为值，重新组建一个数组
    $b = array_fill_keys($keys, array('red', 'green', 'blue')); // 使用$keys的值作为键，另一个数组为元素，组成一个新的二维数组
    print_r($a);
    print_r($b);
    ?>

Array
    (
        [foo] => banana
        [5] => banana
        [10] => banana
        [bar] => banana
    )
    Array
    (
        [foo] => Array
            (
                [0] => red
                [1] => green
                [2] => blue
            )
    
        [5] => Array
            (
                [0] => red
                [1] => green
                [2] => blue
            )
    
        [10] => Array
            (
                [0] => red
                [1] => green
                [2] => blue
            )
    
        [bar] => Array
            (
                [0] => red
                [1] => green
                [2] => blue
            )
    
    )

### 5.3.7 从数组中随机取出一个或多个单元 ###

array\_rand()函数可从数组中取出一个或多个随机的单元，并返回随即条目的一个或多个键。语法如下：

mixed array_rand(array $input [, int $num_req = 1])

\*\*说明：\*\*input是输入的数组，num\_req指明需要输出多少个单元。

*  如果指定的数目超出了数组的长度，将会产生一个E\_WARNING级别的错误。
 *  如果只取出一个，，则array\_rand()将返回一个随机单元的键名，否则返回一个包含随机键名的数组。

<?php
    $input = array('Beijing', 'Shanghai', 'Shenzhen', 'Guangzhou');
    $rand_keys = array_rand($input, 2); // 从$input数组中随机取出两个单元，组成一个新的数组返回
    print_r($rand_keys);
    ?>

Array
    (
        [0] => 0
        [1] => 1
    )

### 5.3.8 数组排序与打乱数组 ###

1.  sort()

sort()函数可实现对数组的排序，语法如下：

bool sort(array &$array [, int $sort_flags = SORT_REGULAR])

**说明：**

*  SORT\_REGULAR：正常比较单元（不改变类型）
 *  SORT\_NUMERIC：单元被作为数字来比较
 *  SORT\_STRING：单元被作为字符串来比较
 *  SORT\_LOCALE\_STRING：根据当前的区域(locale)设置把单元当作字符串比较，可以用setlocale()来改变
 *  SORT\_NATURAL：和natsort()类似，对每个单元以“自然的顺序”对字符串进行排序
 *  SORT\_FLAG\_CASE：能够与SORT\_STRING或SORT\_NATURAL合并(OR位运算)，不区分大小写培训字符串

<?php
    $fruits = array('apple', 'orange', 'banana', 'lemon');
    sort($fruits); // 数字排序
    print_r($fruits);
    ?>

Array
    (
        [0] => apple
        [1] => banana
        [2] => lemon
        [3] => orange
    )

1.  asort()

asort()函数对数组进行排序并保持索引关系。语法如下：

bool asort(array &$array [, int $sort_flage = SORT_REGULAR])

<?php
    $fruits = array('d' => 'lemon', 'a' => 'orange', 'b' => 'banana', 'c' => 'apple');
    asort($fruits); // 数组排序
    print_r($fruits);
    ?>

Array
    (
        [c] => apple
        [b] => banana
        [d] => lemon
        [a] => orange
    )

1.  arsort()

arsort()函数对数组进行逆向排序并保持索引关系。语法如下：

bool arsort(array &$array [, int $sort_flage = SORT_REGULAR])

<?php
    $fruits = array('d' => 'lemon', 'a' => 'orange', 'b' => 'banana', 'c' => 'apple');
    asort($fruits); // 数组排序
    print_r($fruits);
    arsort($fruits); // 数组逆向排序
    print_r($fruits);
    ?>

Array
    (
        [c] => apple
        [b] => banana
        [d] => lemon
        [a] => orange
    )
    Array
    (
        [a] => orange
        [d] => lemon
        [b] => banana
        [c] => apple
    )

1.  rsort()

rsort()函数可对数组进行逆向排序，但不保存索引关系。语法如下：

bool rsort(array &$array [, int sort_flage = SORT_REGULAR])

Array
    (
        [c] => apple
        [b] => banana
        [d] => lemon
        [a] => orange
    )
    Array
    (
        [a] => orange
        [d] => lemon
        [b] => banana
        [c] => apple
    )
    Array
    (
        [0] => orange
        [1] => lemon
        [2] => banana
        [3] => apple
    )

1.  shuffle()

shuffle()函数将数组打乱。语法如下：

bool shuffle(array &$array)

<?php
    $numbers = range(1, 20);
    shuffle($numbers); // 打扰数组顺序
    foreach ($numbers as $number) { 
        echo "$number";
    }
    // 9611191782014181510541316137212
    ?>

### 5.3.9 遍历数组 ###

常用for、foreach、each、list对数组进行遍历。

1.for循环遍历数组

<?php
    $fruit = array('lemon', 'orange', 'banana', 'apple');
    for($i = 0; $i < count($fruit); $i++) { 
        echo current($fruit)."\n";
        echo $fruit[$i]."\n";
    }
    ?>

lemon
    lemon
    lemon
    orange
    lemon
    banana
    lemon
    apple

1.  foreach遍历数组

$array = [0, 1, 2];
    // 遍历数组
    foreach ($array as &$val) { 
        echo $val;
    }
    // 012

1.  each()和list()

<?php
    $foo = array('bob', 'fred', 'jussi', 'jouni', 'egon');
    $bar1 = each($foo); // 指针向后移动一步
    print_r($bar1);
    echo current($foo); // 当指针指向值
    $bar2 = each($foo);
    print_r($bar2);
    echo current($foo);
    ?>

Array
    (
        [1] => bob
        [value] => bob
        [0] => 0
        [key] => 0
    )
    fredArray
    (
        [1] => fred
        [value] => fred
        [0] => 1
        [key] => 1
    )
    jussi

each()函数和list()函数结合可以遍历数组。（PHP 7改变了list()赋值的顺序，由原来的倒序赋值改成了正序赋值。

<?php
    $fruit = array('a' => 'apple', 'b' => 'banana', 'c' => 'cranberry');
    while(list($key, $val) = each($fruit)) { 
        echo "$key => $val\n";
    }

a => apple
    b => banana
    c => cranberry

### 5.3.10 数组的拆分与合并 ###

1.  array\_chunk()：将一个数组分割成多个。

<?php
    $input_array = array('a' => array('x', 'y'), 'b', 'c', 'd', 'e');
    print_r(array_chunk($input_array, 2));
    print_r(array_chunk($input_array, 2, true)); // 设置参数为true，保留原来的键名

Array
    (
        [0] => Array
            (
                [0] => Array
                    (
                        [0] => x
                        [1] => y
                    )
    
                [1] => b
            )
    
        [1] => Array
            (
                [0] => c
                [1] => d
            )
    
        [2] => Array
            (
                [0] => e
            )
    
    )
    Array
    (
        [0] => Array
            (
                [a] => Array
                    (
                        [0] => x
                        [1] => y
                    )
    
                [0] => b
            )
    
        [1] => Array
            (
                [1] => c
                [2] => d
            )
    
        [2] => Array
            (
                [3] => e
            )
    
    )

1.  array\_merge()

<?php
    $arr1 = array('color'=>'red', 2, 4);
    $arr2 = array('a', 'b', 'color'=>'green');
    $result = array_merge($arr1, $arr2);
    print_r($result);
    ?>

Array
    (
        [color] => green
        [0] => 2
        [1] => 4
        [2] => a
        [3] => b
    )

如果想完全保留原数组，且只想将新数组附加到后面，可用“+”运算符。

<?php
    $arr1 = array(0=>'zero', 2=>'two', 3=>'three');
    $arr2 = array(1=>'one_b', 3 => 'three_b', 4=>'four_b');
    $result = $arr1 + $arr2;
    var_dump($result);
    ?>

array(5) {
      [0]=>
      string(4) "zero"
      [2]=>
      string(3) "two"
      [3]=>
      string(5) "three"
      [1]=>
      string(5) "one_b"
      [4]=>
      string(6) "four_b"
    }

### 5.3.11 增加/删除数组中的元素 ###

1.  array\_unshit()

array\_unshit()函数可在数组开头插入一个或多个单元。

**注意：**

*  单元作为整体插入，传入的单元将保持原来的顺序
 *  所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变

<?php
    $queue = array('a' => 'apple', 1 => 'banana', 'c' => 'watermelon');
    array_unshift($queue, 'spring', 'springMVC', 'mybatis'); // 在数组头部插入元素
    print_r($queue);
    ?>

Array
    (
        [0] => spring
        [1] => springMVC
        [2] => mybatis
        [a] => apple
        [3] => banana
        [c] => watermelon
    )

1.  array\_shift()

array\_shift()函数可将数组开头的单元移出数组。array\_shift()将数组的第一个单元移除并作为结果返回，将array的长度减一，并将所有其他单元向前移动一位。所有的数字键名从零开始重新计数，文字键名保持不变。

<?php
    $stack = array('spring', 'summer', 'autumn', 'winter', 'e' => 'happy new year');
    $seasons = array_shift($stack); // 移出数组的第一个单元并返回
    print_r($stack);
    ?>

Array
    (
        [0] => summer
        [1] => autumn
        [2] => winter
        [e] => happy new year
    )

1.  array\_push()

array\_push()函数用来将一个或多个单元压入数字的末尾（入栈）。

<?php
    $stack = array('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday');
    // 在$stack末尾插入元素
    echo array_push($stack, 'Saturday', 'Sunday'); // 7
    print_r($stack);
    ?>

Array
    (
        [0] => Monday
        [1] => Tuesday
        [2] => Wednesday
        [3] => Thursday
        [4] => Friday
        [5] => Saturday
        [6] => Sunday
    )

1.  array\_pop()

array\_pop()函数可将数组的最后一个单元弹出（出栈）。

<?php
    $stack = array('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday');
    // 在$stack末尾插入元素
    echo array_push($stack, 'Saturday', 'Sunday')."\n"; // 7
    print_r($stack);
    echo $week = array_pop($stack)."\n"; // 弹出数组最后一个单元
    print_r($stack);
    ?>

7
    Array
    (
        [0] => Monday
        [1] => Tuesday
        [2] => Wednesday
        [3] => Thursday
        [4] => Friday
        [5] => Saturday
        [6] => Sunday
    )
    Sunday
    Array
    (
        [0] => Monday
        [1] => Tuesday
        [2] => Wednesday
        [3] => Thursday
        [4] => Friday
        [5] => Saturday
    )

### 5.3.12 其他常用数组函数 ###

1.  array\_slice()

array\_slice()可以从数组中取出一段。

<?php
    $arr1 = array('a', 'b', 'c', 'd', 'e', 'f');
    $arr2 = array_slice($arr1, 2); // 从下标为2的位置开始截取
    print_r($arr2);
    $arr2 = array_slice($arr1, -2, 1); // 从末尾开始数的第二个位置，截取1个元素
    print_r($arr2);
    $arr2 = array_slice($arr1, 0, 3); // 从下标为0的位置开始，截取3个元素
    print_r($arr2);
    print_r(array_slice($arr1, 2, -1)); // 从下标为2的位置开始截取，至离末尾length为1的位置
    // array_slice()默认会重新排序并重置数组的数字索引，如果将preserve_keys的值设置为true，则可以改变此行为
    print_r(array_slice($arr1, 2, -1, true));
    ?>

Array
    (
        [0] => c
        [1] => d
        [2] => e
        [3] => f
    )
    Array
    (
        [0] => e
    )
    Array
    (
        [0] => a
        [1] => b
        [2] => c
    )
    Array
    (
        [0] => c
        [1] => d
        [2] => e
    )
    Array
    (
        [2] => c
        [3] => d
        [4] => e
    )

1.  array\_splice()

array\_splice()函数可以将数组的一部分去掉，并用其他值替代。语法如下：

array array_splice(array &$input, int $offset [, int $length = 0 [, mixed $replacement]])

**说明：**

*  array\_splice()把input数组中由offset和length指定的单元去掉，返回一个包含有被移除单元的数组。
 *  如果提供了replacement参数，就用其中的单元取代。
 *  input中的数字键名不会保留。
 *  如果offset大于0，就从input数组中该值指定的偏移量开始移除。
 *  如果offset小于0，就从input末尾倒数该值指定的偏移量开始移除。
 *  如果省略length，就移除数组中从offset到末尾的所有部分。
 *  如果指定了length，且length大于0，就移除这么多单元。

<?php
    $input = array('red', 'green', 'blue');
    array_splice($input, 2); // 移除下标为2的元素
    print_r($input);
    
    $input = array('red', 'green', 'blue', 'yellow');
    array_splice($input, 1, -1); // 从下标为1的位置开始移除，至离数组末尾length为1的位置结束
    print_r($input);
    
    $input = array('zhangsan', 'lisi', 'wangwu', 'zhaoliu');
    array_splice($input, 1, count($input), 'xiaoming'); // 从下标为1的位置开始，移除4个元素，用'xiaoming'替代被移除的部分
    print_r($input);
    
    $input = array('java', 'php', 'c/c++', 'c#');
    array_splice($input, -1, 1, array('black', 'maroon')); // 从末尾开始数，移除第一个元素，用black、maroon替代
    print_r($input);
    
    $input = array('January', 'February', 'March', 'April', 'May', 'June');
    array_splice($input, 3, 0, 'month'); // 将month插入到offset指定的位置
    print_r($input);
    ?>

Array
    (
        [0] => red
        [1] => green
    )
    Array
    (
        [0] => red
        [1] => yellow
    )
    Array
    (
        [0] => zhangsan
        [1] => xiaoming
    )
    Array
    (
        [0] => java
        [1] => php
        [2] => c/c++
        [3] => black
        [4] => maroon
    )
    Array
    (
        [0] => January
        [1] => February
        [2] => March
        [3] => month
        [4] => April
        [5] => May
        [6] => June
    )

1.  is\_array()

is\_array()函数检测变量是否为数组。

<?php
    $a = ['a', 'b', 'c', 1, 2, 3];
    $b = 'b';
    var_dump(is_array($a)); // bool(true)
    var_dump(is_array($b)); // bool(false)
    ?>

1.  array\_sum()

array\_sum()函数可计算数组中所有值的和，以整数或浮点数的结果返回。array\_sum()计算数组元素的和时，普通字符串被当作0，而数字类型的字符串会转换成相应的整型或浮点型数据参与计算。

<?php
    $a = ['a', 'b', 'c', 1, 2, 3, '5'];
    $b = 'b';
    var_dump(is_array($a)); // bool(true)
    var_dump(is_array($b)); // bool(false)
    echo array_sum($a); // 11
    ?>

1.  array\_product()

计算数组中所有值的乘积并返回。(普通字符串被当作0，而数字类型的字符串会转换成相应的整型或浮点型数据参与计算。)

<?php
    $a = ['a', 'b', 'c', 1, 2, 3, '5'];
    $b = 'b';
    $c = [1, 2, '3', 4];
    var_dump(is_array($a)); // bool(true)
    var_dump(is_array($b)); // bool(false)
    echo array_sum($a); // 11
    echo array_product($a); // 0
    echo array_product($c); // 24
    ?>

1.  array\_flip()

用来交换数组中的键和值。

\*\*说明：\*\*如果同一个值出现多次，最后一个键名将作为它的值。

<?php
    $trans = array('a' => 1, 'b' => 1, 'c' => 2);
    $trans = array_flip($trans); // 交换数组中的键和值
    print_r($trans);
    $trans = ['a', 'b', '1', 2, 3];
    print_r(array_flip($trans));
    ?>

Array
    (
        [1] => b
        [2] => c
    )
    Array
    (
        [a] => 0
        [b] => 1
        [1] => 2
        [2] => 3
        [3] => 4
    )

## 5.4 系统预定义函数 ##

### 5.4.1 $\_SERVER ###

> $\_SERVER是一个包含了诸如头信息（header）、路径（path）及脚本位置（script locations）信息的数组。这个数组中的项目由Web服务器创建。

$\_SERVER数组部分元素如下表所示：

<table> 
 <thead> 
  <tr> 
   <th align="center">数组元素</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">$_SERVER[‘PHP_SELF’]</td> 
   <td align="center">当前执行脚本的文件名，与document root有关。例如，在地址为http://example.com/test.php/foo.bar的脚本中使用$_SERVER[‘PHP_SELF’]将得到/test.php/foo.bar</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘SERVER_ADDR’]</td> 
   <td align="center">当前运行脚本所在服务器的IP地址</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘SERVER_NAME’]</td> 
   <td align="center">当前运行脚本所在服务器的主机名。如果脚本运行于虚拟主机中，该名称就由那个虚拟主机所设置的值决定</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘SERVER_PROTOCOL’]</td> 
   <td align="center">请求页面时通信协议的名称和版本，如“HTTP/1.0”</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘REQUEST_METHOD’]</td> 
   <td align="center">访问页面使用的请求方法，如：GET/HEAD/POST/PUT</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘REQUEST_ROOT’]</td> 
   <td align="center">当前运行脚本所在的文档根目录，在服务器配置文件中定义</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘HTTP_ACCEPT_LANGUAGE’]</td> 
   <td align="center">当前请求头中Accept-Language项的内容（如果存在），例如：“en”</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘REMOTE_ADDR’]</td> 
   <td align="center">浏览当前页面的用户IP地址，注意与$_SERVER[‘SERVER_ADDR’]的区别</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘SCRIPT_FILENAME’]</td> 
   <td align="center">当前执行脚本的绝对路径</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘SCRIPT_NAME’]</td> 
   <td align="center">包含当前脚本的路径</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘REQUEST_URI’]</td> 
   <td align="center">URI用来指定要访问的页面，如：“/index.html”</td> 
  </tr> 
  <tr> 
   <td align="center">$_SERVER[‘PATH_INFO’]</td> 
   <td align="center">包含由客户端提供的、跟在真实脚本名称之后并且在查询语句（query string）之前的路径信息（如果存在）。例如，当前脚本是通过URL http://www.example.com/php/path_info.php/some/stuff?foo=bar被访问的，那么$_SERVER[‘PATH_INFO’]将包含/som/stuff</td> 
  </tr> 
 </tbody> 
</table>

<?php
    print_r($_SERVER);
    ?>

### 5.4.2 $\_GET和$\_POST数组 ###

> 页面之间传递信息可通过GET和POST两种方式完成。$\_GET和$\_POST可分别用来接收这两种方式传递过来的数据。使用GET方法在页面间传递数据时，所传递的数据内容会显示在浏览器地址栏，而POST方式则不会。

index.html：

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>GET</title>
    </head>
    <body>
        <form action = "get.php" method="get">
            name:<input type="text" name = "name">
            phone:<input type="text" name="phone">
            <input type="submit" value="submit">
        </form>
    </body>
    </html>

get.php：

<?php
    echo "get method:<br/>";
    echo "name is ".$_GET['name'] .", phone is ".$_GET['phone'];
    ?>

测试：  
![在这里插入图片描述][20200602200851656.png]  
点击“submit”。  
![在这里插入图片描述][20200602200931678.png]  
更改index.html的文件代码，

action="post.php" method="post"

使用POST的方式传值给post.php。  
post.php代码如下：

<?php
    echo "post method:<br/>";
    echo "name is ".$_POST['name'].", phone is ".$_POST['phone'];
    ?>

测试：  
![在这里插入图片描述][20200602201330430.png]  
点击提交：  
![在这里插入图片描述][20200602201403511.png]

### 5.4.3 $\_FILES数组 ###

> $\_FILES数组用于获取通过POST方法上传文件的相关信息，如果为单个文件上传，那么该数组为二维数组，如果为多个文件上传，则该数组为三维数组。  
> file.html：

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>uploadFile</title>
    </head>
    <body>
     <form enctype="multipart/form-data" action="file.php" method="post">
         Send this file:<input name="userFile" type="file"/>
         <input type="submit" value="Send File"/>
     </form>
    </body>
    </html>

file.php：

<?php
    echo "<pre>";
    print_r($_FILES);
    ?>

测试：  
![在这里插入图片描述][20200602202128620.png]  
![在这里插入图片描述][20200602202240516.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJuYW1lNjY2_size_16_color_FFFFFF_t_70]

### 5.4.4 $\_SESSION和$\_COOKIE数组 ###

> $\_COOKIE\[\]全局数组存储了通过HTTP COOKIE传递到脚本的信息，PHP可通过setcookie()函数设置COOKIE的值，用$\_COOKIE\[\]数组接收COOKIE的值，$\_COOKIE\[\]数组的索引为COOKIE的名称。$\_SESSION\[\]数组用于获取会话变量的相关信息。

### 5.4.5 $\_REQUEST\[\]数组 ###

> 默认情况下，$\_REQUEST\[\]数组包含了$\_GET、$\_POST和$\_COOKIE的数组。

--------------------

**往期文章：**

*  [《PHP 7从零基础到项目实战》学习笔记1——PHP语言基础][PHP 7_1_PHP]
 *  [《PHP 7从零基础到项目实战》学习笔记2——流程控制语句][PHP 7_2]
 *  [《PHP 7从零基础到项目实战》学习笔记3——函数][PHP 7_3]
 *  [《PHP 7从零基础到项目实战》学习笔记4——字符串][PHP 7_4]

[20200602200851656.png]: https://img-blog.csdnimg.cn/20200602200851656.png
[20200602200931678.png]: https://img-blog.csdnimg.cn/20200602200931678.png
[20200602201330430.png]: https://img-blog.csdnimg.cn/20200602201330430.png
[20200602201403511.png]: https://img-blog.csdnimg.cn/20200602201403511.png
[20200602202128620.png]: https://img-blog.csdnimg.cn/20200602202128620.png
[20200602202240516.png]: https://img-blog.csdnimg.cn/20200602202240516.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJuYW1lNjY2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020060220225596.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJuYW1lNjY2,size_16,color_FFFFFF,t_70
[PHP 7_1_PHP]: https://blog.csdn.net/username666/article/details/105189285
[PHP 7_2]: https://blog.csdn.net/username666/article/details/106436895
[PHP 7_3]: https://blog.csdn.net/username666/article/details/106443498
[PHP 7_4]: https://blog.csdn.net/username666/article/details/106452477