PHP基础入门（五）

[!NOTE]

本篇文章仅用于个人交流与学习，如涉及侵权请联系站长删除！

​ 在前面的PHP基础入门（二）中我们已经简单了解了有关于PHP数组的一些基础概念，这篇文章将展示关于PHP数组array的一些方法。

1. 创建和修改数组

1.1 创建基础数组

函数 作用 示例
array() 创建新数组 $arr = array("a", "b", "c"); 或 $arr = ["a", "b", "c"]; 
1
2
3
4
5
6
7
8
9
10
11
12
// 创建基础数组
$fruits = array("apple", "banana", "cherry");
echo "<pre>基础数组: "; print_r($fruits); echo "</pre>";
/*
输出：
基础数组: Array
(
    [0] => apple
    [1] => banana
    [2] => cherry
)
*/

1.2 填充数组

函数 作用 示例
array_fill() 填充固定值数组 $arr = array_fill(0, 5, "banana"); // [0=>"banana", 1=>"banana"...] 
1
2
3
4
5
6
7
8
9
10
11
12
// 填充数组
$filled = array_fill(0, 3, "orange");
echo "<pre>填充数组: "; print_r($filled); echo "</pre>";
/*
输出：
填充数组: Array
(
    [0] => orange
    [1] => orange
    [2] => orange
)
*/

1.3 组合键值对

函数 作用 示例
array_combine() 合并键数组和值数组 array_combine(["a","b"], [1,2]); // ["a"=>1, "b"=>2] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 组合键值对
$keys = ["a", "b", "c"];
$values = [1, 2, 3];
$combined = array_combine($keys, $values);
echo "<pre>组合数组: "; print_r($combined); echo "</pre>";
/*
输出：
组合数组: Array
(
    [a] => 1
    [b] => 2
    [c] => 3
)
*/

1.4 合并数组

函数 作用 示例
array_merge() 合并多个数组 array_merge(["a","b"], ["c","d"]); // ["a","b","c","d"] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 合并数组
$colors1 = ["red", "green"];
$colors2 = ["blue", "yellow"];
$merged = array_merge($colors1, $colors2);
echo "<pre>合并数组: "; print_r($merged); echo "</pre>";
/*
输出：
合并数组: Array
(
    [0] => red
    [1] => green
    [2] => blue
    [3] => yellow
)
*/

1.5 数组填充

函数 作用 示例
array_pad() 填充数组到指定长度 array_pad(["a","b"], 4, "x"); // ["a","b","x","x"] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 数组填充
$padded = array_pad(["a", "b"], 5, "fill");
echo "<pre>数组填充: "; print_r($padded); echo "</pre>";
/*
输出：
数组填充: Array
(
    [0] => a
    [1] => b
    [2] => fill
    [3] => fill
    [4] => fill
)
*/

1.6 数组增删操作

函数 作用 示例
array_push() 末尾添加元素 array_push($arr, "x", "y");
array_unshift() 开头添加元素 array_unshift($arr, "x", "y");
array_pop() 移除最后一个元素 $last = array_pop($arr);
array_shift() 移除第一个元素 $first = array_shift($arr); 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 数组增删操作
$stack = ["a", "b"];
array_push($stack, "c", "d"); // 此时为["a", "b", "c", "d"]
array_unshift($stack, "start"); // 此时为["start", "a", "b", "c", "d"]
$last = array_pop($stack); // 此时为["start", "a", "b", "c"]
$first = array_shift($stack); // 此时为["a", "b", "c"]
echo "<pre>增删操作: "; print_r($stack); echo "</pre>";
/*
输出：
增删操作: Array
(
    [0] => a
    [1] => b
    [2] => c
)
*/

1.7 数组去重和反转

函数 作用 示例
array_unique() 移除重复值 array_unique(["a","b","a"]); // ["a","b"]（优先保留前面先出的元素！）
array_reverse() 反转数组顺序 array_reverse(["a","b","c"]); // ["c","b","a"] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 去重和反转
$duplicates = ["apple", "banana", "apple", "cherry"];
$unique = array_unique($duplicates); // 此时为["apple", "banana", "cherry"]
$reversed = array_reverse($unique); // 此事为["cherry", "banana", "apple"]
echo "<pre>去重和反转: "; print_r($reversed); echo "</pre>";
/*
输出：
去重和反转: Array
(
    [0] => cherry
    [1] => banana
    [2] => apple
)
*/

