PHP中的数组与数据结构

索引数组：索引值是整数          关联数组：索引值是字符串          混合          多维数组

在PHP中自定义数组可以使用以下三种方法：直接为数组元素赋值即可声明数组；使用array()函数声明数组；

print_r()函数或var_dump()函数可以打印数组中所有元素的内容，后者还可以输出类型

数组简写语法：数组声明时可以使用[]代替array()函数

多维数组的声明：数组中的元素仍为数组，就是多维数组

二维数组的声明和一维数组的声明方式一样，只是将数组中的每个元素也声明为一个数组，也有直接为数组元素赋值和使用array()函数两种声明数组的方法

数组的遍历

在PHP中，将大量数据声明在数组中，可以通过调用系统函数获取，例如mysql_fetch_row()函数是从结果集中取得一行作为枚举数组返回

使用for循环遍历连续数字索引的一维数组，遍历多维数组时，使用循环嵌套逐层进行遍历

联合使用list()、each()和while循环遍历数组

each()函数需要传递一个数组作为参数，返回数组中当前元素的键/值对，并向后移动数组指针到下一个元素的位置

<?php
    $contact = array("ID"=>1, "姓名"=>"哈哈", "公司"=>"A", "地址"=>"北京市");

    $id = each($contact);
    print_r($id);

    $name = each($contact);
    print_r($name);

    ?>

//Array ( [1] => 1 [value] => 1 [0] => ID [key] => ID ) Array ( [1] => 哈哈 [value] => 哈哈 [0] => 姓名 [key] => 姓名 )

list()函数用一步操作给一组变量进行赋值，即把数组中的值赋给一些变量。list()仅能用于数字索引的数组，并假定数字索引从0开始

list()语句和其他函数在使用上有很大的区别，它并不是直接接收一个数组作为参数，而是通过“=”运算符以赋值的方式，将数组中每个元素的值，对应地赋给list()函数中的每个参数。list()函数又将其中的每个参数转换为直接可以在脚本中使用的变量

<?php
    $info = array('coffee', 'brown', 'caffeine');
    list($drink, $color, $power) = $info;
    echo "$drink is $color and $power makes it special.
";
    list($drink, ,$power) = $info;
    echo "$drink has $power!
";
    list(,,$power) = $info;
    echo "I need $power!";
?>
//coffee is brown and caffeine makes it special. coffee has caffeine! I need caffeine!

while循环遍历数组

while(list($key, $value) = each(array_expression)){
循环体
}

遍历给定的数组，在while()语句每次循环中，each()语句将当前数组元素中的键赋给list()函数中的第一个参数变量$key，并将当前数组元素中的值赋给list()函数中的第二个参数变量$value。each()语句执行后还会把数组内部的指针向后移动一步，下一次while语句循环时，将会得到该数组中下一个元素的键/值对。直到数组的结尾each()语句返回FALSE，while语句停止循环

<?php
$contact = array("ID"=>1,
    "姓名"=>"哈哈",
    "公司"=>"A公司",
    "地址"=>"北京市",
    "电话"=>"(010)98765432",
    "EMAIL"=>"haha@haha.com");

echo '<dl>一个联系人信息:';

while (list($key, $value) = each($contact)) {

    echo("<dd>$key: $value</dd>");
}
echo '</dl>'

?>

//一个联系人信息:
ID: 1
姓名: 哈哈
公司: A公司
地址: 北京市
电话: (010)98765432
EMAIL: haha@haha.com

使用foreach语句遍历数组

//遍历数组，每次循环中，当前元素的值被赋给变量$value，并且把数组内部的指针向后移动一步，因此下一次循环中将会得到该数组的下一个元素，直到数组的结尾停止循环
foreach(array_expression as $value){
循环体
}

//当前元素的键名也会在每次循环中被赋给变量$key
foreach(array_expression as $key => $value){
循环体
}

<?php
//list可以将数组中的元素对应给参数中的变量
list($a, $b) = [1, 2];
echo $a, $b;

//声明一个简单的二级数组
$array = [
    [1, 2],
    [3, 4],
    ];

//使用foreach+list将子数组中的每个元素给list中的参数并输出
foreach ($array as list($a, $b)) {
    echo "A: $a; B: $b
";
}
?>

使用数组的内部指针控制函数遍历数组

