A maneira mais eficiente de acrescentar um valor a uma matriz

Supondo que eu tenha uma matriz que tenha um tamanho de N(onde N > 0), existe uma maneira mais eficiente de preceder a matriz que não exigiria etapas O (N + 1)?

No código, essencialmente, o que estou fazendo atualmente é

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

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

  return newArray;
}

Não tenho certeza de que seja mais eficiente em termos de big-O, mas certamente o uso do unshiftmétodo é mais conciso:

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

[Editar]

Esse benchmark jsPerf mostra que unshifté decentemente mais rápido em pelo menos alguns navegadores, independentemente do desempenho de grande O possivelmente diferente, se você estiver certo em modificar a matriz no local. Se você realmente não pode alterar a matriz original, faria algo como o snippet abaixo, que não parece ser apreciavelmente mais rápido que sua solução:

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

[Editar 2]

Para completar, a seguinte função pode ser usada em vez do exemplo do OP prependArray(...)para tirar proveito do unshift(...)método 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];

Com o ES6, agora você pode usar o operador de spread para criar uma nova matriz com seus novos elementos inseridos antes dos elementos originais.

// 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]);

Atualização 17/08/2018: Desempenho

Pretendi que esta resposta apresentasse uma sintaxe alternativa que eu acho mais memorável e concisa. Deve-se notar que, de acordo com alguns parâmetros de referência (consulte esta outra resposta ), essa sintaxe é significativamente mais lenta. Provavelmente isso não será importante, a menos que você esteja executando muitas dessas operações em um loop.

Se você estiver anexando uma matriz à frente de outra matriz, é mais eficiente usar apenas concat. Assim:

var newArray = values.concat(oldArray);

Mas isso ainda será O (N) no tamanho do oldArray. Ainda assim, é mais eficiente do que iterar manualmente sobre o oldArray. Além disso, dependendo dos detalhes, isso pode ajudá-lo, porque se você anexará muitos valores, é melhor colocá-los em uma matriz primeiro e concatenar o oldArray no final, em vez de anexar cada um individualmente.

Não há como fazer melhor que O (N) no tamanho de oldArray, porque as matrizes são armazenadas na memória contígua com o primeiro elemento em uma posição fixa. Se você deseja inserir antes do primeiro elemento, é necessário mover todos os outros elementos. Se você precisar contornar isso, faça o que o @GWW disse e use uma lista vinculada ou uma estrutura de dados diferente.

Se você deseja anexar a matriz (a1 com uma matriz a2), use o seguinte:

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

Se você precisar preservar a matriz antiga, corte a matriz antiga e desvie o (s) novo (s) valor (es) para o início da fatia.

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

Eu tenho alguns testes novos de diferentes métodos de pré-anexação. Para matrizes pequenas (<1000 elems), o líder é para ciclo acoplado a um método push. Para matrizes enormes, o método Unshift se torna o líder.

Mas essa situação é real apenas para o navegador Chrome. No Firefox, o unshift tem uma otimização impressionante e é mais rápido em todos os casos.

A propagação do ES6 é 100 vezes mais lenta em todos os navegadores.

https://jsbench.me/cgjfc79bgx/1

Existe um método especial:

a.unshift(value);

Mas se você quiser acrescentar vários elementos à matriz, seria mais rápido usar esse método:

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]

Exemplo de anexação no local:

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

A.unshift(...B)

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

A chamada unshiftretorna apenas o comprimento da nova matriz. Então, para adicionar um elemento no começo e retornar uma nova matriz, fiz o seguinte:

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

ou simplesmente com o operador spread:

[ newVal, ...array ]

Dessa forma, a matriz original permanece intocada.