数组

规则

数组构成： 数组是由一个或多个数组元素组成的
数组元素： 每一个数组元素由键（Key）和值（Value）构成
键： “键”为元素的识别名称，也被称为数组下标
值： “值”为元素的内容
映射： “键”和“值”之间存在一种对应关系，称之为映射
类型划分： 根据键的数据类型，可以将数组划分为索引数组和关联数组

数组的意义

数组在编程中是一种重要的数据结构，其主要用途包括：

组织数据： 数组允许你将多个相关的数据项组织在一起，形成一个集合。这样，你可以更方便地访问和管理这些数据。
索引和检索： 数组使用索引或键来标识和访问各个元素。通过使用索引，你可以迅速地检索特定位置或键对应的值。
循环和迭代： 数组结构适用于循环和迭代操作。你可以使用循环语句遍历数组中的所有元素，执行相同的操作。
存储表格数据： 数组可以模拟表格或矩阵的结构，用于存储和处理表格数据，例如二维数组。
参数传递： 在函数或方法中，你可以使用数组来传递一组相关的参数。这使得代码更简洁、灵活，并且易于维护。
多维数组： 数组可以是多维的，即数组的元素也可以是数组。这在处理更复杂的数据结构时非常有用。
灵活性： 数组是一种灵活的数据结构，可以根据需要动态调整大小，添加或删除元素。
关联数据： 关联数组允许使用键值对存储数据，而不仅仅依赖数字索引。这使得数据的结构更清晰，并提高了可读性。

总体而言，数组为程序员提供了一种便捷的方式来组织和处理数据，是编程中非常重要的数据结构之一。在各种编程语言中，数组的实现和用法可能有所不同，但基本的概念和用途通常是相似的

用法

定义数组的方式分三种方式，分别为：

array()结构
短数组定义法[]
逐个赋值方式定义

需要注意的是array()并不算是一个函数，而是一种数据类型，第一部分有详细记录这种数据类型

短数组定义法是在 PHP 5.4.0 版本引入的语法糖，用于更简洁地定义数组。它使用中括号 [] 来表示数组，并可以直接初始化数组元素。

定义规则:

起一个变量$命名后用=接array()或[]来将这个变量定义成数组数据

数组中不同的值用,隔开

数组类型

索引数组

// 传统数组定义
$colors1 = array("Red", "Green", "Blue");

// 短数组定义法
$colors2 = ["Red", "Green", "Blue"];

上述两种方式都创建了一个索引数组，其中元素分别是 "Red"、"Green" 和 "Blue"

索引数组规则：

索引从零开始： 索引数组的索引从 0 开始，依次递增。每个元素都有一个数字索引
元素顺序： 索引数组中元素的顺序是有序的，即元素的存储顺序和插入顺序一致
元素访问： 使用数字索引访问数组元素，例如 $colors1[0]、$colors1[1]
动态添加元素： 可以使用空的 [] 运算符来动态添加元素，例如 $colors1[] = "dark"

现在用print_r()函数来输出其中一个数组：

<?php
// 传统数组定义
$colors1 = array("Red", "Green", "Blue");

// 短数组定义法
$colors2 = ["Red", "Green", "Blue"];

print '<pre>';
print_r($colors1);
print '</pre>';
?>

通过此图可以看出这个数组的清晰结构；按照从0开始依次递增的顺序排列，由[]中的数字来索引数组中的值：

若像：

$sports = array(2 => 'basketball', 4 => 'swimming');	
echo $sports[2];
echo '<hr>';
echo $sports[4];
echo '<hr>';

来这样定义值，这个数组仍然可以被认为是索引数组，在php中；索引数组的关键特征是使用数字作为索引

关联数组

// 传统关联数组定义
$person1 = array("name" => "John", "age" => 30, "city" => "New York");

// 短数组定义法
$person2 = ["name" => "John", "age" => 30, "city" => "New York"];

关联数组中，键和值之间使用 => 连接，用,分隔

关联数组规则：

键值对： 关联数组使用键值对来存储数据，每个元素都有一个键和对应的值
键的类型： 键可以是字符串或数字，甚至是其他数据类型
元素顺序： 关联数组中元素的顺序不一定与插入顺序相同，因为元素是通过键来访问的
元素访问： 使用键来访问数组元素，例如 $person2 = ["name"]
动态添加元素： 可以使用直接指定键的方式添加元素，例如 $person2["gender"]="male"

现在用print_r()函数输出，查看关联数组的结构：

多维数组

// 传统多维数组定义
$students1 = array(
    array("name" => "Alice", "age" => 22),
    array("name" => "Bob", "age" => 25),
    array("name" => "Charlie", "age" => 20)
);

// 短数组定义法
$students2 = [
    ["name" => "Alice", "age" => 22],
    ["name" => "Bob", "age" => 25],
    ["name" => "Charlie", "age" => 20]
];

短数组定义法同样适用于多维数组

现在用print_r()函数来输出$students1查看其结构，得到的结果为：

动态数组

$basket=[ "Orange", "Banana"];    //定义了一个数组
$fruit="apple";    //定义了一个变量
$basket[]=$fruit;    //将这个变量加入数组

在数组中可以包含变量，这使得动态构建数组更加方便

短数组定义法使得数组的声明更加简洁和可读；特别是在定义小型数组时，这种语法更为推荐。但是一般情况下或在较旧的php版本中，使用更多的是用array()这个函数

详述定义方式

用逐个赋值方式定义数组

$arr[] = 123;			// 存储结果：$arr[0] = 123
$arr[] = 'hello';			// 存储结果：$arr[1] = 'hello'
$arr[4] = 'PHP';			// 存储结果：$arr[4] = 'PHP'
$arr['name'] = 'Tom';		// 存储结果：$arr['name'] = 'Tom'
$arr[] = 'Java';			// 存储结果：$arr[5] = 'Java'

这种定义方式个人认为可以理解成：

$arr=array();    //定义了一个空数组
$arr[] = 123;			// 存储结果：$arr[0] = 123
$arr[] = 'hello';			// 存储结果：$arr[1] = 'hello'
$arr[4] = 'PHP';			// 存储结果：$arr[4] = 'PHP'
$arr['name'] = 'Tom';		// 存储结果：$arr['name'] = 'Tom'
$arr[] = 'Java';			// 存储结果：$arr[5] = 'Java'

从某种程度上来说，这种定义方式可以被认为是一种动态数组，只不过$arr=array();这一步可以省略掉

定义混合数组

$mixed = array(2, 'str', 'id' => 5, 5 => 'b', 'a');

在这个数组中，$mixed数组的元素b指定了数字键名为5，b元素后的a元素会自动将前面最大的数字键名加1后，作为其键名，即5+1得到键名6。现在用print_()函数来输出这个数组，得到的结果为：

访问数组

若要一次查看数组中的所有元素，则可以利用前面学习过的输出语句函数print_r()和var_dump()，并且通常情况下为了使输出的函数按照一定的格式打印，查看时经常与pre标记一起使用。具体写法在索引数组那里写过

现在尝试用var_dump()函数打印一个数组：

<?php
$colors1 = array("Red", "Green", "Blue");

echo '<pre>';
var_dump($colors1);
echo '</pre>';
?>

得到的结果为：

得到的信息会更全面

遍历数组

遍历数组就是挨个访问数组中所有元素的操作，这个遍历可以理解为动词，指将数组中的元素全部调用一遍

用`for`循环遍历：

<?php
$arr = ['PHP', 'Python', 'C', 'Java'];    //定义了一个数组
$arr_len=count($arr);    //定义了一个变量$arr_len，用于算出数组$arr中有多少个元素，count就是计数的意思

for($i=0;$i<$arr_len;$i++){
    /*起一个for循环，将索引数0赋值给了$i,设置条件为索引数<元素长度,
    （因为索引数组默认从0开始排序，所以要小于元素长度）,
    设置索引数变量$i递增
     */
    echo $arr[$i];    //通过利用for循环，挨个输出数组中的每一个元素
    echo "<br/>";
}
?>

得到的结果为：

用`foreach`循环遍历：

遍历索引数组：

<?php
$colors = ["Red", "Green", "Blue","dark"];

foreach ($colors as $value) {
    echo $value . '<br>';
}
?>

得到的结果为：

遍历关联数组：

<?php
$colors = ['No.1'=>"Red", 'No.2'=>"Green",'No.3'=>"Blue",'No.4'=>"dark"];
    //将序号作为键，赋给数组内的元素值

foreach ($colors as$key=>$value) {
    echo '序号：'.$key.'值：'.$value.'<br>';
}
?>

得到的结果为：

若像不给元素赋键的索引函数仍然可以被认为是在遍历关联数组：

<?php
$colors = ["Red","Green","Blue","dark"];

foreach ($colors as$key=>$value) {
    echo '序号：'.$key.'值：'.$value.'<br>';
}
?>

得到的结果则是将默认的索引数赋给$key；

遍历多维数组：

<?php
$students = [
     ["name" => "Alice", "age" => 22],
     ["name" => "Bob", "age" => 25],
     ["name" => "Charlie", "age" => 20]
 ];
 
 foreach ($students as $student) {
     foreach ($student as $key => $value) {
         echo $key . ': ' . $value . '<br>';
     }
     echo '<hr>';
 }
?>

解释一下这段代码；$students这个变量是作为一个复数形式的主数组，$student是foreach循环直接提供的一个变量，它代表每个二维数组中的子数组；可以理解为下面这段代码

<?php
$students = [
     $student[]=["name" => "Alice", "age" => 22],
     $student[]=["name" => "Bob", "age" => 25],
     $student[]=["name" => "Charlie", "age" => 20]
 ];
 
 foreach ($students as $student) {
     foreach ($student as $key => $value) {
         echo $key . ': ' . $value . '<br>';
     }
     echo '<hr>';
 }
?>

得到的结果为：

for循环同样也能完成以上任务，但是写法更加繁琐。foreach循环则能更加简洁快捷的完成以上任务

用`while`循环遍历：

<?php
$fruits = ["Apple", "Orange", "Banana"];

$count = count($fruits);
$i = 0;

while ($i < $count) {
    echo $fruits[$i] . '<br>';
    $i++;
}
?>

得到的结果：

数组操作符

在 PHP 中，数组操作符主要有：合并操作符+，相等操作符== 和 ===，不等操作符<>、!=和不全等操作符!==

合并操作符`+` :

合并操作符+用于将两个数组合并成一个新数组。它将两个数组的内容合并在一起，如果有相同的键，后面的数组中的值会覆盖前面的数组中的值。

<?php
$array1 = ['a' => 1, 'b' => 2];
$array2 = ['b' => 3, 'c' => 4];
$result = $array1 + $array2;

echo '<pre>';
print_r($result);
echo '</pre>';
?>

合并操作符只会保留第一个数组中相同键的值，如果后面的数组中有相同键，它们会被忽略

得到的结果为：

另一种合并方法，利用array_combine()函数将一个数组作为键一个数组作为值，合并成一个新的函数：

<?php
<?php
$keys = ['a', 'b', 'c'];
$values = [1, 2, 3];

$newdArray = array_combine($keys, $values);

echo '<pre>';
print_r($newdArray);
echo '</pre>';
?>

得到的结果：

注意事项：

两个输入数组的元素数量必须相同，否则会报错

如果两个输入数组的键名数组和值数组的键名不是相同的顺序，array_combine 会按照键名数组的顺序来匹配值数组的元素

如果输入数组为空，array_combine 返回一个空数组

相等操作符`==` 和 `===` :

相等操作符==用于比较两个数组的值是否相等。如果两个数组的键/值对相同，即使它们的顺序不同，它们被认为是相等的

<?php
$array1 = ['a'=>1,'b'=>2,'c'=>3];
$array2 = ['c'=>2,'b'=>1,'a'=>0,];

if ($array1 == $array2) {
    echo '相同';
} else {
    echo '不同';
}

print '<hr/>';

$array3 = ['a'=>1,'b'=>2,'c'=>3];
$array4 = ['c'=>3,'a'=>1,'b'=>2,];

if ($array3 == $array4) {
    echo '相同';
} else {
    echo '不同';
}
?>

结果为：

全等操作符 (===) 则要求数组的键/值对和顺序全部都相同

<?php
$array3 = ['a'=>1,'b'=>2,'c'=>3];
$array4 = ['a'=>1,'b'=>2,'c'=>3];

if ($array3 === $array4) {
    echo '相同';
} else {
    echo '不同';
}

print '<hr/>';

$array1 = ['a'=>1,'b'=>2,'c'=>3];
$array2 = ['c'=>2,'b'=>1,'a'=>0,];

if ($array1 === $array2) {
    echo '相同';
} else {
    echo '不同';
}
?>

结果为：

不等操作符`!=`、`<>`与不全等操作符`!==`

<?php
$array1 = ['a'=>1,'b'=>2,'c'=>3];
$array2 = ['c'=>3,'a'=>1,'b'=>2,];

if ($array1 != $array2) {
    echo '不等';
} else {
    echo '相等';
}

print '<hr/>';

$array3 = ['a'=>1,'b'=>2,'c'=>3];
$array4 = ['a'=>1,'b'=>2,'c'=>3];

if ($array3 !== $array4) {
    echo '不全等';
} else {
    echo '全相等';
}
?>

结果为：

!=与<>是一个意思，只不过写法不同，实际使用中看个人喜好决定用哪个

array_diff函数，此函数可用来对比两个数组

<?php
$array1 = ['qwe','rty','uio','asd','fgh'];
$array2 = [123,456,'fgh','uio','asd'];

$difference = array_diff($array1, $array2);

echo '<pre>';
print_r($difference);
echo '</pre>';
?>

结果为：

这个结果的意思是：array_diff函数返回了两个数组之间的差异，即包含在$array1中但不包含在$array2中的元素；观察返还结果，qwe与rty是$array2中没有的，但是这两个值在$array1中存在

数组的增删改查

增

利用array_push函数增加元素

<?php
$a=array("red","green");

array_push($a,"blue","yellow");

echo '<pre>';
print_r($a);
echo '</pre>';
?>

需要注意的是array_push($a,"blue","yellow");这句话: array_push($a,"blue","yellow");中的$a并不是将$a这个数组变量套娃加入进数组中，而是指在$a已有的元素后追加新的元素blue和yellow。可以理解为等同于直接赋值添加

直接赋值添加

<?php
$a=array("red","green");

$a[] = "blue";
$a[] = "yellow";

echo '<pre>';
print_r($a);
echo '</pre>';
?>

两种方式添加得到的效果是一样的，显示的内容都会是：

删

删除一个数组

<?php
$arr1 = ['qwe', 'rty', 'uio', 'pas', 'dfg', 'hjk', 'lzx'];
$arr2 = [123, 456, 789, 987, 654, 321, 951];
$arr3 = ['qqq', 'www', 'eee', 'rrr', 'ddd', 'fff', 'ttt'];
    //定义了三个数组

unset($arr1);    //删除$arr1一整个数组

echo '<pre>';
print_r($arr1);    //这里不会输出，因为$arr1已经被一整个unset掉了
print_r($arr2);
print_r($arr3);
echo '</pre>';
?>

结果为：

删除数组内元素

<?php
$arr1 = ['qwe', 'rty', 'uio', 'pas', 'dfg', 'hjk', 'lzx'];
$arr2 = [123, 456, 789, 987, 654, 321, 951];
$arr3 = ['qqq', 'www', 'eee', 'rrr', 'ddd', 'fff', 'ttt'];
    //定义了三个数组

unset($arr1[0],$arr1[1],$arr1[2],
      $arr2[0],$arr2[1],$arr2[2]);
      
echo '<pre>';
print_r($arr1);
print_r($arr2);
print_r($arr3);
echo '</pre>';
?>

结果为：

可以看出$arr1和$arr2的前三个元素被删了，如果想重新排序，则需要用到array_values函数：

<?php
$arr1 = ['qwe', 'rty', 'uio', 'pas', 'dfg', 'hjk', 'lzx'];
$arr2 = [123, 456, 789, 987, 654, 321, 951];
$arr3 = ['qqq', 'www', 'eee', 'rrr', 'ddd', 'fff', 'ttt'];
    //定义了三个数组

unset($arr1[0],$arr1[1],$arr1[2],
      $arr2[0],$arr2[1],$arr2[2]);
      
echo '<pre>';
print_r($arr1);
print_r($arr2);
print_r($arr3);
echo '</pre>';

echo '<hr/>';

$arr1=array_values($arr1);
$arr2=array_values($arr2);

echo '<pre>';
print_r($arr1);
print_r($arr2);
print_r($arr3);
echo '</pre>';
?>

结果为：

可以看出，第二遍输出三个数组时刷新了$arr1与$arr2的索引顺序

删除多个数组

<?php
$arr1 = ['qwe', 'rty', 'uio', 'pas', 'dfg', 'hjk', 'lzx'];
$arr2 = [123, 456, 789, 987, 654, 321, 951];
$arr3 = ['qqq', 'www', 'eee', 'rrr', 'ddd', 'fff', 'ttt'];
    //定义了三个数组

unset($arr2,$arr3);    //删除了后面两个数组
      
echo '<pre>';
print_r($arr1);
print_r($arr2);
print_r($arr3);
echo '</pre>';
?>

结果为：

改

使用array_replace函数

<?php
$arr1 = ['a', 'b', 'c'];
$arr2 = [0 => 'x', 1 => 'y', 2 => 'z'];

echo '<pre>';
print_r($arr1);
print_r($arr2);
echo '</pre>';

echo '<hr/>';

echo '<pre>';
print_r(array_replace($arr1, $arr2));
echo '</pre>';
?>

结果为：

可以看出第二次输出时$arr2将$arr1的元素替换掉了，需要注意的是；array_replace函数不会改变原始数组，而是返回一个新的数组，可以理解为：

<?php
$arr1 = ['a', 'b', 'c'];
$arr2 = [0 => 'x', 1 => 'y', 2 => 'z'];

echo '<pre>';
print_r($arr1);
print_r($arr2);
echo '</pre>';

echo '<hr/>';

$newarr=array_replace($arr1,$arr2);

echo '<pre>';
print_r($newarr);
echo '</pre>';
?>

只不过在第一段代码中未将这个新数组命名，后续如需再次调用这个修改过的新数组会很繁琐

如果键名在第一个数组中不存在，就会直接添加。如果有其他数组作为修改参数，后面的数组会覆盖前面的数组的相同键名的元素:

<?php
$arr1=['a'=>1,'b'=>2,'c'=>3];
$arr2=['b'=>4,'c'=>5,'d'=>6];

