js 如何用push向数组末尾添加新元素

最直接、最常用的方法是使用 push() 方法，它会直接修改原数组并返回新长度；2. 使用 push() 时需注意它是“变异方法”，会改变原数组，且返回值是新长度而非数组本身，易导致误用；3. 其他添加元素的方法包括 unshift()（开头添加，性能较差）、concat()（不修改原数组，返回新数组）、展开运算符（…，灵活且保持不可变性）、splice()（精确控制位置插入）；4. push() 性能通常良好，均摊时间复杂度为 o(1)，在绝大多数场景下不会成为性能瓶颈，远优于 unshift()；5. 在大型应用中更应关注数据可变性带来的副作用，现代开发倾向于使用不可变操作如展开运算符或 concat() 以提升可维护性和状态管理清晰度。

JavaScript里，要把新东西塞进一个数组的末尾，最直接、最常用的办法就是用

push()

方法。它会直接修改你原来的数组，然后告诉你数组现在有多长了。简单粗暴，效率也高。

push()

方法是

Array.prototype

上的一个成员，专门用来把一个或多个元素添加到数组的末尾。它的语法很简单：

array.push(element1, element2, ..., elementN)

。

举个例子，假设我们有个待办事项列表：

let todos = ['买菜', '写代码']; console.log('原始数组:', todos); // 原始数组: ['买菜', '写代码']  // 添加一个新事项 let newLength = todos.push('健身'); console.log('添加后数组:', todos); // 添加后数组: ['买菜', '写代码', '健身'] console.log('新长度:', newLength); // 新长度: 3  // 也可以一次性添加多个 todos.push('看书', '冥想'); console.log('再次添加后数组:', todos); // 再次添加后数组: ['买菜', '写代码', '健身', '看书', '冥想']

你会发现，

push()

直接在

todos

这个数组上操作，并没有返回一个新的数组。它返回的那个数字，就是添加完元素后数组的新长度。这个特性很重要，因为它意味着你正在“原地”修改数据。

使用

push()

时，有哪些容易踩的坑？

其实

push()

用起来直观，但有些小地方，如果没注意，可能会导致一些意想不到的结果。

最关键的一点，也是我刚才强调过的：

push()

是一个“变异”方法（mutating method）。它会直接修改原数组。这意味着如果你在函数里把一个数组传进去，然后对它调用

push()

，那么函数外部的那个数组也会跟着变。这在很多场景下是好事，比如你就是想更新一个全局状态。但如果你的预期是保持原数组不变，然后得到一个新数组，那

push()

就不是你想要的了。很多人会误以为它像

map()

或

filter()

那样返回一个新数组，但它不是。

let originalArray = [1, 2];  function addElement(arr) {     arr.push(3); // 这里直接修改了 originalArray     return arr; // 返回的其实就是被修改后的 originalArray }  let modifiedArray = addElement(originalArray); console.log('Original Array after function:', originalArray); // Original Array after function: [1, 2, 3] console.log('Modified Array:', modifiedArray); // Modified Array: [1, 2, 3] // 它们指向的是同一个数组对象！ console.log(originalArray === modifiedArray); // true

另外一个点，就是

push()

的返回值。它返回的是数组的新长度，而不是修改后的数组本身。有时候，初学者可能会写出

let newArr = arr.push(item);

这样的代码，然后期望

newArr

是修改后的数组。结果

newArr

得到的是一个数字，比如

3

或

4

，这显然不是我们想要的数组。如果你想链式调用或者想拿到修改后的数组，你得直接用原数组变量，或者在

push()

之后再引用它。

除了

push()

，还有哪些向数组添加元素的方法？它们各自的适用场景是什么？

JavaScript 提供了好几种往数组里加东西的办法，每种都有自己的脾气和用武之地。

• unshift()

  ：往数组开头加 如果

  push()

  是往队尾加人，那

  unshift()

  就是往队头加人。它的用法和

  push()

  类似，也是可以加一个或多个元素，并且同样会修改原数组，返回新长度。

  let queue = ['B', 'C']; queue.unshift('A'); console.log(queue); // ['A', 'B', 'C']

  但要注意，

  unshift()

  的性能通常不如

  push()

  。因为往数组开头加元素，意味着数组里所有现有元素的位置都得往后挪，如果数组很大，这开销可不小。所以，除非你真的需要把元素加到开头，否则

  push()

  往往是更优选择。

• concat()

  ：合并数组，生成新数组 这是

  push()

  的一个好搭档，尤其是在你需要保持原数组不变（即“不可变性”）的时候。

  concat()

  不会修改原数组，而是创建一个新数组，把调用它的数组和传入的数组或元素合并起来。

  let arr1 = [1, 2]; let arr2 = [3, 4]; let newCombinedArr = arr1.concat(arr2, 5); // 可以合并数组，也可以合并单个元素 console.log(arr1); // [1, 2] (arr1 没变) console.log(newCombinedArr); // [1, 2, 3, 4, 5]

  当你需要基于现有数据生成新数据，而不是修改旧数据时，

  concat()

  是个不错的选择。

• 展开运算符（Spread Operator

  ...

  ）：灵活且强大 ES6 引入的展开运算符，在处理数组时简直是神器。它能让你以非常简洁的方式创建新数组，同时添加新元素。

  let originalItems = ['apple', 'banana']; let newItems = [...originalItems, 'orange', 'grape']; // 在末尾添加 console.log(newItems); // ['apple', 'banana', 'orange', 'grape']  let evenNewerItems = ['kiwi', ...originalItems, 'pear']; // 也可以在开头或中间添加 console.log(evenNewerItems); // ['kiwi', 'apple', 'banana', 'pear']

  展开运算符的优势在于它的灵活性和“不可变”特性——它总是创建一个新数组。这在React/Vue等前端框架的状态管理中非常流行，因为它能帮助你避免意外的副作用，让数据流向更清晰。

• splice()

  ：精确控制增删改

  splice()

  是一个多面手，它既能删除、替换，也能插入元素。它同样会修改原数组。

  let list = ['a', 'b', 'd']; // 在索引2的位置（即'd'前面）插入'c'，不删除任何元素 list.splice(2, 0, 'c'); console.log(list); // ['a', 'b', 'c', 'd']

  splice()

  功能强大，但语法相对复杂一些，通常用于需要精确控制插入位置的场景，而不仅仅是简单的末尾添加。

所以你看，虽然

push()

是最直接的末尾添加方式，但根据你是否需要修改原数组、添加位置、以及对性能的考量，总有其他方法可以替代或补充。

在大型应用中，频繁使用

push()

会带来性能问题吗？

这是一个很好的问题，尤其是在处理大量数据或构建高性能应用时，我们总会下意识地考虑性能。对于

push()

方法来说，答案通常是：不会，或者说，它的性能表现通常非常好，很少成为瓶颈。

这是因为 JavaScript 引擎在实现数组时，通常会预留一些额外的空间。当你用

push()

添加元素时，如果还有预留空间，它就直接把新元素放进去，这个操作是 O(1) 的时间复杂度，也就是常数时间，非常快。只有当预留空间用完，数组需要扩容时，引擎才会分配一块更大的内存，然后把现有元素拷贝过去，再添加新元素。这个扩容和拷贝操作的开销是 O(n)（n 是数组当前长度），听起来好像很慢，但由于扩容策略通常是指数级的（比如每次扩容到原来的1.5倍或2倍），所以平均下来，

push()

的均摊时间复杂度依然是 O(1)。这意味着，即使你连续

push

很多次，每次操作的平均成本依然很低。

相比之下，

unshift()

（往数组开头添加元素）的性能开销就大多了。因为它每次添加都意味着所有现有元素都需要向后移动一个位置，这直接导致了 O(n) 的时间复杂度。所以，如果你在循环里频繁地往数组开头添加元素，那性能问题就非常显著了。

当然，凡事无绝对。如果你的“大型应用”指的是在极其严苛的实时渲染或数据处理场景下，并且数组的每次扩容都恰好触发了昂贵的内存重新分配和拷贝，那理论上是可能遇到微小的性能抖动的。但对于绝大多数日常的 Web 应用开发来说，

push()

的性能是完全可以信赖的。

更值得思考的，反而不是

push()

本身的性能，而是它带来的“可变性”。在现代前端框架和函数式编程范式中，我们越来越推崇“不可变数据结构”。这意味着一旦数据创建，就不再修改它，而是通过生成新数据来反映变化。这样做的好处是数据流清晰，更容易追踪问题，也方便进行性能优化（比如通过引用比较来避免不必要的组件渲染）。在这种范式下，我们可能会更倾向于使用展开运算符

[...]

或

concat()

来添加元素，因为它们会返回一个新数组，而不是修改原数组。

所以，与其担心

push()

的原始性能，不如多想想你的应用架构和数据管理策略，这往往是决定性能和可维护性的更深层次因素。