2. 访问数组元素

2.1 获取所有键名

函数 作用 示例
array_keys() 获取所有键名 array_keys(["a"=>1,"b"=>2]); // ["a","b"] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 获取所有键名
$user = ["id" => 101, "name" => "John", "email" => "john@example.com"];

$keys = array_keys($user);
echo "<pre>所有键名: "; print_r($keys); echo "</pre>";
/*
输出：
所有键名: Array
(
    [0] => id
    [1] => name
    [2] => email
)
*/

2.2 获取所有值

函数 作用 示例
array_values() 获取所有值 array_values(["a"=>1,"b"=>2]); // [1,2] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 获取所有值
$user = ["id" => 101, "name" => "John", "email" => "john@example.com"];

$values = array_values($user);
echo "<pre>所有值: "; print_r($values); echo "</pre>";
/*
输出：
所有值: Array
(
    [0] => 101
    [1] => John
    [2] => john@example.com
)
*/

2.3 检查键是否存在

函数 作用 示例
array_key_exists() 检查键是否存在 array_key_exists("a", $arr); // true 
1
2
3
4
5
6
// 检查键是否存在
$user = ["id" => 101, "name" => "John", "email" => "john@example.com"];

$hasName = array_key_exists("name", $user);
echo "包含 'name' 键吗? " . ($hasName ? '是' : '否') . "<br>";
// 输出：包含 'name' 键吗? 是

2.4 检查值是否存在

函数 作用 示例
in_array() 检查值是否存在 in_array("a", $arr); // true 
1
2
3
4
5
6
// 检查值是否存在
$user = ["id" => 101, "name" => "John", "email" => "john@example.com"];

$hasJohn = in_array("John", $user);
echo "包含 'John' 值吗? " . ($hasJohn ? '是' : '否') . "<br>";
// 输出：包含 'John' 值吗? 是

2.5 搜索值位置

函数 作用 示例
array_search() 搜索值位置 array_search("a", $arr); // true 
1
2
3
4
5
6
// 搜索值位置
$user = ["id" => 101, "name" => "John", "email" => "john@example.com"];

$position = array_search("john@example.com", $user);
echo "'email' 值的键: " . ($position !== false ? $position : '未找到') . "<br>";
// 输出：'email' 值的键: email

3. 排序数组

3.1 索引数组排序

函数 作用 排序依据 示例
sort() 升序排序索引数组 值 sort($arr); // ["a","b","c"] → ["a","b","c"]
rsort() 降序排序索引数组 值 rsort($arr); // ["a","b","c"] → ["c","b","a"] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 索引数组排序
$numbers = [3, 1, 4, 2, 5];
sort($numbers);  // 升序
echo "<pre>升序排序: "; print_r($numbers); echo "</pre>";
/*
输出：
升序排序: Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
*/
rsort($numbers); // 降序
echo "<pre>降序排序: "; print_r($numbers); echo "</pre>";
/*
输出：
降序排序: Array
(
    [0] => 5
    [1] => 4
    [2] => 3
    [3] => 2
    [4] => 1
)
*/

3.2 关联数组排序

函数 作用 排序依据 示例
asort() 升序排序关联数组（保键） 值 asort(["a"=>3,"b"=>1]); // ["b"=>1,"a"=>3]
ksort() 升序按键排序关联数组 键 ksort(["b"=>2,"a"=>1]); // ["a"=>1,"b"=>2]
arsort() 降序按值排序关联数组 值 arsort(["a"=>1,"b"=>3]); // ["b"=>3,"a"=>1]
krsort() 降序按键排序关联数组 键 krsort(["a"=>1,"b"=>2]); // ["b"=>2,"a"=>1] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 关联数组排序
$ages = ["John" => 25, "Jane" => 30, "Jim" => 20];
asort($ages); // 按值升序
echo "<pre>按值升序: "; print_r($ages); echo "</pre>";
/*
输出：
按值升序: Array
(
    [Jim] => 20
    [John] => 25
    [Jane] => 30
)
*/
ksort($ages); // 按键升序
echo "<pre>按键升序: "; print_r($ages); echo "</pre>";
/*
输出：
按键升序: Array
(
    [Jane] => 30
    [Jim] => 20
    [John] => 25
)
*/
arsort($ages); // 按值降序
echo "<pre>按值降序: "; print_r($ages); echo "</pre>";
/*
输出：
按值降序: Array
(
    [Jane] => 30
    [John] => 25
    [Jim] => 20
)
*/
krsort($ages); // 按键降序
echo "<pre>按键降序: "; print_r($ages); echo "</pre>";
/*
输出：
按键降序: Array
(
    [John] => 25
    [Jim] => 20
    [Jane] => 30
)
*/