数组的内部指针是数组内部的组织机制，指向一个数组中的某个元素。默认指向数组中的第一个元素，通过移动或改变指针的位置，可以访问数组中的任意元素。对于数组指针的控制，PHP提供了以下几个内建函数：

current()：取得目前指针位置的内容资料

key()：读取目前指针所指向资料的索引值

next()：将数组中的内部指针移动到下一个单元

prev()：将数组的内部指针倒回一位

end()：将数组的内部指针指向最后一个元素

reset()：将目前指针无条件移至第一个索引位置

这些函数的参数都只有一个，就是要操作的数组本身

<?php
//声明一个一维的关联数组$contact，使用“=>”运算符指定了每个元素的字符串下标
$contact = array(
    "ID" => 1,
    "姓名" => "高某",
    "公司" => "A公司",
    "地址" => "北京市",
    "电话" => "(010)98765432",
    "EMAIL" => "gao@brophp.com"
);

//数组刚声明时，数组指针在数组中第一个元素位置
//使用key()和current()函数传入数组$contact,返回数组中当前元素的键和值
echo '第一个元素： '. key($contact) . '=>' .current($contact). '<br>';  //第一个元素
echo '第一个元素： '. key($contact) . '=>' .current($contact). '<br>';  //数组指针没动

next($contact);
next($contact);
echo '第三个元素： '.key($contact) . '=>' . current($contact). '<br>';  //第三个元素

end($contact);
echo '最后一个元素： '. key($contact) . '=>' .current($contact) . '<br>';  //最后一个元素

prev($contact);
echo '最后第二个元素： '. key($contact) . '=>'. current($contact) . '<br>';

reset($contact);  //再将数组$contact中的指针重置到第一个元素的位置，指向第一个元素
echo '第一个元素： '. key($contact) . '=>' .current($contact) . '<br>';

?>


//
第一个元素： ID=>1
第一个元素： ID=>1
第三个元素： 公司=>A公司
最后一个元素： EMAIL=>gao@brophp.com
最后第二个元素： 电话=>(010)98765432
第一个元素： ID=>1

预定义数组

全局数组，直接使用，无需定义

$_SERVER：变量由Web服务器设定或者直接与当前脚本的执行环境相关联

$_ENV：执行环境提交至脚本的变量

$_GET：经由URL请求提交至脚本的变量

$_POST：经由HTTP POST方法提交至脚本的变量

$_REQUEST：经由GET、POST和COOKIE机制提交至脚本的变量，因此该数组不值得信任

$_FILES：经由HTTP POST文件上传而提交至脚本的变量

$_COOKIE：经由HTTP Cookies方法提交至脚本的变量

$_SESSION：当前注册给脚本会话的变量

$GLOBALS：包含一个引用指针指向每个当前脚本的全局范围内有效的变量，该数组的键名为全局变量的名称

数组的相关处理函数：使用数组的处理函数，可以很方便地对数组中每个元素的键和值进行操作，进而生成一个新数组

数组的键值操作函数

array_values()：作用是返回数组中所有元素的值，传入给定的数组，返回一个包含给定数组中所有值的数组；但不保留键名，被返回的数组将使用顺序的数值键重新建立索引。适合用于数组中元素下标混乱的数组，或者可以将关联数组转换为索引数组

array_keys()：返回数组中所有的键名

array array_keys(array input [, mixed search_value [, bool strict]])

<?php
$lamp = ["a"=>"Linux", "b"=>"Apache", "c"=>"MySQL", "d"=>"PHP"];
print_r(array_keys($lamp));
print_r(array_keys($lamp, 'Apache'));

$a = array(10, 20, 30, "10");
print_r( array_keys($a, 10, false));

$a = array(10, 20, 30, "10");
print_r( array_keys($a, 10, true));
?>

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

in_array()：检查数组中是否存在某个值，有三个参数，前两个参数是必需的，最后一个参数是可选的

bool in_array(mixed needle, array haystack [, bool strict])
@needle  规定要在数组中搜索的值
@haystack  规定要被搜索的数组
<?php
echo '<br>';
$os = array("Mac", "NT", "Irix", "Linux");

if (in_array("Irix", $os)) {
    echo "Got Irix";
}

if (in_array("mac", $os)) {
    echo "Got mac";
}

$a = array('1.10', 12.4, 1.13);

if (in_array('12.4', $a, true)) {
    echo "'12.4' found with strict check
";
}

if (in_array(1.13, $a, true)) {
    echo "1.13 found with strict check
";
}

//in_array()中还可以用数组当做第一个参数作为查询条件
$a = array(array('p', 'h'), array('p', 'r'), 'o');

if (in_array(array('p', 'h'), $a)) {
    echo "'ph' was found
";
}

if (in_array(array('h', 'p'), $a)) {
    echo "'hp' was found
";
}
?>
//Got Irix1.13 found with strict check 'ph' was found

也可以使用函数array_search()进行检索。该函数与in_array()函数的参数相同，搜索给定的值，存在则返回相应的键名，也支持对数据类型的严格判断

使用array_key_exists()函数还可以检查给定的键名或索引是否存在于数组中

<?php
$search_array = array('first'=>null, 'second'=>4);
isset($search_array['first']);  //false
array_key_exists('first', $search_array);  //true
?>

array_flip()：交换数组中的键和值，返回一个反转后的数组

array_reverse()：将原数组中的元素顺序翻转，创建新的数组并返回

array array_reverse(array array [, bool preserve_keys])
//第一个参数传入一个数组
//第二个参数是可选项，指定为TRUE，则元素的键名保持不变；否则键名将丢失

统计数组元素的个数和唯一性

count()：计算数组中的元素数目或对象中的属性个数

array_count_values()：统计数组中所有值出现的次数

array_unique()：删除数组中重复的值，并返回没有重复值的新数组

使用回调函数处理数组的函数

函数的回调允许在函数的参数列表中，传入用户自定义的函数地址作为参数处理或完成一定的操作

array_filter()函数：用回调函数过滤数组中的元素，返回按用户自定义函数过滤后的新数组

array array_filter( array input [, callback callback])

<?php
/**
  自定义函数myFun，为数组过滤设置条件
 *@param          int          $var          数组中的一个元素值
 *@return         bool         如果参数能被2整除则返回真
 */

function myFun($var) {
  if ($var % 2 == 0) {
      return true;
  }
}

$array = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);

print_r(array_filter($array, "myFun"));

?>

//Array ( [b] => 2 [d] => 4 )

array_walk()函数：对数组中的每个元素应用回调函数处理。如果成功返回true，否则返回false

bool array_walk(array &array, callback funcname [, mixed userdata])

//@array：必选项，输入待处理数组
@callback：必选项，传入用户定义的回调函数
array_walk()函数依次将第一个参数的数组中的每个值传递到这个自定义的函数中

<?php
/**
定义一个可以作为回调的函数，名称为myfun1
 * @param      string      $value      一个字符串参数，接收数组的值
 * @param      string      $key        一个字符串参数，接收数组的键
 */
function myfun1( $value, $key) {
    echo "The key $key has the value $value<br>";
}

$lamp = array("a"=>"Linux", "b"=>"Apache", "c"=>"Mysql", "d"=>"PHP");

array_walk($lamp, "myfun1");

/**
定义一个可以作为回调的函数，名称为myfun2
 * @param      string      $value      一个字符串参数，接收数组的值
 * @param      string      $key        一个字符串参数，接收数组的键
 * @param      string      $p          一个字符串参数，接收一个自定义的连接符号字符串
 */
function myfun2($value, $key, $p) {
    echo "$key $p $value <br>";
}

array_walk($lamp, "myfun2", "has the value");

/**
定义一个可以作为回调的函数，名称为fun3，改变数组元素的值
 * @param      string      $value      一个引用参数，接收数组变量，&$value传入引用
 * @param      string      $key        一个字符串参数，接收数组的键
 */
function myfun3 (&$value, $key) {
    $value = "Web";
}

array_walk($lamp, "myfun3");

print_r($lamp);
?>


//
The key a has the value Linux
The key b has the value Apache
The key c has the value Mysql
The key d has the value PHP
a has the value Linux 
b has the value Apache 
c has the value Mysql 
d has the value PHP 
Array ( [a] => Web [b] => Web [c] => Web [d] => Web )

array_map()函数：array_map()函数比array_walk()函数更加灵活，并且可以处理多个数组。将回调函数作用于给定数组的元素上，返回用户自定义函数作用后的数组

array_map()是任意参数列表函数，回调函数接收的参数数目应该和传递给array_map()函数的数组数目一致

array array_map(callback callback, array arr1 [, array...])

<?php
/**
自定义一个函数作为回调的函数，函数名称为myfun1
 * @param      string      $v      接收数组中每个元素作为参数
 * @param      string      返回一个字符串类型的值
 */
function myfun1($v) {
    if ($v == "MySQL") {
        return "Oracle";
    }
    return $v;
}

$lamp = array("Linux", "Apache", "MySQL", "PHP");

print_r(array_map("myfun1", $lamp));

/**
声明一个函数使用多个参数，回调函数接收的参数数目应该和传递给array_map()函数的数组数目一致
 * 自定义一个函数需要两个参数，两个数组中的元素依次传入
 * @param      mixed      $v1      数组中前一个元素的值
 * @param      mixed      $v2      数组中下一个元素的值
 * @param      string      提示字符串
 */
function myfun2 ($v1, $v2) {
    if ($v1 === $v2) {
        return "same";
    }
    return "different";
}

$a1 = array("Linux", "PHP", "MySQL");
$a2 = array("Unix", "PHP", "Oracle");

print_r(array_map("myfun2", $a1, $a2));

//当自定义函数名设置为null时的情况
$a1 = array("Linux", "Apache");
$a2 = array("MySQL", "PHP");

print_r(array_map(null, $a1, $a2));//通过将第一个参数设置为NULL，构造一个数组的数组

//
Array ( [0] => Linux [1] => Apache [2] => Oracle [3] => PHP ) Array ( [0] => different [1] => same [2] => different ) Array ( [0] => Array ( [0] => Linux [1] => MySQL ) [1] => Array ( [0] => Apache [1] => PHP ) )

数组的排序函数

sort()：按值  小-->大  升序排序

rsort()：按值  大-->小  降序排序

usort()：自定义的回调函数排序

asort()：小-->大  并保持索引关系

arsort()：大-->小  并保持索引关系

uasort()：

ksort()：

krsort()：

uksort()：

natsort()：自然顺序算法对给定数组中的元素排序

natcasesort()：不区分大小写的自然顺序算法对给定数组中元素排序

array_multisort()：对多个数组或多维数组进行排序

拆分、合并、分解和接合数组

array_slice()函数：在数组中根据条件取出一段值并返回。如果数组有字符串键，则返回的数组将保留键名

array_splice()函数

array_combine()函数

array_merge()函数

array_intersect()函数

array_diff()函数

数组与数据结构

使用数组实现堆栈：在PHP中，将数组当做一个栈，使用array_push()和array_pop()两个系统函数即可完成数据的进栈和出栈操作；array_push()函数向第一个参数的数组尾部添加一个或多个元素（入栈），然后返回新数组的长度，该函数等于多次调用$array[]=$value

int array_push( array &array, mixed var [, mixed...])

<?php
$lamp = array("Web");
echo array_push( $lamp, "Linux");
print_r($lamp);

echo array_push($lamp, "Apache", "MySQL", "PHP");
print_r($lamp);

$lamp = array("a"=>"Linux", "b"=>"Apache");
echo array_push($lamp, "MySQL", "PHP");
print_r($lamp);

$lamp["web"] = "www";
print_r($lamp);
?>

//2Array ( [0] => Web [1] => Linux ) 5Array ( [0] => Web [1] => Linux [2] => Apache [3] => MySQL [4] => PHP ) 4Array ( [a] => Linux [b] => Apache [0] => MySQL [1] => PHP ) Array ( [a] => Linux [b] => Apache [0] => MySQL [1] => PHP [web] => www )

array_pop()函数删除数组中的最后一个元素，即将数组中的最后一个单元弹出，并将数组的长度减1，如果数组为空将返回NULL

mixed array_pop(array &array)

使用数组实现队列

array_shift()函数可以实现删除数组中的第一个元素，并返回被删除元素的值

mixed array_shift(array &array)

将数组中第一个单元移出并作为结果返回，并将数组的长度减1，还将所有其他元素向前移动一位。所有的数字键名将改为从0开始计数，字符串键名将保持不变。如果数组为空，则返回NULL

还可以使用array_unshift()函数在队列数组的开头插入一个或多个元素，该函数执行成功将返回插入元素的个数