echo '<pre>';
print_r($arr1);
print_r($arr2);
echo '</pre>';

echo '<hr/>';

$newarr=array_replace($arr1,$arr2);

echo '<pre>';
print_r($newarr);
echo '</pre>';
?>

结果为：

修改了同键的值，添加了一个新元素d

直接改

<?php
$arr=['a'=>1,'b'=>2,'c'=>3,'d'=>4];

echo '<pre>';
print_r($arr);
echo '</pre>';

echo '<hr/>';

$arr['b']=114514;

echo '<pre>';
print_r($arr);
echo '</pre>';
?>

结果为：

将b的值改成了一个很臭的数字

查

array_search函数

此函数一般用于查找要搜索的值对应的键

<?php
$colors=['red','green','blue','yellow'];
echo array_search('red',$colors);
?>

这个函数的语法是：array_search(值, 数组变量名)。
得到的结果为：

array_search函数的返回结果是对应值的键，用print_r()输出返回的结果是一样的，上图返回的键是索引数0

in_array()函数

此函数用于验证数组中是否存在一个值

<?php
$colors=['red','green','blue','yellow'];
var_dump(in_array('green',$colors));

echo '<hr/>';

var_dump(in_array('dark',$colors));
?>

结果为：

可以看出返回了两个布尔数据；green存在，所以返回true，dark不存在则返回了false，若用echo或print_r()输出，则结果为true的值返回1，结果为false的值因=0而什么都不显示

两个函数都可以套用if...else语句

<?php
$colors=['red','green','blue','yellow'];

$sr1=array_search('blue',$colors);    //将array_search()函数运行后的值赋给$sr1
if ($sr1==true) {
    echo '已匹配到键：'.$sr1;
} else {
    echo '查无此值';
};

echo '<hr/>';

$sr2=in_array('blue',$colors);    //将in_array()函数运行后的值赋给$sr2
if($sr2==true){
     echo '已匹配到键：'.$sr2;
}else{
     echo '艹';
};
?>

结果为：

观察这段代码及返回结果；搜索的值都是blue，返回结果却不同。这就是两个函数的区别，array_search函数会对值的键进行匹配搜索。而in_array函数只会查找数组内有没有这个值，却不会对键进行匹配。所以echo '已匹配到键：'.$sr2;这里的sr2只是一个布尔型数据

数组常用函数

数组操作函数

`array_pop()`函数

从数组末尾删除并返回最后一个元素的值

<?php
$fruits = ['apple', 'banana', 'orange'];

$apv = array_pop($fruits);    //删除数组中的末尾元素，并将元素中的值赋给$apv
echo '被删除的值为：' . $apv;

echo '<hr/>';

print_r($fruits);
?>

结果为：

`array_push()`函数

<?php
$a=array("red","green");

array_push($a,"blue","yellow");

echo '<pre>';
print_r($a);
echo '</pre>';
?>

需要注意的是array_push($a,"blue","yellow");这句话: array_push($a,"blue","yellow");中的$a并不是将$a这个数组变量套娃加入进数组中，而是指在$a已有的元素后追加新的元素blue和yellow。可以理解为等同于直接赋值添加。array_push可以理解为push something into array

`array_unshift()`函数

在数组开头插入一个或多个元素，并count数组内有多少元素

<?php
$fruits = ['banana', 'orange'];

$new_count = array_unshift($fruits, 'apple', 'grape');

echo '共有'.$new_count.'个元素'.'<hr/>';

echo 'Updated array: ';
print_r($fruits);
?>

结果为：

`array_shift()`函数

从数组开头删除并返回第一个元素的值

<?php
$fruits = ['apple', 'banana', 'orange'];

$removed_element = array_shift($fruits);

echo 'Removed element: ' . $removed_element . '<br>';
echo 'Updated array: ';
print_r($fruits);
?>

结果为：

此函数理解方法参考array_pop

`array_unique()`函数

移除数组中重复的值，并返回新的数组

<?php
$numbers = [1, 2, 2, 3, 4, 4, 5];

$unique_numbers = array_unique($numbers);

echo 'Original array: ';
print_r($numbers);
echo '<hr/>';
echo 'Unique array: ';
print_r($unique_numbers);
?>

结果为：

`array_slice()`函数

目的：提取数组的一部分
语法：array_slice(array $array, int $offset, ?int $length = null, bool $preserve_keys = false): array

示例：

$fruits = ['apple', 'banana', 'cherry', 'date'];
$slice = array_slice($fruits, 1, 2);
print_r($slice);

`array_splice()`函数

目的：删除数组的一部分并用其他内容替换
语法：array_splice(array &$array, int $offset, ?int $length = null, mixed $replacement = []): array

示例：

$colors = ['red', 'green', 'blue', 'yellow'];
array_splice($colors, 1, 2, ['orange']);
print_r($colors);

检索函数

`in_array()`函数

目的：检查值是否存在于数组中
语法：in_array(mixed $needle, array $haystack, bool $strict = false): bool

示例：

$numbers = [1, 2, 3, 4, 5];
$isFound = in_array(3, $numbers);
echo $isFound ? '找到了' : '未找到';

`array_search()`函数

目的：在数组中搜索值并返回对应的键（如果成功）
语法：array_search(mixed $needle, array $haystack, bool $strict = false): mixed

示例：

$colors = ['red' => '红色', 'green' => '绿色', 'blue' => '蓝色'];
$key = array_search('绿色', $colors);
echo $key;  // 输出 'green'

`array_key_exists()`函数

目的：检查数组中是否存在指定的键
语法：array_key_exists(mixed $key, array $array): bool

示例：

$info = ['name' => 'John', 'age' => 25, 'city' => 'Beijing'];
$hasKey = array_key_exists('age', $info);
echo $hasKey ? '存在' : '不存在';

其他函数

`count()`函数

目的：返回数组中元素的个数
语法：count(array|Countable $array, int $mode = COUNT_NORMAL): int

示例：

$numbers = [1, 2, 3, 4, 5];
$count = count($numbers);
echo $count;  // 输出 5

`range()`函数

目的：创建一个包含指定范围的元素的数组
语法：range(mixed $start, mixed $end, float|null $step = null): array

示例：

