数组大概是最被低估的数据结构。我在日常开发里几乎天天跟它打交道，从 C++ 的底层指针到 JavaScript 的前端列表，再到 numpy 的矩阵切片，说到底都是在折腾同一件事：怎么把一批数据存好、取对、算快。这篇内容就把数组的常用操作从创建初始化、增删改查，到查找筛选、排序去重，再到二维矩阵和跨语言使用场景，完整捋一遍。无论是刚入门的新手，还是经常在多种语言间切换的老手，都可以把它当作一份随查随用的操作手册。

1. 创建与初始化：基础中的基础

数组操作的第一步永远是怎么把它造出来。这一步看着简单，实际上不同语言的初始化规则差别非常大，很多隐蔽的 Bug 都是从这里开始的。

1.1 不同语言的数组初始化规则

C 语言里，数组一旦声明，长度就固定了，而且未初始化元素的取值是未知的。比如int arr[5];这行代码，如果是在函数内部声明的，那 arr 里存的完全可能是上次其他代码留下的残留数据，直接读取就是未定义行为。所以 C 里初始化数组最安全的做法是int arr[5] = {0};，这样能确保所有元素归零。如果只想给前几个元素赋值，后面会自动补零：int arr[5] = {1, 2};的结果就是 1, 2, 0, 0, 0。

C++ 里有了std::array和std::vector之后，初始化就优雅多了。std::array<int, 5> a{};可以把全部元素初始化为零值，std::vector<int> v(5, -1);可以直接创建 5 个值为 -1 的元素。这里我特别推荐用大括号初始化，因为它能阻止窄化转换，比如int x{3.14}会直接编译报错，而int x = 3.14只是悄悄截断，这类问题在数组里更容易被忽略。

Java 的数组初始化和 C 类似，int[] arr = new int[5];会把默认值设为 0，对象数组则是 null。但真正好用的是语法糖写法：int[] arr = {1, 2, 3};或者int[] arr = new int[]{1, 2, 3};。

Python 没有原生数组的概念，最常用的是 list：arr = [0] * 5会得到 5 个零组成的列表，但要注意这个写法对不可变元素安全，如果元素是字典、列表这类可变对象，用[[]] * 3得到的三个子列表其实指向同一个对象，修改任何一个都会影响全部。这个坑我踩过不止一次。

JavaScript 同样有类似陷阱。new Array(5).fill(0)是安全的，但Array(5)只是创建了一个长度为 5 的空数组，元素全是 empty，直接 map 是不会执行的。更隐蔽的是Array(3).fill([])，三个元素指向同一个空数组，和 Python 那个坑如出一辙。想创建二维数组的话，正确姿势是用Array.from({length: 3}, () => new Array(4).fill(0))。

1.2 数组长度计算与字符串数组初始化

数组长度这个话题看着简单，但 C 语言里的sizeof陷阱能把老手都坑进去。在数组声明的同一作用域里，sizeof(arr) / sizeof(arr[0])可以得到元素个数，但一旦数组作为函数参数传入，它就会退化为指针，这时候sizeof(arr)得到的是指针大小而不是数组大小。所以我在 C 项目里普遍约定，如果函数需要接收数组，必须同时传入长度参数，不要指望在函数内部用它自己计算出来。

C++ 里可以用模板函数来安全获取数组长度：

template <typename T, std::size_t N> constexpr std::size_t array_size(T (&)[N]) { return N; }

这个写法保留了对数组类型的完整引用，不会退化成指针，在 C++11 以后推荐直接使用std::size()。

字符串数组的初始化值得单独说说。C++ 里const char* arr[] = {"apple", "banana", "cherry"};声明的是一个指针数组，每个元素指向一个字符串字面量。如果希望字符串本身可修改，就得用char arr[][16]，但第二个维度必须足够大，否则编译器会报错或截断。C++17 以后推荐直接使用std::array<std::string, 3>，安全省心，还能用std::string_view避免拷贝。

