全面解析与实战应用 | www.xservx.com
在 PHP 开发中,数组是最核心、最常用的数据结构之一,几乎贯穿所有业务逻辑处理场景。从简单的数据传递到复杂的算法实现,php 数组方法提供了强大而灵活的操作能力。掌握这些方法,不仅提升开发效率,更能写出健壮、可维护的代码。
PHP 提供了超过 100 个数组处理函数,覆盖增删改查、排序、过滤、映射、聚合、遍历等全生命周期操作。本页将系统梳理高频实用方法,结合真实业务场景,提供可直接复用的代码范例与注意事项,助您从“会用”进阶到“善用”。
以电商系统为例:用户购物车数据通常以多维数组存储商品信息(id、name、price、qty);订单筛选需用 array_filter 过滤状态;统计总金额需 array_column + array_sum;排序则依赖 usort 或 uasort。脱离对 php 数组方法 的深刻理解,这些逻辑将变得冗长且易错。
本文不堆砌函数列表,而是以“问题驱动”方式组织内容,每个方法均配以深度解析与多场景示例,确保学完即可落地应用。
PHP 的 数组 本质是一个有序映射(ordered map),即键值对的集合。它既是 索引数组(整数键,从 0 开始)又是 关联数组(字符串键),兼具数组与哈希表的特性,这是其强大却易被误用的根本原因。
索引数组(Index Array):键为连续整数,如 [0 => 'A', 1 => 'B', 2 => 'C'],适合顺序存储、队列/栈操作。
关联数组(Associative Array):键为字符串,如 ['name' => 'Tom', 'age' => 28],适合键值映射,查找复杂度 O(1)。
混合结构(如 [0 => 'a', 'b' => 'B', 2 => 'c'])虽合法,但易引发遍历混乱,建议避免。使用 is_array() + array_keys() 可判断结构类型:
<?php
$data = ['x' => 10, 'y' => 20];
$keys = array_keys($data);
$isAssoc = count(array_filter($keys, 'is_string')) > 0;
echo $isAssoc ? '关联数组' : '索引数组'; // 输出:关联数组
?>
推荐使用 [] 初始化空数组(PHP 5.4+),比 array() 更简洁:
<?php
$empty = []; // 等价于 array()
$init = ['php', 'js', 'go'];
?>
⚠️ 避免使用 NULL 初始化后追加:如 $arr = NULL; $arr[] = 'x'; 会触发 Notice。应始终初始化为 [] 或 [0] 等有效结构。
<?php
$items = [];
$items[0] = 'A'; // 预占位避免动态扩容
$items[1] = 'B';
?>
向数组末尾或开头添加元素是高频操作,不同方法适用场景不同,需结合性能与语义选择。
向数组末尾添加一个或多个元素,返回新长度:
<?php
$stack = ['A', 'B'];
array_push($stack, 'C', 'D');
print_r($stack); // 输出:['A', 'B', 'C', 'D']
?>
⚠️ 注意:当仅添加单个元素时,使用 $arr[] = 'x' 比 array_push() 更快(省去函数调用开销)。实测:10万次循环中 $arr[] 比 array_push() 快约 15%。
向数组开头插入元素,后续键自动重排(索引数组):
<?php
$queue = ['B', 'C'];
array_unshift($queue, 'A');
print_r($queue); // 输出:['A', 'B', 'C']
?>
⚠️ 性能警告:对大数组调用 array_unshift() 会重置所有索引,时间复杂度 O(n),慎用于高频场景。推荐用双端队列(SplDoublyLinkedList)替代。
当需指定位置插入时,直接赋值最高效:
<?php
$data = ['A', 'B', 'D'];
$data[2] = 'C'; // 注意:此操作会覆盖原值
print_r($data); // ['A', 'B', 'C']
?>
若需插入不覆盖,需手动移动后续元素:
<?php
$data = ['A', 'B', 'D'];
$pos = 2;
array_splice($data, $pos, 0, 'C'); // 推荐方式
print_r($data); // ['A', 'B', 'C', 'D']
?>
功能最全面的插入工具,可同时处理删除、替换、插入:
<?php
$colors = ['red', 'green', 'blue'];
array_splice($colors, 1, 0, ['yellow']); // 在索引1插入
print_r($colors); // ['red', 'yellow', 'green', 'blue']
?>
当需按键名合并且避免重排时:
<?php
$arr1 = ['a' => 1, 'b' => 2];
$arr2 = ['c' => 3];
$result = $arr1 + $arr2;
print_r($result); // ['a' => 1, 'b' => 2, 'c' => 3]
?>
⚠️ 关键区别:+ 运算符仅添加 $arr2 中 $arr1 不存在的键,若键已存在则跳过。与 array_merge() 行为截然不同!
用户提交新增商品时,避免重复 ID 覆盖,用 array_merge_recursive() 合并:
<?php
$cart = [
['id' => 101, 'qty' => 2],
['id' => 102, 'qty' => 1]
];
$newItem = ['id' => 101, 'qty' => 1];
$cart = array_merge_recursive($cart, [$newItem]);
// 结果:['id' => [101,101], 'qty' => [2,1]] → 需后续聚合
// 更优方案:先检查是否存在,存在则更新 qty
?>
推荐方式:用 array_column() 提取 ID 列检查重复:
<?php
$ids = array_column($cart, 'id');
if (in_array($newItem['id'], $ids)) {
$key = array_search($newItem['id'], $ids);
$cart[$key]['qty'] += $newItem['qty'];
} else {
$cart[] = $newItem;
}
?>
删除操作需特别注意键名重排、引用失效、空数组处理等问题。
移除并返回数组最后一个元素,自动重排索引:
<?php
$stack = ['A', 'B', 'C'];
$last = array_pop($stack);
echo $last; // 输出:C
print_r($stack); // ['A', 'B']
?>
✅ 优势:对空数组调用返回 NULL,无警告;自动维护索引连续性。
通过 end() + key() + unset() 删除末元素但保留原索引:
<?php
$keys = array_keys($arr);
$lastKey = end($keys);
unset($arr[$lastKey]);
?>
⚠️ 仅适用于需保留键名的场景(如关联数组),否则推荐 array_pop()。
移除并返回第一个元素,重排所有索引:
<?php
$queue = ['A', 'B', 'C'];
$first = array_shift($queue);
echo $first; // 输出:A
print_r($queue); // ['B', 'C']
?>
⚠️ 性能陷阱:对大数组操作成本高(需重排所有键),高频场景建议用 SplQueue:
<?php
$queue = new SplQueue();
$queue->enqueue('A');
$queue->enqueue('B');
$first = $queue->dequeue(); // O(1) 操作
?>
直接移除指定键,不重排索引:
<?php
$arr = ['a' => 1, 'b' => 2, 'c' => 3];
unset($arr['b']);
print_r($arr); // ['a' => 1, 'c' => 3]
?>
⚠️ 陷阱:对索引数组调用后,索引不连续(0,2 而非 0,1),后续循环可能遗漏。修复方案:
<?php
unset($arr[1]);
$arr = array_values($arr); // 重置索引
?>
删除指定长度的元素,自动重排索引:
<?php
$data = ['A', 'B', 'C', 'D'];
array_splice($data, 1, 2); // 从索引1删除2个元素
print_r($data); // ['A', 'D']
?>
✅ 优势:无论索引是否连续,均能正确操作,且重排索引。
删除前务必检查数组是否为空,避免逻辑错误:
<?php
if (!empty($items)) {
$last = array_pop($items);
// 处理逻辑
} else {
// 空数组处理
}
?>
更严谨写法(防止 NULL 警告):
<?php
$last = $items ? array_pop($items) : null;
?>
合并是数据聚合的基础操作,但不同方法行为差异巨大,需精准选择。
核心规则:数字键连续重排;字符串键后者覆盖前者:
<?php
$a = [0 => 'A', 1 => 'B', 'x' => 1];
$b = [2 => 'C', 'x' => 2, 'y' => 3];
$result = array_merge($a, $b);
?>
✅ 适用场景:拼接查询结果、合并配置项(后者优先)。
仅添加右侧 $b 中 $a 不存在的键:
<?php
$a = ['x' => 1, 'y' => 2];
$b = ['y' => 3, 'z' => 4];
$result = $a + $b;
// 结果:['x' => 1, 'y' => 2, 'z' => 4] → y 未覆盖
?>
⚠️ 常见错误:误以为 + 会合并所有键,实际是“取并集,保留左侧值”。
当值为数组时,递归合并而非覆盖:
<?php
$a = ['user' => ['name' => 'Tom', 'role' => 'admin']];
$b = ['user' => ['age' => 28]];
$result = array_merge_recursive($a, $b);
?>
⚠️ 深坑:若键值非数组(如字符串),会自动转为数组!
<?php
$a = ['msg' => 'Hello'];
$b = ['msg' => 'World'];
$result = array_merge_recursive($a, $b);
// 结果:['msg' => ['Hello', 'World']] → 非预期!
?>
✅ 替代方案:用 array_replace_recursive()(PHP 5.3+),仅对数组值递归合并:
<?php
$a = ['msg' => 'Hello'];
$b = ['msg' => 'World'];
$result = array_replace_recursive($a, $b);
// 结果:['msg' => 'World'] → 字符串正常覆盖
?>
场景:合并用户订单列表(按 user_id 分组):
<?php
$orders1 = [
['user_id' => 1, 'amount' => 100],
['user_id' => 2, 'amount' => 50]
];
$orders2 = [
['user_id' => 1, 'amount' => 200],
['user_id' => 3, 'amount' => 75]
];
// 目标:按 user_id 汇总总金额
$merged = [];
foreach (array_merge($orders1, $orders2) as $order) {
$uid = $order['user_id'];
if (!isset($merged[$uid])) {
$merged[$uid] = ['user_id' => $uid, 'total' => 0];
}
$merged[$uid]['total'] += $order['amount'];
}
print_r(array_values($merged)); // 重置索引
?>
✅ 最佳实践:复杂合并逻辑用循环 + 条件判断,比内置函数更可控、可读。
截取是分页、数据分片的核心,需兼顾效率与语义。
语法:array_slice(array, offset, length, preserve_keys)
<?php
$data = ['A','B','C','D','E'];
$part = array_slice($data, 1, 3, true); // preserve_keys=true
print_r($part); // [1 => 'B', 2 => 'C', 3 => 'D']
?>
✅ 关键参数:preserve_keys 默认为 false(重排索引),设为 true 可保留原键名。
offset 为负值时,从末尾倒数开始:
<?php
$lastThree = array_slice($data, -3, 3); // ['C','D','E']
?>
⚠️ 注意:负偏移时,length 必须非负;若 length 省略,则截取到末尾。
将数组分割为指定大小的子数组:
<?php
$data = range(1, 10);
$chunks = array_chunk($data, 3);
?>
✅ 实用场景:批量处理大数组(避免内存溢出),如邮件发送:
<?php
$emails = get_all_subscribers(); // 假设10万条
foreach (array_chunk($emails, 1000) as $batch) {
send_batch_emails($batch);
sleep(1); // 限流
}
?>
⚠️ 注意:默认重排索引,设 preserve_keys=true 可保留。
标准分页逻辑(页码从 1 开始):
<?php
$total = count($items);
$perPage = 20;
$page = max(1, (int)$_GET['page']);
$offset = ($page - 1) * $perPage;
$pagedItems = array_slice($items, $offset, $perPage);
$totalPages = (int)ceil($total / $perPage);
?>
✅ 性能优化:对超大数组,先用 array_keys() 获取索引再截取,减少内存占用:
<?php
$keys = array_keys($items);
$offsetKeys = array_slice($keys, $offset, $perPage);
$pagedItems = array_intersect_key($items, array_flip($offsetKeys));
?>
| 特性 | array_slice() | array_splice() |
|---|---|---|
| 是否修改原数组 | 否(返回新数组) | 是(原数组被截断) |
| 返回值 | 截取部分 | 被移除部分 |
| 键名处理 | 可选保留 | 始终重排索引 |
| 适用场景 | 数据展示、分页 | 原地修改、插入删除 |
搜索是数据检索的基础,不同方法适用于不同场景。
基础用法:
<?php
if (in_array('php', $languages)) {
echo "支持 PHP";
}
?>
⚠️ 严格模式:默认弱比较,推荐启用第三参数 true:
<?php
$nums = [0, 1, 2];
in_array('0', $nums); // true('0' == 0)
in_array('0', $nums, true); // false('0' !== 0)
?>
返回首次匹配的键,未找到返回 false:
<?php
$key = array_search('php', $langs); // 'lang1'
?>
⚠️ 注意:返回 0 或 '0' 时需用 === false 判断,避免 0 被视为 false:
<?php
$key = array_search('A', ['A','B']);
if ($key !== false) { ... } // 正确判断
?>
比 isset() 更可靠(可检测值为 NULL 的键):
<?php
$arr = ['a' => 1, 'b' => null];
isset($arr['b']); // false
array_key_exists('b', $arr); // true
?>
可选过滤条件:
<?php
$keys = array_keys($arr, 'php', true); // 第三参数严格匹配
?>
返回满足条件的元素(默认移除所有 false 值):
<?php
$nums = [0, 1, 2, 3];
$even = array_filter($nums, function($n) { return $n % 2 == 0; });
// 结果:[0 => 0, 2 => 2] → 保留原键名
?>
✅ 重置索引:用 array_values() 包裹:
<?php
$even = array_values(array_filter($nums, ...));
?>
搜索嵌套数组中的特定值:
<?php
$users = [
['id' => 1, 'name' => 'Tom'],
['id' => 2, 'name' => 'Jerry']
];
$key = array_search(2, array_column($users, 'id'));
$target = $users[$key];
?>
对超大数组,预构建索引表加速查询:
<?php
// 构建索引:id → 原始索引
$index = array_flip(array_column($users, 'id'));
// O(1) 查询
if (isset($index[5])) {
$user = $users[$index[5]];
}
?>
⚠️ 注意:索引构建成本 O(n),仅适用于查询频次远高于构建频次的场景。
PHP 排序函数丰富,但易混淆,需按场景精准选择。
默认升序/降序,**修改原数组**,重排索引:
<?php
$nums = [3, 1, 2];
sort($nums); // [1,2,3]
rsort($nums); // [3,2,1]
?>
⚠️ 注意:字符串比较区分大小写('Z' < 'a'),需用 natcasesort() 实现自然排序(忽略大小写):
<?php
$files = ['file2.txt', 'file10.txt', 'file1.txt'];
sort($files); // ['file1.txt', 'file10.txt', 'file2.txt']
natcasesort($files); // ['file1.txt', 'file2.txt', 'file10.txt']
?>
按值排序,保持键值对应关系:
<?php
$scores = ['Tom' => 95, 'Jerry' => 88];
asort($scores); // ['Jerry' => 88, 'Tom' => 95]
?>
按键名排序(字符串/数字):
<?php
$data = ['b' => 2, 'a' => 1];
ksort($data); // ['a' => 1, 'b' => 2]
?>
usort():按值排序,重排索引:
<?php
$users = [
['name' => 'Tom', 'age' => 28],
['name' => 'Jerry', 'age' => 25]
];
usort($users, function($a, $b) {
return $a['age'] - $b['age'];
});
// 按年龄升序
?>
uasort():按值排序,保留键名:
<?php
$scores = ['Tom' => 95, 'Jerry' => 88];
uasort($scores, function($a, $b) {
return $b - $a; // 降序
});
// ['Tom' => 95, 'Jerry' => 88]
?>
uksort():按键名排序:
<?php
$data = ['B' => 2, 'a' => 1];
uksort($data, 'strcasecmp'); // 忽略大小写排序
// ['a' => 1, 'B' => 2]
?>
先按 age 升序,再按 name 升序:
<?php
usort($users, function($a, $b) {
$ageDiff = $a['age'] - $b['age'];
if ($ageDiff !== 0) return $ageDiff;
return strcmp($a['name'], $b['name']);
});
?>
| 方法 | 时间复杂度 | 适用场景 |
|---|---|---|
| sort / rsort | O(n log n) | 简单数值/字符串排序 |
| usort | O(n log n) × 比较成本 | 自定义逻辑(如多字段) |
| asort / ksort | O(n log n) | 关联数组排序 |
✅ 实战建议:对 1000+ 元素数组,避免在循环内排序;优先用 SQL 排序(数据库索引优化)。
过滤是数据预处理的关键步骤,确保后续逻辑健壮性。
最简用法:清理空值
<?php
$input = ['', 'php', null, 'js', 0, false];
$clean = array_filter($input);
// 结果:[1 => 'php', 3 => 'js'] → 移除空字符串、NULL、0、false
?>
⚠️ 注意:0 和 '0' 会被移除,若需保留,需自定义回调:
<?php
$clean = array_filter($input, function($v) { return $v !== '' && $v !== null; });
// 保留 0 和 '0'
?>
场景:过滤无效邮箱
<?php
$emails = ['a@b.com', 'invalid', 'c@d.org'];
$valid = array_filter($emails, 'filter_var', FILTER_VALIDATE_EMAIL);
// 结果:[0 => 'a@b.com', 2 => 'c@d.org']
?>
多条件过滤(年龄 > 18 且 非空):
<?php
$users = [
['name' => 'Tom', 'age' => 20],
['name' => 'Jerry', 'age' => 16],
['name' => 'Spike', 'age' => null]
];
$adults = array_filter($users, function($u) {
return $u['age'] !== null && $u['age'] >= 18;
});
?>
先清理再过滤:移除前后空格 + 非空检查
<?php
$input = [' php ', ' ', 'js ', ''];
$clean = array_filter(array_map('trim', $input));
// 结果:[0 => 'php', 2 => 'js']
?>
按字符串比较去重('1' 和 1 视为相同):
<?php
$data = [1, '1', 2, '2', 3];
$unique = array_unique($data);
// 结果:[0 => 1, 2 => 2, 4 => 3]
?>
⚠️ 深坑:对多维数组无效,需序列化后处理:
<?php
$arr = [['a','b'], ['a','b'], ['c']];
$serialized = array_map('serialize', $arr);
$unique = array_unique($serialized);
$cleaned = array_map('unserialize', $unique);
?>
转换是连接原始数据与业务逻辑的桥梁。
核心用法:array_column(array, column_key, index_key)
<?php
$users = [
['id' => 1, 'name' => 'Tom'],
['id' => 2, 'name' => 'Jerry']
];
$names = array_column($users, 'name');
// ['Tom', 'Jerry']
$named = array_column($users, 'name', 'id');
// [1 => 'Tom', 2 => 'Jerry']
?>
✅ 实战:构建下拉选项
<?php
$options = array_column($users, 'name', 'id');
echo '';
?>
分隔符连接:
<?php
$langs = ['php', 'js', 'go'];
$str = implode(', ', $langs); // 'php, js, go'
?>
⚠️ 注意:对空数组返回空字符串;对单元素数组返回该元素。
结构化输出:
<?php
$data = ['status' => 'ok', 'items' => [1,2,3]];
echo json_encode($data, JSON_UNESCAPED_UNICODE);
// {"status":"ok","items":[1,2,3]}
?>
用一个数组的值作为键,另一个作为值:
<?php
$keys = ['name', 'age'];
$values = ['Tom', 28];
$obj = array_combine($keys, $values);
// ['name' => 'Tom', 'age' => 28]
?>
⚠️ 必须保证两个数组长度相同,否则返回 FALSE。
递归转换(含私有属性):
<?php
function objectToArray($obj) {
return json_decode(json_encode($obj), true);
}
?>
✅ 优势:保留所有属性,包括 protected/private。
映射是函数式编程的核心,将输入转换为输出。
对每个元素应用回调:
<?php
$nums = [1, 2, 3];
$squares = array_map(function($n) { return $n * $n; }, $nums);
// [1, 4, 9]
?>
⚠️ 注意:回调返回 NULL 时,结果中对应位置为 NULL(非移除)。
同时遍历多个数组:
<?php
$names = ['Tom', 'Jerry'];
$ages = [20, 25];
$descriptions = array_map(function($n, $a) {
return "$n ($a 岁)";
}, $names, $ages);
// ['Tom (20 岁)', 'Jerry (25 岁)']
?>
✅ 优势:避免嵌套循环,代码简洁。
闭包捕获上下文:
<?php
$prefix = 'ID:';
$users = [
['id' => 1, 'name' => 'Tom'],
['id' => 2, 'name' => 'Jerry']
];
$labels = array_map(function($u) use ($prefix) {
return $prefix . $u['id'] . ' - ' . $u['name'];
}, $users);
// ['ID:1 - Tom', 'ID:2 - Jerry']
?>
先过滤再映射:
<?php
$filtered = array_filter($users, fn($u) => $u['age'] > 18);
$names = array_column(array_map(fn($u) => ['name' => $u['name']], $filtered), 'name');
?>
聚合是计算总和、平均值、分组统计的基础。
语法:array_reduce(array, callback, initial)
<?php
$nums = [1, 2, 3, 4];
$sum = array_reduce($nums, function($carry, $item) {
return $carry + $item;
}, 0);
// 输出:10
?>
✅ initial 参数指定初始值,避免第一次循环时 $carry 未定义。
<?php
$avg = array_reduce($nums, function($carry, $item) {
static $count = 0;
$count++;
return $carry + $item;
}, 0) / count($nums);
?>
场景:按类别汇总销售额
<?php
$sales = [
['cat' => 'A', 'amount' => 100],
['cat' => 'B', 'amount' => 150],
['cat' => 'A', 'amount' => 200]
];
$grouped = array_reduce($sales, function($carry, $item) {
$cat = $item['cat'];
if (!isset($carry[$cat])) {
$carry[$cat] = 0;
}
$carry[$cat] += $item['amount'];
return $carry;
}, []);
// ['A' => 300, 'B' => 150]
?>
将扁平数据转为树形结构:
<?php
$items = [
['id' => 1, 'pid' => 0, 'name' => 'Root'],
['id' => 2, 'pid' => 1, 'name' => 'Child A'],
['id' => 3, 'pid' => 1, 'name' => 'Child B']
];
$tree = array_reduce($items, function($carry, $item) {
$carry[$item['id']] = $item;
if ($item['pid'] > 0) {
$carry[$item['pid']]['children'][] = &$carry[$item['id']];
}
return $carry;
}, []);
?>
对纯数值求和,直接用 array_sum() 更简洁高效:
<?php
$sum = array_sum(array_column($sales, 'amount'));
?>
复杂逻辑(如带条件的求和)才需 array_reduce()。
以下方法虽不常用,但关键时刻能省时省力。
求交集/差集(值比较):
<?php
$a = [1, 2, 3, 4];
$b = [3, 4, 5, 6];
$intersect = array_intersect($a, $b); // [2 => 3, 3 => 4]
$diff = array_diff($a, $b); // [0 => 1, 1 => 2]
?>
⚠️ 注意:对关联数组,仅比较值,不比较键。
安全获取首/末键名:
<?php
$data = ['a' => 1, 'b' => 2];
$firstKey = array_key_first($data); // 'a'
$lastKey = array_key_last($data); // 'b'
?>
✅ 替代方案:对旧版 PHP 用 reset($arr); key($arr)。
生成连续值数组:
<?php
$nums = range(1, 10); // [1,2,...,10]
$chars = range('a', 'z'); // ['a','b',...,'z']
?>
⚠️ 注意:'z' + 1 不是 'aa',需用 chr(ord('a')+n) 处理字母序列。
原地打乱数组:
<?php
$cards = range(1, 52);
shuffle($cards);
?>
⚠️ 注意:非密码学安全,敏感场景用 random_int() + Fisher-Yates 洗牌。
格式化输出数组结构:
<?php
echo '';
print_r($data);
echo '
';
?>
✅ 技巧:用 json_encode() 输出简洁结构:
<?php
echo json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
?>
对非数组/对象调用返回 1,易引发逻辑错误:
<?php
$data = null;
count($data); // 1!
?>
✅ 修复:加类型检查
<?php
$count = is_array($data) ? count($data) : 0;
?>