其他有用的数组处理函数

array_rand()函数：从数组中随机选出一个或多个元素并返回，第一个参数是数组，第二个参数是希望返回的元素个数

shuffle()函数：把数组中的元素按随机顺序重新排列，即将数组中的顺序打乱

array_sum()函数：返回数组中所有值的总和

range()函数：创建并返回一个包含指定范围的元素的数组

array range(mixed first, mixed second [, number step])

<?php
$number = range(0, 5);
print_r($number);

$number = range(0, 50, 10);
print_r($number);

$letter = range("a", "d");
print_r($letter);
?>

函数

标量类型声明：因为PHP是弱类型语言，不允许在声明变量时加上类型限制。但在PHP5中可以在函数的形参中加上类型声明，会对不符合预期的参数进行强制类型转换。但在PHP5中只能是类名、接口、array或者callable

<?php
    function demo_a($args) {
        var_dump($args);
    }

    demo_a(1);
    demo_a('abc');
    demo_a(array(1, 2, 3));

    function demo_b(array $args) {
        var_dump($args);
    }

    demo_b(array(1, 2, 3));
?>

伪类型参数的函数：在声明函数时，如果参数能接受多种不同但并不必须是所有类型的值，在函数的说明文档中就可以使用mixed标记这个参数类型。如果说明一个参数可以是integer或float，就可以使用number标记参数。除了参数可以传递伪类型的参数，函数的返回值也可以根据参数类型的不同，返回不同类型的值

从PHP7开始，函数中的形参类型声明可以是标量，即现在也可以使用string、int、float和bool类型

mixed funName(mixed $args) 
#在参数列表中出现类型使用mixed描述的参数

number funName(number $args)
#在参数列表中出现类型使用number描述的参数

引用参数的函数

void funName($arg)  值传递
void funName(array &$arg)
#在参数列表中出现使用&描述的参数  引用传递

//在PHP中默认是按值传递参数，函数的参数也属于局部变量，即使在函数内部改变参数的值，它并不会改变函数外部的值
使用引用符号“&”指定变量$arg为按引用传递方式。如果在函数的形参中有使用“&”修饰的参数，则在调用该函数时就必须传入一个变量给这个参数，而不能传递一个值
在PHP中有很多这样的函数，都需要传递一个变量给引用参数，在函数中改变参数变量的值，则传递的这个参数变量本身的值也会在父程序中被改变。
例如，在数组处理函数中的next()、sort()、shuffle、key()等函数都是引用参数的函数

默认参数的函数

mixed funName(string name [, string value [, int expire]])
#在参数列表中出现使用[]描述的参数

#在定义函数时声明了参数，而在调用函数时没有指定参数或是少指定了参数，就会出现缺少参数的警告。在PHP中，支持函数的默认方式调用，即为参数指定一个默认值。在调用函数时如果没有指定参数的值，在函数中会使用参数的默认值。默认值必须是常量表达式，不能是变量、类成员或者函数调用。PHP还允许使用数组和特殊类型NULL作为默认参数

可变个数参数的函数

mixed funName(string arg1 [, string...])

<?php
    function more_args()
    {
        $args = func_get_args();
        for ($i=0; $i<count($args); $i++) {

            echo "第".$i."个参数是".$args[$i]."<br>";
        }
    }
    more_args("one", "two", "three", 1, 2, 3);

    function sum( ...$ints)
    {
        return array_sum($ints);
    }
    var_dump(sum(2, '3', 4.1, 10, true));

    function sums(int ...$ints) :int
    {
        return array_sum($ints);
    }
    var_dump(sums(1, 2, 3));


?>

在调用函数时，还可以使用“...”运算符，将数组和可遍历的对象展开为函数参数。这个功能非常实用，当一个函数参数比较多时，可以不用逐一地传递参数，在调用函数时，只要传递一个数组，数组中的成员就展开为函数的参数了

类型在PHP中也是允许为空，当启用这个特性时，传入的参数或者函数返回的结果要么是给定的类型，要么是null。可以通过在类型前面加上一个问号？来使之成为可空的通配符

回调函数，就是指调用函数时并不是传递一个标准的变量作为参数，而是将另一个函数作为参数传递到调用的函数中。如果在函数的格式说明中出现“callback”类型的参数，则该函数就是回调函数