3.3 自定义排序

函数 作用 排序依据 示例
自定义排序 通过回调函数排序 - usort($arr, fn($a,$b) => $a["name"] <=> $b["name"]); 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// 自定义排序
$products = [
    ["name" => "Laptop", "price" => 999],
    ["name" => "Mouse", "price" => 25],
    ["name" => "Keyboard", "price" => 50]
];

usort($products, function($a, $b) {
    return $a["price"] <=> $b["price"];
});
echo "<pre>按价格排序: "; print_r($products); echo "</pre>";
/*
输出：
按价格排序: Array
(
    [0] => Array
        (
            [name] => Mouse
            [price] => 25
        )

    [1] => Array
        (
            [name] => Keyboard
            [price] => 50
        )

    [2] => Array
        (
            [name] => Laptop
            [price] => 999
        )

)
*/
  • 解释：
    1. 首先我们使用变量$products定义了一个二维数组，它包含三个产品，每一个产品都是一个关联数组，它们包含name和price两个键。初始的顺序为：Laptop → Mouse → keyboard。
    2. usort()函数的两个参数比较特殊，可以使第一个参数：$products（本示例代码中的例子，可更换），通过第二个参数：一个匿名函数，中所定义的比较算法来对数组进行排序。
    3. 在匿名函数中参数$a和参数$b分别指代两个产品数组。而$a["price"] <=> $b["price"]则通过太空船运算符<=>来比较两个产品的价格值，最后可能返回的结果有三种：
      • 如果 $a 价格 < $b 价格 → 返回 -1，$a 排在前面。
      • 如果 $a 价格 = $b 价格 → 返回 0，位置不变。
      • 如果 $a 价格 > $b 价格 → 返回 1，$b 排在前面。
    4. 最后将比较的结果返回，我们就得到了排序好的数组了。

4. 比较数组

4.1 值比较

函数 作用 示例
array_diff() 返回差集（值比较） array_diff([1,2,3], [2,3]); // [1]
array_intersect() 返回交集（值比较） array_intersect([1,2,3], [2,3]); // [2,3] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 值比较
$set1 = ["red", "green", "blue"];
$set2 = ["green", "blue", "yellow"];

$diff = array_diff($set1, $set2);
echo "<pre>差集(值): "; print_r($diff); echo "</pre>";
/*
输出：
差集(值): Array
(
    [0] => red
)
*/
$intersect = array_intersect($set1, $set2);
echo "<pre>交集(值): "; print_r($intersect); echo "</pre>";
/*
输出：
交集(值): Array
(
    [1] => green
    [2] => blue
)
*/

4.2 键值比较

函数 作用 示例
array_diff_assoc() 返回差集（键值比较） array_diff_assoc(["a"=>1,"b"=>2], ["a"=>1]); // ["b"=>2]
array_intersect_assoc() 返回交集（键值比较） array_intersect_assoc(["a"=>1,"b"=>2], ["a"=>1]); // ["a"=>1] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 键值比较
$set3 = ["red" => "#f00", "green" => "#0f0", "blue" => "#00f"];
$set4 = ["red" => "#f00", "yellow" => "#ff0"];

$diffAssoc = array_diff_assoc($set3, $set4);
echo "<pre>差集(键值): "; print_r($diffAssoc); echo "</pre>";
/*
输出：
差集(键值): Array
(
    [green] => #0f0
    [blue] => #00f
)
*/
$intersectAssoc = array_intersect_assoc($set3, $set4);
echo "<pre>交集(键值): "; print_r($intersectAssoc); echo "</pre>";
/*
输出：
交集(键值): Array
(
    [red] => #f00
)
*/

5. 实用函数

5.1 映射函数

​ 映射函数——array_map()，它的作用是：应用回调函数到每个元素。例如：array_map("strtoupper", ["a","b"]); // ["A","B"]。这个函数中我们可以通过参数一的匿名函数来对数组的每一个元素进行操作，就像例子中我们对每一个元素都进行了平方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 映射函数
$numbers = [1, 2, 3, 4, 5];

$squared = array_map(function($n) { return $n * $n; }, $numbers);
echo "<pre>平方映射: "; print_r($squared); echo "</pre>";
/*
输出：
平方映射: Array
(
    [0] => 1
    [1] => 4
    [2] => 9
    [3] => 16
    [4] => 25
)
*/

5.2 过滤函数

​ 过滤函数——array_filter()，它的作用是：用回调过滤数组。例如：array_filter([1,2,3], fn($v) => $v>1); // [2,3]。顾名思义这个函数是通过参数二的匿名函数自定义的过滤出数组中符合条件的元素，可以看到例子中我们过滤出了可以被2整除的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
// 过滤函数
$numbers = [1, 2, 3, 4, 5];

$even = array_filter($numbers, function($n) { return $n % 2 == 0; });
echo "<pre>偶数过滤: "; print_r($even); echo "</pre>";
/*
输出：
偶数过滤: Array
(
    [1] => 2
    [3] => 4
)
*/

5.3 归约函数

​ 归约函数——array_reduce()，它的作用是：迭代缩减为单一值。例如：array_reduce([1,2,3], fn($c,$v) => $c+$v, 0); // 6。

1
2
3
4
5
6
7
8
// 归约函数
$numbers = [1, 2, 3, 4, 5];

$sum = array_reduce($numbers, function($carry, $n) {
    return $carry + $n;
}, 0);
echo "数组求和: $sum<br>";
// 输出：数组求和: 15

5.4 数组遍历

​ 数组遍历——array_walk()，它的作用是：自定义处理每个元素。例如：array_walk($arr, fn($v) => echo $v);。

1
2
3
4
5
6
7
8
// 数组遍历
$numbers = [1, 2, 3, 4, 5];

echo "数组遍历: ";
array_walk($numbers, function($value, $key) {
    echo "[$key=>$value] ";
});
// 输出：数组遍历: [0=>1] [1=>2] [2=>3] [3=>4] [4=>5]

5.5 数组分块

​ 数组分块——array_chunk()，它的作用是：分割数组为多块。例如：array_chunk(["a","b","c"], 2); // [["a","b"], ["c"]]。其中参数二指明了这个要分块数组每一部分含有多少个元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 数组分块
$chunks = array_chunk(["a", "b", "c", "d", "e"], 2);
echo "<pre>数组分块: "; print_r($chunks); echo "</pre>";
/*
输出：
数组分块: Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

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

    [2] => Array
        (
            [0] => e
        )

)
*/

5.6 数组切片

​ 数组切片——array_slice()，它的作用是：截取数组片段。例如：array_slice(["a","b","c"], 1, 2); // ["b","c"]。其中参数二和参数三指明了切片的其实和终止位置。

1
2
3
4
5
6
7
8
9
10
11
12
// 数组切片
$slice = array_slice(["a", "b", "c", "d", "e"], 1, 3);
echo "<pre>数组切片: "; print_r($slice); echo "</pre>";
/*
输出：
数组切片: Array
(
    [0] => b
    [1] => c
    [2] => d
)s
*/

5.7 栈模拟

​ 栈模拟使用数组实现栈操作。例如：$stack = [];array_push($stack, 3);$top = array_pop($stack);。（先入后出）

1
2
3
4
5
6
// 栈模拟
$stack = [];
array_push($stack, "first", "second");
$top = array_pop($stack);
echo "栈顶元素: $top<br>";
// 输出：栈顶元素：second

6. 数组统计

函数 作用 示例
array_sum() 计算值总和 array_sum([1,2,3]); // 6
array_product() 计算值乘积 array_product([2,3,4]); // 24
count() 统计元素数量 count(["a","b"]); // 2
array_count_values() 统计值出现次数 array_count_values(["a","b","a"]); // ["a"=>2, "b"=>1] 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 数组统计
$data = [10, 20, 30, 10, 20, 10];
$count = count($data);
$sum = array_sum($data);
$product = array_product([2, 3, 4]);
$frequencies = array_count_values($data);

echo "<pre>数组统计: 
元素数量: $count
元素总和: $sum
元素乘积(2×3×4): $product
值频率: "; print_r($frequencies); echo "</pre>";
/*
输出：
数组统计: 
元素数量: 6
元素总和: 100
元素乘积(2×3×4): 24
值频率: Array
(
    [10] => 3
    [20] => 2
    [30] => 1
)
*/