小开

最佳答案

我不确定big-O是否更有效，但使用unshift方法肯定更简洁:

var a = [1, 2, 3, 4];
a.unshift(0);
// => [0, 1, 2, 3, 4]
console.log({a});

(编辑)

这个jsPerf基准表明，unshift在至少两个浏览器中都要快得多，不管大o性能是否不同。如果你真的不能改变原始数组，那么你会像下面的代码片段那样做，这似乎并不比你的解决方案快得多:

a.slice().unshift(0); // Use "slice" to avoid mutating "a".

[编辑2]

为了完整起见，可以使用以下函数代替OP的示例prependArray(...)来利用Array unshift(...)方法:

function prepend(value, array) {
var newArray = array.slice();
newArray.unshift(value);
return newArray;
}


var x = [1, 2, 3];
var y = prepend(0, x);
// x => [1, 2, 3];
// y => [0, 1, 2, 3];
console.log({ x, y });

小开

有特殊的方法:

a.unshift(value);

但是如果你想在数组中前置几个元素，使用这样的方法会更快:

var a = [1, 2, 3],
b = [4, 5];


function prependArray(a, b) {
var args = b;
args.unshift(0);
args.unshift(0);
Array.prototype.splice.apply(a, args);
}


prependArray(a, b);
console.log(a); // -> [4, 5, 1, 2, 3]

小开

如果将一个数组前置到另一个数组的前面，使用concat会更有效。所以:

const newArray = [1, 2, 3].concat([4, 5]);
newArray; // [1, 2, 3, 4, 5]

但这仍然是O(N)的oldArray大小。尽管如此，它还是比在oldArray上手动迭代更有效。此外，根据细节，它可能会对您有所帮助，因为如果您要预先添加许多值，最好先将它们放入一个数组中，然后在末尾连接oldArray，而不是单独地预先添加每个值。

在oldArray的大小上没有比O(N)更好的方法，因为数组存储在连续的内存中，第一个元素位于固定的位置。如果要在第一个元素之前插入，则需要移动所有其他元素。如果需要解决这个问题，就按照@GWW说的做，使用链表或不同的数据结构。

小开

f你需要保留旧数组，切片旧的，并不变新值

var oldA=[4,5,6];
newA=oldA.slice(0);
newA.unshift(1,2,3)


oldA+'\n'+newA


/*  returned value:
4,5,6
1,2,3,4,5,6
*/

小开

如果你想用数组a2来前置数组(a1)，你可以使用下面的方法:

var a1 = [1, 2];
var a2 = [3, 4];
Array.prototype.unshift.apply(a1, a2);
console.log(a1);
// => [3, 4, 1, 2]

小开

在ES6中，你现在可以使用传播算子来创建一个新数组，将你的新元素插入到原始元素之前。

// Prepend a single item.
const a = [1, 2, 3];
console.log([0, ...a]);

// Prepend an array.
const a = [2, 3];
const b = [0, 1];
console.log([...b, ...a]);

更新2018-08-17:性能

我想用这个回答来提供一种我认为更容易记住和简洁的替代语法。应该注意的是，根据一些基准测试(参见另一个答案)，此语法明显较慢。这可能无关紧要，除非您在循环中执行许多这样的操作。

小开

我有一些新的测试不同的预先方法。对于小型阵列(1000 elems)， leader用于循环与push方法耦合。对于巨大的数组，Unshift方法成为领导方法

但这种情况只适用于Chrome浏览器。在Firefox中，unshift有一个很棒的优化，并且在所有情况下都更快。

ES6在所有浏览器中的传播速度慢了100倍以上。

< a href = " https://jsbench。我/ cgjfc79bgx / 1”rel = " https://jsbench.me/cgjfc79bgx/1 noreferrer " > < / >

小开

in-place预置的例子:

var A = [7,8,9]
var B = [1,2,3]


A.unshift(...B)


console.log(A) // [1,2,3,7,8,9]

小开

调用unshift只返回新数组的长度。因此，为了在开头添加一个元素并返回一个新数组，我这样做:

let newVal = 'someValue';
let array = ['hello', 'world'];
[ newVal ].concat(array);

或者简单地用展开运算符:

[ newVal, ...array ]

这样，原始数组将保持不变。

小开

以一种不可改变的方式，这可能是最好的方式:

const x = 1
const list = [2, 3, 4]
const newList = [x].concat(list) // [1, 2, 3, 4]

小开

我只是在Chrome上运行了4个算法的基准测试:

就地:

// 1) splice method
{
let x = [8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44];
const y = [5, 6, 99, 5, 3, 4];
x.splice(0, 0, ...y); // 87'426 ops/s (but big variation of 35%)
// x is [5, 6, 99, 5, 3, 4, 8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44]
}


// 2) unshift method
{
let x = [8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44];
const y = [5, 6, 99, 5, 3, 4];
x.unshift(...y); // 69'471 ops/s
// x is [5, 6, 99, 5, 3, 4, 8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44]
}

复制:

// 3) spread operator
{
const x = [8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44];
const y = [5, 6, 99, 5, 3, 4];
const z = [...y, ...x]; // 17'118 ops/s
// z is [5, 6, 99, 5, 3, 4, 8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44]
}


// 4) concat method
{
const x = [8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44];
const y = [5, 6, 99, 5, 3, 4];
const z = y.concat(x); // 6'286 ops/s
// z is [5, 6, 99, 5, 3, 4, 8, 4, 1, 4, 124, 1, 14, 11, 9, 100, 6, 44]
}

总结:如果你想要在适当的位置预叠，unshift和splice都是很好的，如果你想要一个副本，那么展开运算符似乎是最好的选择…至少在Chrome上是这样。

将值前置到数组的最有效方法

更新2018-08-17:性能

就地:

复制: