php 数组方法

全面解析与实战应用 | www.xservx.com

一、php 数组方法概览与核心价值

在 PHP 开发中,数组是最核心、最常用的数据结构之一,几乎贯穿所有业务逻辑处理场景。从简单的数据传递到复杂的算法实现,php 数组方法提供了强大而灵活的操作能力。掌握这些方法,不仅提升开发效率,更能写出健壮、可维护的代码。

PHP 提供了超过 100 个数组处理函数,覆盖增删改查、排序、过滤、映射、聚合、遍历等全生命周期操作。本页将系统梳理高频实用方法,结合真实业务场景,提供可直接复用的代码范例与注意事项,助您从“会用”进阶到“善用”。

以电商系统为例:用户购物车数据通常以多维数组存储商品信息(id、name、price、qty);订单筛选需用 array_filter 过滤状态;统计总金额需 array_column + array_sum;排序则依赖 usort 或 uasort。脱离对 php 数组方法 的深刻理解,这些逻辑将变得冗长且易错。

本文不堆砌函数列表,而是以“问题驱动”方式组织内容,每个方法均配以深度解析与多场景示例,确保学完即可落地应用。

二、基础认知:php 数组本质与类型结构

PHP 的 数组 本质是一个有序映射(ordered map),即键值对的集合。它既是 索引数组(整数键,从 0 开始)又是 关联数组(字符串键),兼具数组与哈希表的特性,这是其强大却易被误用的根本原因。

• 索引 vs 关联:结构差异与性能影响

索引数组(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 ? '关联数组' : '索引数组'; // 输出:关联数组
?>
⚡ 注意:当数组键为字符串且非连续整数时,count() 返回元素总数,但 end() 操作可能因内部指针位置异常导致取值错误,建议改用 array_slice($arr, -1, 1, true) 安全获取末元素。

• 数组初始化与空值处理

推荐使用 [] 初始化空数组(PHP 5.4+),比 array() 更简洁:

<?php
$empty = []; // 等价于 array()
$init = ['php', 'js', 'go'];
?>

⚠️ 避免使用 NULL 初始化后追加:如 $arr = NULL; $arr[] = 'x'; 会触发 Notice。应始终初始化为 [] 或 [0] 等有效结构。

⚙️ 实战技巧:在循环中累积数据时,预分配数组容量可提升性能(PHP 7.4+):
<?php
$items = [];
$items[0] = 'A'; // 预占位避免动态扩容
$items[1] = 'B';
?>

三、添加元素:高效追加与前置插入

向数组末尾或开头添加元素是高频操作,不同方法适用场景不同,需结合性能与语义选择。

• array_push():批量追加

向数组末尾添加一个或多个元素,返回新长度:

<?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%。

• array_unshift():开头插入

向数组开头插入元素,后续键自动重排(索引数组):

<?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']
?>

• array_splice():灵活插入

功能最全面的插入工具,可同时处理删除、替换、插入:

<?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;
}
?>

四、删除元素:安全移除与边界处理

删除操作需特别注意键名重排、引用失效、空数组处理等问题。

• array_pop():安全弹出末元素

移除并返回数组最后一个元素,自动重排索引:

<?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()。

• array_shift():弹出首元素

移除并返回第一个元素,重排所有索引:

<?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) 操作
?>

• unset():精准删除指定键

直接移除指定键,不重排索引:

<?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); // 重置索引
?>

• array_splice():按位置删除

删除指定长度的元素,自动重排索引:

<?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;
?>

五、合并数组:深度解析与陷阱规避

合并是数据聚合的基础操作,但不同方法行为差异巨大,需精准选择。

• array_merge():数字键重排,字符串键覆盖

核心规则:数字键连续重排;字符串键后者覆盖前者:

<?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 未覆盖
?>

⚠️ 常见错误:误以为 + 会合并所有键,实际是“取并集,保留左侧值”。

• array_merge_recursive():递归合并,键冲突则嵌套

当值为数组时,递归合并而非覆盖:

<?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_chunk 深度应用

截取是分页、数据分片的核心,需兼顾效率与语义。

• array_slice():按位置截取

语法: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 省略,则截取到末尾。

• array_chunk():等分数组

将数组分割为指定大小的子数组:

<?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 可保留。

• 分页实现:结合 offset 与 limit

标准分页逻辑(页码从 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_splice() vs array_slice()

特性array_slice()array_splice()
是否修改原数组否(返回新数组)是(原数组被截断)
返回值截取部分被移除部分
键名处理可选保留始终重排索引
适用场景数据展示、分页原地修改、插入删除

八、排序:灵活应对各种排序需求

PHP 排序函数丰富,但易混淆,需按场景精准选择。

• sort() / rsort():索引数组排序

默认升序/降序,**修改原数组**,重排索引:

<?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']
?>

• asort() / arsort():按键值排序,保留键名

按值排序,保持键值对应关系:

<?php
$scores = ['Tom' => 95, 'Jerry' => 88];
asort($scores); // ['Jerry' => 88, 'Tom' => 95]
?>

• ksort() / krsort():按键名排序

按键名排序(字符串/数字):

<?php
$data = ['b' => 2, 'a' => 1];
ksort($data); // ['a' => 1, 'b' => 2]
?>

• usort() / uasort() / uksort():自定义比较

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']);
});
?>