2. 数据操纵：遍历、增删与类型转换

初始化完成后，最频繁的操作就是遍历、添加、删除和修改元素。不同语言在数组的增删能力上差异巨大，了解各自的设计逻辑能帮你少走很多弯路。

2.1 遍历方式的演进与选择

C 里只能靠下标遍历，这是最原始的方式，性能最好。C++ 引入了范围 for 循环，for (const auto& x : arr)，不但简洁，而且避免了下标计算错误的风险。Java 从 8 开始有了 Stream，可以把“遍历 + 操作”组合成一条流式管线：

Arrays.stream(arr).filter(x -> x > 0).map(x -> x * 2).toArray();

Python 里最 Pythonic 的遍历方式有几种，纯遍历用for x in arr，需要索引时用for i, x in enumerate(arr)，想同时遍历两个列表就用zip(a, b)。JavaScript 则提供了forEach、map、filter、reduce这一整套函数式方法，也是现在处理数组的主流方式。

选择遍历方式时有个重要的考量：你在遍历过程中还需要索引吗？需要修改原数组吗？需要提前中断吗？如果答案都是否，那直接用语言提供的最简洁写法即可；如果需要索引且支持提前退出，传统 for 循环仍然是最合适的。

2.2 增删元素与可变数组

固定长度数组是没有真正的“增删”概念的，只能通过新建数组来间接实现。这也是为什么现代语言普遍提供了动态数组类型：C++ 的std::vector、Java 的ArrayList、Python 的 list、JavaScript 本身就是动态的。

C++ 的 vector 扩容是一个很有意思的话题。push_back在容量不够时会触发扩容，通常是按 1.5 到 2 倍增长，因为重新分配内存并搬运元素的开销很大，指数扩容能保证整体均摊时间复杂度是 O(1)。如果提前知道大概需要多少个元素，可以用reserve()预分配容量，这是在性能调优里很容易见效的一招，我处理百万级数据时经常这么做。

JavaScript 里删除元素的方法容易混淆。pop()删末尾、shift()删头部、splice(index, count)删除指定位置的元素。特别想提醒的是，splice是原地修改，而slice是返回新数组，两个拼写接近但行为完全不同。想快速在头部插入元素应该用unshift，但它的时间复杂度是 O(n)，如果频繁头部插入，考虑改为push后最后reverse。

Python 的del arr[2]和arr.remove(value)也常被弄混，前者按索引删除，后者按值查找删除。按值删除一次次调用是 O(n) 的，如果你需要批量删除符合某个条件的多个元素，直接写列表推导式更高效：arr = [x for x in arr if x != target]。

2.3 数组类型转换与切片操作

类型转换是数组操作里容易被忽略但实际非常高频的环节。C 语言里数组变量类型转换最典型的是指针转换，比如int* p = (int*)arr;然后以字节为单位访问内存，这种操作往往伴随字节序和内存对齐问题，能不用尽量不用。

Java 的数组转换主要集中在基本类型数组和包装类型数组之间：Arrays.stream(intArr).boxed().toArray()得到 Integer 对象数组，反向用mapToInt(Integer::intValue).toArray()。一组字符串转基本类型数组就是Arrays.stream(strArr).mapToInt(Integer::parseInt).toArray()。

Python 的数组切片是它最强大的特性之一。arr[1:4]会取出索引 1 到 3 的元素，arr[::-1]反向切片，arr[::2]取偶数位。这里要注意，切片返回的是新列表，但如果是 numpy 数组，切片默认是视图（view），修改切片会影响到原数组，只有显式调用.copy()才会生成新数组。这个差异在数据处理流水线里非常容易引发诡异 Bug，我见过太多人因为没搞清楚这一点，导致上游数据被无意识地污染。

