JS数组末尾添加元素的几种方法

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《JS数组末尾添加元素方法》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

最直接、最常用的方法是使用 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() 的原始性能，不如多想想你的应用架构和数据管理策略，这往往是决定性能和可维护性的更深层次因素。

理论要掌握，实操不能落！以上关于《JS数组末尾添加元素的几种方法》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！