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

Предполагая, что у меня есть массив, размер которого N(где N > 0), есть ли более эффективный способ присоединения к массиву, который не требует O (N + 1) шагов?

В коде, по сути, то, что я сейчас делаю, это

function prependArray(value, oldArray) {
  var newArray = new Array(value);

  for(var i = 0; i < oldArray.length; ++i) {
    newArray.push(oldArray[i]);
  }

  return newArray;
}

Я не уверен насчет более эффективного с точки зрения big-O, но, конечно, использование 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(...)чтобы воспользоваться преимуществом unshift(...)метода Array :

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. Так:

var newArray = values.concat(oldArray);

Но это все равно будет 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]

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

У меня есть несколько свежих тестов различных методов приготовления. Для небольших массивов (<1000 элементов) лидером является цикл, связанный с методом push. Для огромных массивов метод 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]

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

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

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

[ newVal, ...array ]

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