字符串转字符数组也是日常高频操作。C++ 里std::string::c_str()返回 const char* 指针，但用完之后立即失效的风险很高，别把它保存下来。更稳妥的是直接拷贝到std::vector<char>或std::array<char, N>里。C 里如果拿到的确实是 CString（MFC 环境），可以自己写一个宽字符转窄字符的封装函数，或者直接使用CStringA做窄字符转换。

3. 查找、筛选与去重：数据清洗的三大经典操作

如果数组操作有个“黄金三角”，那一定是查找、筛选和去重。这几种操作在几乎所有数据处理任务里都会出现，也是面试题里出镜率最高的组合。

3.1 查找的几种境界

最直接的查找是线性扫描，时间复杂度 O(n)，适合小规模数据和无序数组。代码写起来就是循环比较，没什么技术含量，但要注意的是如果内层循环里还嵌套了字符串比较，实际开销可能会远大于预期，这时候先把数组排序再用二分查找会更划算。

二分查找要求数组已经有序，它的前提条件（有序性）本身就是一种重要约束。C++ 里可以用std::binary_search判断存在，std::lower_bound和std::upper_bound找到上下边界。Python 的bisect模块提供了同样的能力。JavaScript 没有原生二分查找，一般借助Array.prototype.find做线性查找，或者自己实现一个。

在实际开发中，我更推荐用哈希表做值到索引的映射。一次遍历把数组的值和位置存进 Map，后续查找就是 O(1) 的事。这就是经典的两数之和题目的标准解法：

function twoSum(nums, target) { const map = new Map(); for (let i = 0; i < nums.length; i++) { const complement = target - nums[i]; if (map.has(complement)) return [map.get(complement), i]; map.set(nums[i], i); } return []; }

这套思路在数组操作里非常通用：想快速判断某个值出现过没有，优先考虑 Set 而不是数组的 includes，因为 Set 的查找是 O(1) 且不受数组长度影响。

3.2 数组去重的四种方案对比

数组去重是数据清洗里的高频需求，不同场景有不同的最优解。我把常用方案整理成了一个对照表：

Set 去重是我最常用的方案，简洁而且性能好。但注意它只做浅比较，如果数组元素是对象，两个内容完全相同但引用不同的对象并不会被去重。

3.3 对象数组去重与按字段提取

实际开发中更多遇到的是对象数组的去重，按照某个唯一字段去重。比如从接口拿到一批用户列表，同一个 id 可能出现多次，需要保留第一次出现的记录。这时候 Set 直接失效，需要用 Map 来按字段去重：

const unique = [...new Map(arr.map(item => [item.id, item])).values()];

这行代码的核心逻辑是先按 id 构建键值对，因为 Map 的 key 不允许重复，后面出现的相同 id 会自动覆盖前面的，再取 values 就得到了按 id 去重后的数组。如果希望保留第一次出现而不是最后一次，反着遍历即可。

从对象数组里提取一部分字段也是一个常见需求。ES6 的解构赋值可以让代码非常干净。比如你有一个用户数组，只需要保留 name 和 email 两个字段：

const simplified = users.map(({ name, email }) => ({ name, email }));

再叠加一个筛选条件，把 status 为 active 的用户取出来，就可以组合成users.filter(u => u.status === 'active').map(...)。这种 filter + map 的组合链在数据处理里几乎每天都在用。

PHP 处理接口返回的数组对象时有一些自己的坑。array_column($users, 'name')可以直接提取某一列的值组成新数组，非常好用。但array_unique对关联数组的去重默认按值比较，不会递归比较对象内部的复杂结构，而且 PHP 的数组本身就是有序字典，在处理 JSON 接口返回的数据时要注意json_decode($json, true)和json_decode($json)的区别，前者得到的是数组，后者得到的是对象。

3.4 数组分割与包含过滤

“数组分割并显示包含某一字符”这个需求也很典型。比如你有一个文件名列表，想找出所有包含.log的项，或者想把一个长字符串按分隔符切分成数组再过滤。

Python 里一步到位：[x for x in text.split(',') if '.log' in x]。JavaScript 里配合filter+includes：text.split(',').filter(x => x.includes('log'))。这里推荐用includes而不是indexOf !== -1，语义更清晰，而且支持第二参数指定搜索起始位置。

C 语言做字符串分割和过滤就比较原始了。strtok()会修改原字符串，而且不可重入，多线程场景要用strtok_r()。如果只是判断子串是否存在，strstr()就够了。

4. 排序：一个比看起来复杂得多的主题

排序是数组操作里最“表面单纯”实际坑最多的话题。我见过不少代码在排序环节出现诡异问题，最后都追溯到对比较函数理解不透彻上。

4.1 JavaScript 数组排序的几种方法

JavaScript 的sort()有历史性的坑：默认行为是把元素转成字符串再按字典序排序。所以[10, 9, 2].sort()的结果是[10, 2, 9]，因为字符串'10'在'2'前面。这直接导致很多人发现 sort 不生效，其实是没传比较函数。

正确写法是明确传入比较函数：

// 升序 arr.sort((a, b) => a - b); // 降序 arr.sort((a, b) => b - a);

比较函数必须遵守三条规则：返回负数表示 a 排在 b 前，返回正数表示 a 排在 b 后，返回 0 表示相等顺序不变。理解了这三条规则，对象数组按某个字段排序就很简单了：

users.sort((a, b) => a.age - b.age);

中文排序是个容易忽略的细节。默认的字符串比较对中文是按 Unicode 码点排的，结果不是拼音顺序。想按拼音排的话，用localeCompare加参数：arr.sort((a, b) => a.localeCompare(b, 'zh-Hans-CN-u-co-pinyin'))。

4.2 Python、C++ 与 Java 的排序要点

Python 的排序核心是sorted(arr)返回新列表，arr.sort()原地排序。两者都可以传key参数，key是一个函数，会在每个元素上调用一次得到排序依据。比如按字符串长度排序：sorted(arr, key=len)。Python 的排序是稳定的，这意味着相同 key 的元素保持原来的相对顺序，这是很多场景下特别有用的性质。

C++ 的排序用<algorithm>头文件里的std::sort(arr.begin(), arr.end())，默认升序。自定义排序需要传比较函数：

std::sort(arr.begin(), arr.end(), [](int a, int b) { return a > b; });

C++ 的std::sort不保证稳定性，需要稳定排序用std::stable_sort。这算是性能和稳定性的取舍，大多数场景用std::sort就够了。在 C++20 里，std::ranges::sort可以直接对数组名排序，不需要写迭代器了。

Java 里基本类型数组用Arrays.sort(arr)，是双轴快速排序；对象数组用Arrays.sort(arr)走归并排序（保证稳定）。List 用list.sort(Comparator)或者Collections.sort(list)。按对象的某个属性排序可以写：

users.sort(Comparator.comparingInt(User::getAge));

4.3 二维数组按列排序与算法题中的排序实践

二维数组按某列排序在算法题和真实项目里都很常见。比如你有一个[[name, score], ...]数组，想按分数降序排。JavaScript 里arr.sort((a, b) => b[1] - a[1])就行。Python 里用sorted(arr, key=lambda x: x[1], reverse=True)。C++ 的std::sort配合 lambda 写入行指针或者 vector 引用就可以。如果后续还要按第 0 列排序，注意排序稳定性问题，如果要先按分数再按姓名，更稳妥的做法是一次比较两个字段：

sorted(arr, key=lambda x: (-x[1], x[0]))

numpy 里排序也有自己的门道。np.sort(a)返回排序后的新数组，a.sort()原地排序，np.argsort(a)返回的是排序后的索引，这个索引可以用于其他数组的重排。多列排序用np.lexsort((last, first))，注意参数的顺序是反直觉的，最后一个参数是第一优先级。

算法题里常见的三个数组最大乘积问题，思路就是排序后比较最值。最大值要么来自三个最大正数乘积，要么来自两个最小负数乘以一个最大正数。排序法写起来很简单：

def max_product(nums): nums.sort() return max(nums[-1] * nums[-2] * nums[-3], nums[0] * nums[1] * nums[-1])

4.4 Excel、VBA 与数据库场景中的排序

Excel 里的动态数组函数极大简化了排序操作。SORT(array, [sort_index], [sort_order])可以直接生成排序后的数组结果，不需要 Ctrl+Shift+Enter，Excel 365 和 2021 都原生支持。排序后想提取前两列匹配的数据成数组，可以用INDEX和MATCH组合实现。

VBA 里对数组排序一直比较尴尬，内置没有直接对数组排序的方法，通常是把数组写入工作表区域，用Range.Sort方法排完再读回数组。如果数据量不大，我更推荐直接用ArrayList对象来排序。

SQL 里也可以用GROUP_CONCAT、JSON_ARRAYAGG直接生成聚合后的数组，这一点放在后面结合 JSON 场景细说。

5. 二维数组与矩阵操作：从基础到 numpy

二维数组本质上是一维数组的数组，但在真实的数据处理中它承载着矩阵运算的重任。这里的操作方式跟一维有很大区别，很多坑也藏在细节里。

5.1 numpy 常用操作速览

numpy 几乎是我处理数值数据的第一选择。创建数组的方式很多，日常最常用这几个：

import numpy as np # 从列表创建 a = np.array([[1, 2, 3], [4, 5, 6]]) # 全零、全一矩阵 zeros = np.zeros((3, 4)) ones = np.ones((2, 3)) # 等差数列 arange = np.arange(0, 10, 2) # 初始化二维数组 grid = np.zeros((3, 3), dtype=np.int32) # 用 reshape 把一维变成二维 matrix = np.arange(12).reshape(3, 4)

numpy 的强大之处在于向量化操作。你可以对整个数组直接做加减乘除和广播运算，不需要写循环。比如a * 2、a + b（形状相同时逐元素相加）、a.sum(axis=0)按列求和、a.max(axis=1)按行求最大值。

5.2 取出多列、切片与布尔索引

numpy 取多列的核心是切片和索引的组合。a[:, 1:3]取出所有行、第 1 到第 2 列，这是矩阵操作里最常见的需求。如果想取出不连续的列，用列表索引：a[:, [0, 2]]。

布尔索引是 numpy 最强大的特性之一。比如你想拿到所有大于 10 的元素，或者想筛选出满足条件的行，直接写条件表达式就完成了：

mask = matrix[:, 2] > 10 # 第三列值大于10的行掩码 selected = matrix[mask]

这种写法避免了循环，代码短，可读性好，而且底层是 C 实现，速度远快于 Python 循环。

MATLAB 里取出多列的逻辑和 numpy 几乎一致：A(:, 2:4)取所有行的第 2 到第 4 列，A(:, [1 3])取第 1 和 3 列。MATLAB 是 1-based 索引，numpy 是 0-based 索引，这个差异在两种工具之间切换时是最容易出错的。

需要注意的一点是 numpy 切片默认是视图，如果你修改了切片结果，原数组也会被改动。想避免这种情况要用.copy()。比如：

sub = matrix[:, 1:3].copy()

5.3 一列数中确定哪些值相加等于固定值

这是数组算法里一个很经典的问题，也是很多数据处理任务的底层原型。给定一个数组和一个目标和，找出数组中的哪些数据之和等于这个固定值。

最简单的是两数之和，用哈希表可以一次遍历搞定。三数之和需要先排序再用双指针。更一般化的“子集和问题”则是回溯或者动态规划，核心状态是dp[i]表示能否凑出和为 i，转移方程是dp[j] |= dp[j - arr[i]]。

def subset_sum(nums, target): dp = [False] * (target + 1) dp[0] = True for num in nums: for j in range(target, num - 1, -1): if dp[j - num]: dp[j] = True return dp[target]

这个 DP 的思路在分组求和、凑零钱等问题里都能复用。核心是要注意内层循环必须从大到小遍历，否则同一个元素会被重复使用。

5.4 树状数组的模板与应用

树状数组（Fenwick Tree）是处理数组前缀和和单点更新的经典数据结构，能在 O(log n) 时间内完成前缀和查询和单点修改。模板很固定，没有太多变化，背下来即可：

class BIT { public: vector<int> tree; int n; BIT(int size) : n(size), tree(size + 1, 0) {} int lowbit(int x) { return x & -x; } void add(int idx, int delta) { while (idx <= n) { tree[idx] += delta; idx += lowbit(idx); } } int sum(int idx) { int res = 0; while (idx > 0) { res += tree[idx]; idx -= lowbit(idx); } return res; } };

比如维护长度为 16 的序列，查询前缀和 sum(11) 会从树状数组的第 11 个位置开始，依次加 tree[11]、tree[10]、tree[8]，对应二进制 1011 逐步消除最低位的 1，最终得到前 11 个数的和。单点修改 add(3, x) 则是从位置 3 开始，依次改 tree[3]、tree[4]、tree[8]、tree[16]，对应二进制 0011 逐步加上最低位的 1。

树状数组的硬性要求是下标从 1 开始，如果原始数据从 0 开始，需要整体偏移一位。

6. 指针数组、引用传递与多语言接口

数组操作在底层语言里会涉及指针和引用，这是很多 C/C++ 新手最头疼的部分，但在真实系统中的作用非常重要。同时，现代开发里数组经常要跨语言传递，接口层的数据结构处理也是一门手艺。

6.1 C 语言指针数组存放字符串

C 语言中，指针数组最常见的用途就是存放字符串。const char *fruits[] = {"apple", "banana", "cherry"};这个数组的每个元素都是一个const char*指针，分别指向常量区的字符串。这种方式节省空间，但是不能修改字符串内容。

如果是需要动态修改的字符串数组，可以用char fruits[][16]，每个字符串都存储在数组自己的内存空间里。用 16 作为第二个维度意味着所有字符串最多 15 个字符，剩余空间浪费在较短字符串上。所以具体选择哪种方式，本质是“节省内存但只读”和“可修改但占用固定大小”之间的权衡。

C 语言里数组名本身会退化为指针。arr和&arr[0]在作为函数参数传参时表现一致。真正容易混淆的是int arr[3][4]这种二维数组，它在参数列表里会被解释为int (*arr)[4]，是一个指向长度为 4 的 int 数组的指针。如果你试图写成int**，编译器会报不兼容的警告或错误，很多刚从一维数组过渡到二维数组的人会在这里卡壳。

6.2 Qt 窗体间引用数组的接收与赋值

Qt 开发中，窗体间传递数组是一个比较常见的需求。如果看到const (&double [10])这样的函数参数声明，其实就是“指向包含 10 个 double 元素的数组的常量引用”。这样的写法避免了数组退化为指针，同时保证了数组长度是类型的一部分，调用时传入长度不对的数组直接编译报错。

void setData(const double (&data)[10]) { m_data = std::vector<double>(data, data + 10); }

不过在 Qt 项目里，我更推荐直接用std::vector<double>或者QVector<double>来做窗体间的数据传递，因为它们可以动态调整大小，语义更清晰，也不用担心数组引用语法的退化问题。如果你在用 Qt6，QList其实和QVector是同一个类型了，直接用就行。

6.3 跨语言接口中的数组处理

后端接口返回 JSON 数组，前端接收后要转成对象数组，这已经是前后端联调的日常了。JavaScript 里JSON.parse(jsonString)可以把 JSON 字符串转成数组，对于复杂嵌套，用解构和 map 提取字段即可。PHP 里接口返回数组对象，前端读取时通常会用json_decode($json, true)拿到关联数组，再用array_column提取需要的字段。

Java 后端处理 JSON 数组一般借助 Jackson 或 Gson，把 JSON 数组反序列化成List<SomeDTO>，配合 Stream 做后续操作。整体思路和其他语言完全一致：先解析成通用数组结构，再按需求筛选、映射、分组。

6.4 C++ 中的动态数组与扩容策略

C++ 的std::vector是最常用的动态数组，它解决了 C 语言固定长度数组的痛点。扩容策略我前面提到过，是倍增式的。push_back是均摊 O(1)，但如果频繁在中间位置插入或删除元素，vector 的开销是 O(n)，因为需要移动后续所有元素。这种场景应该优先考虑std::deque或std::list。

有些旧项目里还在用 C 风格的动态数组：int* arr = (int*)malloc(sizeof(int) * n);。这种做法需要手动管理内存，容易出现泄漏和悬垂指针。C++ 里推荐直接使用std::vector，即使从 C 接口接受数据，也可以先拿到原始指针然后赋给 vector 管理，避免手动释放。

7. 常见问题与排查技巧实录

数组操作写多了，总会遇到一些反复出现的坑。我把这些年实际调试中遇到的问题整理成一份速查表，每一条背后都是真实踩过的坑。

7.1 高频问题速查表

7.2 数组越界与隐藏的性能陷阱

数组越界是最危险的一类问题，C/C++ 里越界访问不会立即报错，而是悄悄覆盖了相邻内存，可能在很远的地方才暴露出来。排查手段通常是开启 AddressSanitizer 或者 Valgrind。日常写代码时养成一个习惯：凡是访问数组下标，先确认索引边界，循环里多用<而不是<=，固定长度数组用常量而不是魔法数字。

性能方面，有一个容易忽略的点是数组拷贝的隐性开销。JavaScript 的arr.slice()、Python 的arr[:]、Java 的System.arraycopy都是 O(n) 操作，在高频循环里反复拷贝大数组会让程序变慢好几个数量级。可以考虑直接原地操作，或者用不可变数据配合函数式手段实现同一效果。

对于 VBA 数组对比，常见的需求是找出两个数组的差异。最直接的双重循环在数据量大时会慢得离谱，改用字典（Dictionary）做一次遍历匹配能显著提升速度。Excel 动态数组配合UNIQUE、FILTER、SORT这些函数，可以把很多原本需要写 VBA 的操作交给公式完成，这也是近几年 Excel 数据处理最值得掌握的新能力。

7.3 从问题中总结出的几条避坑心法

第一，拿到一个数组操作需求，先问一句：我要修改原数组，还是生成新数组？这个问题的答案决定了用哪个 API，能避免一半以上的误用。JavaScript 里sort、splice会修改原数组，slice、map、filter不会；Python 里list.sort()原地修改，sorted()返回新列表；C++ 里std::sort原地排序，想要副本得先拷贝。

第二，当感觉代码逻辑完全正确但结果不对时，先怀疑引用和视图问题。Python 列表的乘法、numpy 的视图、Java 数组的引用传参都是这类问题的重灾区。

第三，不要在一个数据结构里死磕。数组操作卡住了，想想是不是该换一个数据结构。需要在中间频繁插入删除，换链表；需要快速查找，换哈希表；需要有序查找，换平衡树。能用库就用库，自己手写集合类的时候，先默认是在浪费时间。

第四，算法题里练过的基本功完全可以迁移到日常开发。比如确定几个数之和等于固定值，实际就是一个简单的 DP；树状数组就是动态维护区间和；二维数组的遍历就是两个循环嵌套。数组的很多高级用法本质上就是这几种基础模式的组合，没有多少玄学在里面。

最后再分享一个小技巧。数组操作在编码之外的另一个关键动作是打印调试。调试数组问题时，别用那种只输出一行“结果不对”的日志，而是直接把数组完整打印出来，检查中间状态。用 Python 的pprint、JavaScript 的console.table、C++ 里手动循环打印，都能大大减少排查时间。有时候问题一眼就看出来了，比盲猜快得多。