Effizienteste Methode, einen Wert einem Array voranzustellen

Question

Angenommen, ich habe ein Array mit einer Größe von N (wobei N > 0 ), gibt es einen effizienteren Weg, dem Array etwas voranzustellen, der nicht O(N + 1) Schritte erfordern würde?

Im Code bedeutet das, was ich derzeit tue, im Wesentlichen

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

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

  return newArray;
}

Answer 1

Ich habe einige neue Tests mit verschiedenen Methoden des Voranstellens durchgeführt. Für kleine Arrays (<1000 elems) ist der Führer für Zyklus mit einer Push-Methode gekoppelt. Bei großen Arrays wird die Unshift-Methode führend.

Diese Situation ist jedoch nur für den Chrome-Browser aktuell. In Firefox hat unshift eine großartige Optimierung und ist in allen Fällen schneller.

Die Verbreitung von ES6 ist in allen Browsern mehr als 100 Mal langsamer.

https://jsbench.me/cgjfc79bgx/1

Answer 2

F müssen Sie das alte Array erhalten, das alte Array und verschieben Sie den/die neuen Wert(e) an den Anfang des Slice.

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

Answer 3

Aufruf von unshift gibt nur die Länge des neuen Arrays zurück. Um also ein Element am Anfang hinzuzufügen und ein neues Array zurückzugeben, habe ich Folgendes getan:

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

oder einfach mit Spread-Operator:

[ newVal, ...array ]

Auf diese Weise bleibt die ursprüngliche Anordnung unangetastet.

Answer 4

Es gibt eine besondere Methode:

a.unshift(value);

Wenn Sie jedoch mehrere Elemente einem Array voranstellen wollen, wäre es schneller, eine solche Methode zu verwenden:

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]

Answer 5

Ich habe gerade einen Benchmark mit 4 Algorithmen in Chrome durchgeführt:

an Ort und Stelle:

// 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]
}

Kopie:

// 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]
}

Zusammenfassung: Wenn Sie an Ort und Stelle vorspannen wollen, sind sowohl unshift als auch splice gut, und wenn Sie eine Kopie wollen, dann scheint der Spread-Operator die beste Wahl zu sein ... zumindest auf Chrome.