• 性能对比:内置函数 vs 自定义

方法时间复杂度适用场景
sort / rsortO(n log n)简单数值/字符串排序
usortO(n log n) × 比较成本自定义逻辑(如多字段)
asort / ksortO(n log n)关联数组排序

✅ 实战建议:对 1000+ 元素数组,避免在循环内排序;优先用 SQL 排序(数据库索引优化)。

九、过滤与清理:数据清洗核心手段

过滤是数据预处理的关键步骤,确保后续逻辑健壮性。

• array_filter():默认移除 false 值

最简用法:清理空值

<?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;
});
?>

• array_map() + array_filter():组合清洗

先清理再过滤:移除前后空格 + 非空检查

<?php
$input = [' php ', ' ', 'js ', ''];
$clean = array_filter(array_map('trim', $input));
// 结果:[0 => 'php', 2 => 'js']
?>

• array_unique():去重(注意类型)

按字符串比较去重('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():提取单列(PHP 5.5+)

核心用法: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 '';
?>

• implode():数组转字符串

分隔符连接:

<?php
$langs = ['php', 'js', 'go'];
$str = implode(', ', $langs); // 'php, js, go'
?>

⚠️ 注意:对空数组返回空字符串;对单元素数组返回该元素。

• json_encode():转 JSON

结构化输出:

<?php
$data = ['status' => 'ok', 'items' => [1,2,3]];
echo json_encode($data, JSON_UNESCAPED_UNICODE);
// {"status":"ok","items":[1,2,3]}
?>

• array_combine():键值互换

用一个数组的值作为键,另一个作为值:

<?php
$keys = ['name', 'age'];
$values = ['Tom', 28];
$obj = array_combine($keys, $values);
// ['name' => 'Tom', 'age' => 28]
?>

⚠️ 必须保证两个数组长度相同,否则返回 FALSE。

• object_to_array():对象转数组

递归转换(含私有属性):

<?php
function objectToArray($obj) {
  return json_decode(json_encode($obj), true);
}
?>

✅ 优势:保留所有属性,包括 protected/private。

十一、映射处理:array_map 与匿名函数实战

映射是函数式编程的核心,将输入转换为输出。

• array_map():单数组转换

对每个元素应用回调:

<?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 岁)']
?>

✅ 优势:避免嵌套循环,代码简洁。

• 使用 use 传递外部变量

闭包捕获上下文:

<?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']
?>

• 与 array_filter() 组合:链式操作

先过滤再映射:

<?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_reduce():基础聚合

语法: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() vs array_reduce()

对纯数值求和,直接用 array_sum() 更简洁高效:

<?php
$sum = array_sum(array_column($sales, 'amount'));
?>

复杂逻辑(如带条件的求和)才需 array_reduce()。

十三、其他高频方法:细节决定成败

以下方法虽不常用,但关键时刻能省时省力。

• array_intersect() / array_diff():集合运算

求交集/差集(值比较):

<?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]
?>

⚠️ 注意:对关联数组,仅比较值,不比较键。

• array_key_first() / array_key_last()(PHP 7.3+)

安全获取首/末键名:

<?php
$data = ['a' => 1, 'b' => 2];
$firstKey = array_key_first($data); // 'a'
$lastKey = array_key_last($data); // 'b'
?>

✅ 替代方案:对旧版 PHP 用 reset($arr); key($arr)。

• range():生成序列

生成连续值数组:

<?php
$nums = range(1, 10); // [1,2,...,10]
$chars = range('a', 'z'); // ['a','b',...,'z']
?>

⚠️ 注意:'z' + 1 不是 'aa',需用 chr(ord('a')+n) 处理字母序列。

• shuffle():随机打乱

原地打乱数组:

<?php
$cards = range(1, 52);
shuffle($cards);
?>

⚠️ 注意:非密码学安全,敏感场景用 random_int() + Fisher-Yates 洗牌。

• print_r() / var_dump():调试输出

格式化输出数组结构:

<?php
echo '
';
print_r($data);
echo '
'; ?>

✅ 技巧:用 json_encode() 输出简洁结构:

<?php
echo json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
?>

• count():安全计数

对非数组/对象调用返回 1,易引发逻辑错误:

<?php
$data = null;
count($data); // 1!
?>

✅ 修复:加类型检查

<?php
$count = is_array($data) ? count($data) : 0;
?>