Самый эффективный способ добавить значение в массив

Я не уверен, что это более эффективно с точки зрения большого О, но, конечно, использование метода unshift более кратко:

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

[Изменить]

Этот тест jsPerf показывает, что unshift работает значительно быстрее по крайней мере в нескольких браузерах, независимо от возможно, другая производительность big-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);
y; // => [0, 1, 2, 3];
x; // => [1, 2, 3];

В 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: Производительность

Я хотел, чтобы этот ответ представил альтернативный синтаксис, который я считаю более запоминающимся и кратким. Следует отметить, что согласно некоторым тестам (см. этот другой ответ) этот синтаксис значительно медленнее. Это, вероятно, не имеет значения, если вы не выполняете многие из этих операций в цикле.

Если вы добавляете массив перед другим массивом, более эффективно просто использовать concat. Так:

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

Но это все равно будет O (N) размером oldArray. Тем не менее, это более эффективно, чем итерация по oldArray вручную. Кроме того, в зависимости от деталей, это может помочь вам, потому что, если вы собираетесь добавить много значений, лучше сначала поместить их в массив, а затем объединить oldArray в конце, а не добавлять каждое из них по отдельности.

Нет способа добиться большего, чем O (N), в размере oldArray, потому что массивы хранятся в непрерывной памяти с первым элементом в фиксированной позиции. Если вы хотите вставить перед первым элементом, вам нужно переместить все остальные элементы. Если вам нужен способ обойти это, сделайте то, что сказал @GWW, и используйте связанный список или другую структуру данных.

Если вы хотите добавить массив (a1 к массиву a2), вы можете использовать следующее:

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

Если вам нужно сохранить старый массив, нарежьте старый и переместите новое значение (я) в начало среза.

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
*/

Вызов unshift возвращает только длину нового массива. Итак, чтобы добавить элемент в начало и вернуть новый массив, я сделал следующее:

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

или просто с оператором распространения:

[ newVal, ...array ]

Таким образом, исходный массив остается нетронутым.

У меня есть свежие тесты различных методов препендинга. Для небольших массивов (‹1000 элементов) выноска предназначена для цикла с методом проталкивания. Для огромных массивов лидером становится метод Unshift.

Но такая ситуация актуальна только для браузера Chrome. В Firefox unshift имеет отличную оптимизацию и работает быстрее во всех случаях.

Распространение ES6 во всех браузерах в 100+ раз медленнее.

https://jsbench.me/cgjfc79bgx/1

Есть специальный метод:

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]

Пример добавления на место:

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

A.unshift(...B)

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