$numbers = range(1, 5);
print_r($numbers);  // 输出 [1, 2, 3, 4, 5]

`array_rand()`函数

目的：从数组中随机选择一个或多个键
语法：array_rand(array $array, int $num = 1): mixed

示例：

$colors = ['red', 'green', 'blue', 'yellow'];
$randomKey = array_rand($colors);
echo $colors[$randomKey];

`array_keys()`函数

目的：返回数组中所有的键
语法：array_keys(array $array, mixed $search_value = null, bool $strict = false): array

示例：

$info = ['name' => 'John', 'age' => 25, 'city' => 'Beijing'];
$keys = array_keys($info);
print_r($keys);  // 输出 ['name', 'age', 'city']

`array_values()`函数:

目的：返回数组中所有的值
语法：array_values(array $array): array

示例：

$info = ['name' => 'John', 'age' =>25, 'city' => 'Beijing'];
$values = array_values($info);
print_r($values);  // 输出 ['John', 25, 'Beijing']

`array_column()`函数

目的：返回数组中指定列的值
语法：array_column(array $array, mixed $column_key, mixed $index_key = null): array

示例：

$students = [
    ['name' => 'John', 'age' => 20],
    ['name' => 'Jane', 'age' => 22],
    ['name' => 'Bob', 'age' => 21]
];
$names = array_column($students, 'name');
print_r($names);  // 输出 ['John', 'Jane', 'Bob']

`array_sum()`函数

目的：计算数组中所有数值的和
语法：array_sum(array $array): number

示例：

$numbers = [1, 2, 3, 4, 5];
$sum = array_sum($numbers);
echo $sum;  // 输出 15

`array_reverse()`函数

目的：将数组元素的顺序反转
语法：array_reverse(array $array, bool $preserve_keys = false): array

示例：

$numbers = [1, 2, 3, 4, 5];
$reversed = array_reverse($numbers);
print_r($reversed);  // 输出 [5, 4, 3, 2, 1]

`array_merge()`函数

目的：合并一个或多个数组
语法：array_merge(array ...$arrays): array

示例：

$fruits1 = ['apple', 'banana'];
$fruits2 = ['orange', 'grape'];
$merged = array_merge($fruits1, $fruits2);
print_r($merged);

`array_flip()`函数

目的：交换数组中的键和值
语法：array_flip(array $array): array

示例：

$colors = ['red' => '红色', 'green' => '绿色', 'blue' => '蓝色'];
$flipped = array_flip($colors);
print_r($flipped);

`array_combine()`函数

目的：通过合并两个数组来创建一个新数组，其中一个数组为键名，另一个数组为键值
语法：array_combine(array $keys, array $values): array|false

示例：

$keys = ['name', 'age', 'city'];
$values = ['John', 25, 'Beijing'];
$info = array_combine($keys, $values);
print_r($info);

`array_chunk()`函数

目的：将数组分割成指定大小的块，并返回一个多维数组
语法：array_chunk(array $array, int $size, bool $preserve_keys = false): array

示例：

$numbers = [1, 2, 3, 4, 5, 6, 7, 8];
$chunks = array_chunk($numbers, 3);
print_r($chunks);

`array_fill()`函数

目的：用给定的值填充数组
语法：array_fill(int $start_index, int $num, mixed $value): array

示例：

$filledArray = array_fill(0, 5, 'apple');
print_r($filledArray);

`array_replace()`函数

目的：使用后面数组的值替换第一个数组的值
语法：array_replace(array ...$arrays): array

示例：

$arr1 = ['a', 'b', 'c'];
$arr2 = [0 => 'x', 1 => 'y', 2 => 'z'];
print_r(array_replace($arr1, $arr2));

`array_map()`函数:

目的：将指定的回调函数作用于给定数组的每个单元，返回一个新数组。
语法：array_map(callable $callback, array ...$arrays): array

示例：

$numbers = [1, 2, 3, 4, 5];
$squared = array_map(function ($num) {
    return $num * $num;
}, $numbers);
print_r($squared);

`array_walk()`函数:

目的：对数组中的每个元素应用用户自定义的回调函数
语法：array_walk(array &$array, callable $callback, mixed $userdata = null): bool

示例：

$fruits = ['apple', 'banana', 'cherry'];
array_walk($fruits, function (&$value, $key) {
    $value = strtoupper($value);
});
print_r($fruits);

函数

函数的概念：

数学概念： 在数学中，函数是一种特殊的关系，它将一个集合的每个元素映射到另一个集合的唯一元素。通常表示为 f(x)，其中 x 是输入，f(x) 是输出。函数在数学中用于描述变量之间的关系，例如，y = f(x) 可以表示一个图表上的曲线

汇编语言中的意义： 在编程和计算机科学中，函数是一段可重用的代码块，它接受输入（参数），执行一系列操作，然后返回结果。函数有助于模块化程序，提高代码的可读性和可维护性。函数在程序中可以被调用多次，避免了重复编写相同的代码

宏观理解： "函数"可以理解为某种操作或服务，例如社会功能、机构功能等。这里的功能指的是完成特定任务或提供特定服务的能力

自定义函数

自定义函数可以理解为：我需要通过函数来实现某种功能，但是这个函数在系统中不存在。那么就可以用function这个关键字来创造一个函数；这个函数的运行方式会以它被定义的方式运行。这属于一种功能，一种客制化或者说定制化服务

自定义函数的结构如下：

<?php
function sum($a, $b){   //用function这个关键字起一个自定义函数，命名为sum，并用两个变量作为参数（形参）                         
	return $a+$b;    //此为函数体，用于定义这个函数内的变量以何种方式运行
};
$re = sum(1,2);    //此处为赋值并调用这个函数，并将函数的运行结果赋给$re这个变量（1和2为实参）
echo $re;    //现在输出$re这个变量，结果得3
?>

观察上述代码，可以看出是一个自定义的求和函数。函数可以随个人喜好进行命名；例如此函数的命名不一定非得是sum，也可以起名叫qiuhe或者plus甚至叫whatever都行。函数体则是定义这个函数以哪种方式运行，此段代码只是定义了一个简单的加法并返还一个得出的结果。$re = sum(1,2)这是一种赋值方法，意为将1、2这两个值传给参数$a与参数$b。因为这里并没有给参数赋值，所以在调用函数的时候需要赋值传递给参数。对于函数来说，参数的不同设置方式，决定了其调用和使用方式。当然这段代码也可以在起函数时就给参数赋值，例如：function sum($a=1, $b=2)。使用时直接调用即可，如：$re = sum();

参数设置

函数参数的设置方法有很多种上面的代码使用的是按值传递的方法，也叫传参。function sum($a, $b)中的$a和$b这两个个变量，即在定义时声明的参数叫做形参，无论形参是否设置了默认值都叫形参。而$re = sum(1,2)中的1和2就叫实参，只有经过传递的值才叫实参；若在定义函数时设置了默认值，这个默认值就不叫实参，它只是作为在调用函数时未提供相应实参的情况下使用的备选值

按值传递参数

继续引用上段代码

<?php
function sum($a, $b){                  
	return $a+$b;    
};
$re = sum(1,2);   
echo $re;   
?>

在这段代码中调用函数时使用的1,2这两个实参会按顺序传递给形参$a,$b，然后经由函数体内定义的方式进行计算，最后用return这个关键字将结果返还给$re。关键字return可以理解为return to；这里将计算结果3这个值return to $re，或者可以理解为通过return将值赋给了$re。

利用变量传值

<?php
function sum($a,$b){
  return $a+$b;
}
$x=2;
$y=9;
echo sum($x,$y);
?>

在这段代码中$a,$b仍然是函数的形参，而实参是2,9。$x,$y是实参的变量名，2,9则是实参的具体值

无参函数

适用于不需要提供任何的数据即可以完成指定功能的情况，例如：

function shout()
{
    return 'come on';
}
echo shout();// 输出结果：come on

默认参数设置与传参规则

默认参数必须在设置形参时置于末尾，因为调用函数时实参是按顺序传递的，如下，$c的默认值设置为25：

<?php
function sum($a,$b,$c=25){
  return $a+$b+$c;
}
$x=2;
$y=9;
echo sum($x,$y);   //结果得36
?>

若像下段代码，将$b与$c位置颠倒则会报错：

<?php
function sum($a,$c=25,$b){
  return $a+$b+$c;
}
$x=2;
$y=9;
echo sum($x,$y);    //此结果会报错
?>

因为$y只是覆盖了默认值，而$b没有得到实参

上文中记录过：若在定义函数时设置了默认值；这个默认值不叫实参，它只是作为在调用函数时未提供相应实参的情况下使用的备选值，例：

<?php
function sum($a,$b,$c=25){
  return $a+$b+$c;
}
$x=2;
$y=9;
echo sum($x,$y,5);    //输出结果为16
?>

此段代码中5覆盖了$c的默认值

引用覆盖

在开发中，若需要函数修改它的参数值，则需通过函数参数的引用传递。实现方式只需在参数前添加取地址符&即可，例如下面两段代码；

<?php
function cover($cov)
{
	$cov='已覆盖';
}
$a = '未覆盖';
cover($a);   //这一步没有任何意义
echo $a;   //结果仍然是$a的值：未覆盖



function cover(&$cov)
{
	$cov='已覆盖';
}
$a = '未覆盖';
cover($a);
echo $a;   //因为使用了取地址符&，两个变量共用一个地址，所以$a的值被函数覆盖，变成$cov的值：已覆盖
?>

因为&会让两个变量共用一个内存地址，所以$a被函数中的值覆盖

指定参数数据类型

在某些情况下，需要参数以特定的数据类型运行，此时在定义函数时就需要指定类型。（此功能需要PHP 7.0及以上的版本）

弱类型

function sum1(int $a, int $b)
{
    return $a + $b;
}
echo sum1(2.6, 3.8); // 输出结果：5

当用户调用函数时，如果传递的参数不是int类型，程序会将其强制的转换为int型后，再进行操作，这种方式称为弱类型参数设置。此规则不遵循四舍五入，而是将小数点后的数字全部丢弃

强类型

declare(strict_types = 1);
function sum2(int $a, int $b)
{
    return $a + $b;
}
echo sum2(2.6, 3.8); //结果会报错

强类型通过declare(strict_types = 1);进行声明，即当用户传递的参数类型不符合函数的定义，程序会报错提醒。declare(strict_types = 1);是php7引入的严格类型检查模式的指定语法，因此声明后设置实参时必须符合形参指定的数据类型

变量的作用域

function test()
{
    $sum = 36; 	// 局部变量
    return $sum;
}
$sum = 0; 	// 全局变量
echo test();   	// 输出结果：36
echo $sum;    	// 输出结果：0

在函数中定义的变量称为局部变量，在函数外定义的变量称为全局变量。可以理解为函数体外的变量就是全局变量，函数体内的用于定义函数运行规则的就是局部变量

在自定义函数中引入全局变量

<?php
$v=100;    //定义了一个全局变量
function test(){    
	global $v;    //用global关键字引入全局变量
$y=10;
	return $v+$y;
}
echo test();     //结果为：110
?>

或使用超全局变量$GLOBALS['v'],如下：

<?php
$v=100;    //定义了一个全局变量
function test(){    

$y=10;
	return $GLOBALS['v']+$y;
}
echo test();     //结果为：110
?>

全局变量是在脚本中定义的，可以在脚本的任何地方访问。一般情况下，在函数内部无法直接访问全局变量，除非使用 global 关键字声明

超全局变量是 PHP 中的特殊变量，它们在脚本的任何地方都可以访问，而无需使用 global 关键字声明。超全局变量是预定义的，它们在 PHP 中始终可用，无需特别的配置。一些常见的超全局变量包括 $_GET、$_POST、$_SESSION、$_COOKIE 等

主要的区别在于：

全局变量需要使用 global 关键字声明才能在函数内部使用，而超全局变量无需声明即可在函数内外直接访问

超全局变量是 PHP 预定义的一组特殊变量，具有特殊的用途，比如 $_GET 用于获取通过 URL 参数传递的数据，$_POST 用于获取通过 POST 方法提交的数据等。而全局变量则是用户自定义的变量，可以在脚本的任何地方使用

需要注意的是，在编写 PHP 脚本时，应该谨慎使用全局变量，因为它们可能导致命名冲突和代码的不易维护。在函数中传递参数或使用超全局变量可能是更好的选择
$GLOBALS 也是 PHP 中的超全局变量。$GLOBALS 是一个关联数组，包含了脚本中所有的全局变量，其键是变量名，值是变量的内容。通过 $GLOBALS 可以在脚本的任何地方访问和操作全局变量，而无需使用 global 关键字例如，如果有一个全局变量 $x，可以使用 $GLOBALS['x'] 来访问和修改它，或在函数内部使用 global $x。这使得在函数中访问全局变量更加方便

设置局部变量为静态变量

所有的全局变量都是静态变量，而局部变量只有定义时加上类型修饰符static，才为局部静态变量，例：

局部变量：

<?php
function num()
{
    $i = 1;
    echo $i;
    $i++;
}
echo num().'<br/>';    //1
echo num().'<br/>';    //1
echo num();    //三次输出都为1
?>

此代码三次的输出结果都为1，因为$i只是一个局部变量，虽然设置的$i自增，但是自增后的值并不会保存下来，所以每次调用输出的时候都会重新读取这个函数

设置静态变量：

<?php
function num()
{
    static $i = 1;
    echo $i;
    $i++;
}
echo num().'<br/>';    //1
echo num().'<br/>';    //2
echo num();    //3
?>

此代码在输出过一次后会将自增结果存入给$i分配的地址中，再次调用时会读取保存的值

重置静态函数设置if条件，达到条件后自动重置：

<?php
function num(){
    static $i = 1;
    echo $i;
    $i++;
    
    if($i>3){
      $i=1;     //设置如果$i的值保存三次后重置$i
    };

};
echo num().'<br/>';    //1
echo num().'<br/>';    //2
echo num().'<hr/>';    //3

echo num().'<br/>';    //1 $i被重置
echo num().'<br/>';    //2
echo num().'<br/>';    //3
?>

目前暂不知如何在函数体外重置$i

嵌套与递归

嵌套

函数的嵌套调用：指的是在调用一个函数的过程中，调用另外一个函数，这种在函数内调用其他函数的方式称为嵌套调用

所谓嵌套函数，就是在函数中定义并调用其他函数

嵌套函数可以将一个复杂的功能分解成多个子函数，再通过调用的方式结合起来，有利于提高函数的可读性

例：求学科的平均值

代码如下：

<?php
function sum($yuwen,$shuxue){      //先求和
    $sun=$yuwen+$shuxue;
    return $sun;
    }
function avg($yuwen,$shuxue){
    $avg=sum($yuwen,$shuxue)/2;     //套用求和函数
    return $avg;
    }
    $avg=avg(50,80);
	echo $avg;    //结果为65
?>

递归

递归调用：是函数嵌套调用中一种特殊的调用。它指的是一个函数在其函数体内调用自身的过程，这种函数称为递归函数

递归调用是一种解决方案，一种逻辑思想，将一个大工作分为逐渐减小的小工作,只不过在程序中，就是依靠函数嵌套这个特性来实现了

利用递归调用计算5的阶乘：

<?php
function fact($n) {
  if ($n <= 1) {
      return 1; // 0和1的阶乘都是1
  } else {
      return $n * fact($n - 1); // 递归调用
  }
}

// 使用例子
echo fact(5); // 输出 120，因为 5! = 5 * 4 * 3 * 2 * 1 = 120
?>

注:这段代码中的$n * fact($n - 1);可以理解为：

fact(5) = 5 * fact(4)
            = 5 * (4 * fact(3))
            = 5 * (4 * (3 * fact(2)))
            = 5 * (4 * (3 * (2 * fact(1))))
            = 5 * (4 * (3 * (2 * 1)))
            = 5 * 4 * 3 * 2 * 1

函数的高级应用

可变函数

<?php
# 变量函数的用法:
function demo(){
	echo "天王盖地虎! ";
	}
$de='demo'; //将demo函数名赋给变量$de;
echo $de();//调用该变量名加();
?>

可变函数的实现就是在一个变量名后添加一对圆括号()，让其变成一个函数的形式，然后PHP就寻找与变量值同名的函数，并且尝试执行它
暂不知这样变化有啥具体作用，个人认为不如好好考虑如何命名能更高效的使用函数

回调函数

回调函数（callback）：指的就是具有callable类型的函数，一般用作参数的传递。PHP内置函数call_user_func()可以接受用户自定义的回调函数作为参数。就是把函数作为参数传入进另一个函数中使用

<?php
function qwe($name,$age){
echo "我叫$name 我$age 岁了 <br>";
}
call_user_func('qwe', "张三",'18');
call_user_func('qwe', "李四",'24');
?>

将一个函数作为参数传递给另一个函数，并在需要的时候调用该函数
回调函数常用于事件处理、排序、过滤等场景，可以增加代码的灵活性和可复用性

匿名函数

匿名函数：就是没有函数名称的函数，也称作闭包函数，经常用作回调函数参数的值。对于临时定义的函数，使用匿名函数无需考虑函数命名冲突的问题

匿名函数可以直接把赋数赋值给变量，匿名函数仍然是函数，可以传入参数，直接把赋数赋值给变量，调用变量即为调用函数

匿名函数中使用外部的变量，需要通过use关键字实现。use关键字后圆括号()中的内容即为要使用的外部变量列表，多个变量之间使用英文逗号,分隔即可，例：

$c = 100;
$sum = function($a, $b) use($c) {
    return $a + $b + $c;
};
echo $sum(100, 200);  	// 输出结果：400

除此之外，匿名函数还可以作为函数的参数传递，实现回调函数，例：

<?php
function calculate($a, $b, $func)//回调函数
{
    return $func($a, $b);
}
echo calculate(100, 200, function($a, $b) { 	// 输出结果：300
    return $a + $b;
});
echo calculate(100, 200, function($a, $b) { 	// 输出结果：20000
    return $a * $b;
});
?>

内置函数

字符串函数

strlen()

$string = "Hello, World!";
$length = strlen($string);
echo "Length of the string: $length"; // Output: Length of the string: 13

理解： strlen() 函数用于获取字符串的长度。在这个例子中，$string 的长度是 13

strpos()

$string = "Hello, World!";
$position = strpos($string, "World");
echo "Position of 'World': $position"; // Output: Position of 'World': 7

理解： strpos() 函数用于查找子字符串在字符串中的第一次出现的位置。在这个例子中，"World" 第一次出现在索引 7 处

strrpos()

$string = "Hello, World!";
$position = strrpos($string, "o");
echo "Last position of 'o': $position"; // Output: Last position of 'o': 8

理解： strrpos() 函数类似于 strpos()，但它查找子字符串在字符串中的最后一次出现的位置。在这个例子中，最后一个 "o" 出现在索引 8 处

str_replace()

$string = "Hello, World!";
$newString = str_replace("World", "Universe", $string);
echo "Updated string: $newString"; // Output: Updated string: Hello, Universe!

理解： str_replace() 函数用于在字符串中替换指定的子字符串。在这个例子中，将 "World" 替换为 "Universe"

substr()

$string = "Hello, World!";
$substring = substr($string, 7, 5);
echo "Substring: $substring"; // Output: Substring: World

理解： substr() 函数用于获取字符串的子串。在这个例子中，从索引 7 开始提取长度为 5 的子串，结果是 "World"

explode()

$string = "Apple,Orange,Banana";
$fruitsArray = explode(",", $string);
print_r($fruitsArray); 
// Output: Array ( [0] => Apple [1] => Orange [2] => Banana )

理解： explode() 函数用于将字符串拆分为数组，根据指定的分隔符。在这个例子中，根据逗号拆分字符串为一个水果数组

implode()

$fruitsArray = array("Apple", "Orange", "Banana");
$string = implode(", ", $fruitsArray);
echo "Fruits: $string"; // Output: Fruits: Apple, Orange, Banana

理解： implode() 函数用于将数组元素连接成一个字符串，使用指定的分隔符。在这个例子中，将水果数组连接为一个以逗号和空格分隔的字符串

trim()

$string = "   Hello, World!   ";
$trimmedString = trim($string);
echo "Trimmed string: $trimmedString"; // Output: Trimmed string: Hello, World!

理解： trim() 函数用于去除字符串两端的空格或指定字符。在这个例子中，去除了字符串两端的空格

str_repeat()

$stars = str_repeat("*", 5);
echo "Stars: $stars"; // Output: Stars: *****

理解： str_repeat() 函数用于重复一个字符串指定的次数。在这个例子中，将星号 "*" 重复了 5 次

数学函数

abs()

$number = -5;
$absoluteValue = abs($number);
echo "Absolute value: $absoluteValue"; // Output: Absolute value: 5

理解： abs() 函数用于获取一个数字的绝对值。在这个例子中，获取了 -5 的绝对值，结果是 5

ceil()

$number = 4.3;
$ceiledValue = ceil($number);
echo "Ceiled value: $ceiledValue"; // Output: Ceiled value: 5

理解： ceil() 函数用于向上取整，获取大于或等于给定数字的最小整数。在这个例子中，4.3 被向上取整为 5

floor()

$number = 4.9;
$flooredValue = floor($number);
echo "Floored value: $flooredValue"; // Output: Floored value: 4

理解： floor() 函数用于向下取整，获取小于或等于给定数字的最大整数。在这个例子中，4.9 被向下取整为 4

fmod()

$dividend = 8;
$divisor = 3;
$remainder = fmod($dividend, $divisor);
echo "Remainder of $dividend divided by $divisor: $remainder"; // Output: Remainder of 8 divided by 3: 2

理解： fmod() 函数用于获取两个数相除的余数。在这个例子中，8 除以 3 的余数是 2

is_nan()

$number = sqrt(-1);
if (is_nan($number)) {
    echo "The number is not a valid number.";
} else {
    echo "The number is valid.";
}
// Output: The number is not a valid number.

理解： is_nan() 函数用于检查一个值是否为非数值（NaN）。在这个例子中，sqrt(-1) 返回了非数值，所以输出是 "The number is not a valid number."

max()

$numbers = array(5, 8, 2, 10);
$maximumValue = max($numbers);
echo "Maximum value: $maximumValue"; // Output: Maximum value: 10

理解： max() 函数用于获取一组数字中的最大值。在这个例子中，数组 [5, 8, 2, 10] 中的最大值是 10

本篇为数组和部分函数的个人理解与代码练习，欢迎补充指正

PHP基础语法的学习与个人理解 第二部分

数组

规则

数组的意义

用法

数组类型

详述定义方式

访问数组

遍历数组

用for循环遍历：

用foreach循环遍历：

用while循环遍历：

数组操作符

合并操作符+ :

相等操作符== 和 === :

不等操作符!=、<>与不全等操作符!==

数组的增删改查

增

删

改

查

数组常用函数

数组操作函数

array_pop()函数

array_push()函数

array_unshift()函数

array_shift()函数

array_unique()函数

array_slice()函数

array_splice()函数

检索函数

in_array()函数

array_search()函数

array_key_exists()函数

其他函数

count()函数

range()函数

array_rand()函数

array_keys()函数

array_values()函数:

array_column()函数

array_sum()函数

array_reverse()函数

array_merge()函数

array_flip()函数

array_combine()函数

array_chunk()函数

array_fill()函数

array_replace()函数

array_map()函数:

array_walk()函数:

函数

自定义函数

参数设置

按值传递参数

无参函数

默认参数设置与传参规则

引用覆盖

指定参数数据类型

变量的作用域

嵌套与递归

嵌套

递归

函数的高级应用

可变函数

回调函数

匿名函数

内置函数

字符串函数

数学函数

本篇为数组和部分函数的个人理解与代码练习，欢迎补充指正

PHP基础语法的学习与个人理解第二部分

用`for`循环遍历：

用`foreach`循环遍历：

用`while`循环遍历：

合并操作符`+` :

相等操作符`==` 和 `===` :

不等操作符`!=`、`<>`与不全等操作符`!==`

`array_pop()`函数

`array_push()`函数

`array_unshift()`函数

`array_shift()`函数

`array_unique()`函数

`array_slice()`函数

`array_splice()`函数

`in_array()`函数

`array_search()`函数

`array_key_exists()`函数

`count()`函数

`range()`函数

`array_rand()`函数

`array_keys()`函数

`array_values()`函数:

`array_column()`函数

`array_sum()`函数

`array_reverse()`函数

`array_merge()`函数

`array_flip()`函数

`array_combine()`函数

`array_chunk()`函数

`array_fill()`函数

`array_replace()`函数

`array_map()`函数:

`array_walk()`函数: