Kopieren von Array-Elementen in ein anderes Array

Question

Ich habe ein JavaScript-Array dataArray die ich in ein neues Array schieben möchte newArray . Nur will ich nicht newArray[0] zu sein dataArray . Ich möchte alle Elemente in das neue Array schieben:

var newArray = [];

newArray.pushValues(dataArray1);
newArray.pushValues(dataArray2);
// ...

oder noch besser:

var newArray = new Array (
   dataArray1.values(),
   dataArray2.values(),
   // ... where values() (or something equivalent) would push the individual values into the array, rather than the array itself
);

Das neue Array enthält nun also alle Werte der einzelnen Daten-Arrays. Gibt es eine Kurzschrift wie pushValues zur Verfügung, so dass ich nicht jeden einzelnen Schritt durchlaufen muss. dataArray , indem Sie die Elemente nacheinander hinzufügen?

Answer 1

Leistung

Ich analysiere die aktuellen Lösungen und schlage 2 neue vor (F und G werden im Detail vorgestellt), die für kleine und mittlere Arrays extrem schnell sind

Heute 2020.11.13 Ich führe Tests auf MacOs HighSierra 10.13.6 auf Chrome v86, Safari v13.1.2 und Firefox v82 für ausgewählte Lösungen

Ergebnisse

Für alle Browser

• Lösungen basierend auf while-pop-unshift (F,G) sind (extrem) schnell auf allen Browsern für kleine und mittelgroße Arrays. Für Arrays mit 50000 Elementen verlangsamt sich diese Lösung in Chrome
• Lösungen C,D für Felder mit 500000 Pausen: "RangeError: Maximale Aufrufstapelgröße überschritten
• Lösung (E) ist am langsamsten

Einzelheiten

Ich führe 2 Testfälle durch:

• wenn Arrays 10 Elemente haben - Sie können es ausführen HIER
• wenn Arrays 10k Elemente haben - Sie können es ausführen HIER

Der folgende Ausschnitt zeigt die Unterschiede zwischen den Lösungen A , B , C , D , E , F(my), G(my), H , I

// https://stackoverflow.com/a/4156145/860099
function A(a,b) {
  return a.concat(b);
}

// https://stackoverflow.com/a/38107399/860099 
function B(a,b) {
  return [...a, ...b];
}

// https://stackoverflow.com/a/32511679/860099
function C(a,b) {
  return (a.push(...b), a);
}

// https://stackoverflow.com/a/4156156/860099
function D(a,b) {
    Array.prototype.push.apply(a, b);
    return a;
}

// https://stackoverflow.com/a/60276098/860099
function E(a,b) {
    return b.reduce((pre, cur) => [...pre, cur], a);
}

// my
function F(a,b) {
    while(b.length) a.push(b.shift());
    return a;
}

// my
function G(a,b) {
    while(a.length) b.unshift(a.pop());
    return b;
}

// https://stackoverflow.com/a/44087401/860099
function H(a, b) {
    var len = b.length;
    var start = a.length;
    a.length = start + len;
    for (var i = 0; i < len; i++ , start++) {
        a[start] = b[i];
    }
    return a;
}

// https://stackoverflow.com/a/51860949/860099
function I(a, b){
   var oneLen = a.length, twoLen = b.length;
   var newArr = [], newLen = newArr.length = oneLen + twoLen;
   for (var i=0, tmp=a[0]; i !== oneLen; ++i) {
        tmp = a[i];
        if (tmp !== undefined || a.hasOwnProperty(i)) newArr[i] = tmp;
    }
    for (var two=0; i !== newLen; ++i, ++two) {
        tmp = b[two];
        if (tmp !== undefined || b.hasOwnProperty(two)) newArr[i] = tmp;
    }
    return newArr;
}

// ---------
// TEST
// ---------

let a1=[1,2,3];
let a2=[4,5,6];

[A,B,C,D,E,F,G,H,I].forEach(f=> {
    console.log(`${f.name}: ${f([...a1],[...a2])}`)
})

Und hier sind Beispielergebnisse für Chrom

Answer 2

Hier ist der ES6-Weg

var newArray = [];
let dataArray1 = [1,2,3,4]
let dataArray2 = [5,6,7,8]
newArray = [...dataArray1, ...dataArray2]
console.log(newArray)

Die oben beschriebene Methode ist für die meisten Fälle geeignet, und in den Fällen, in denen sie nicht geeignet ist, sollten Sie Folgendes beachten concat als ob Sie Hunderttausende von Elementen in Arrays hätten.

    let dataArray1 = [1,2,3,4]
    let dataArray2 = [5,6,7,8]
    let newArray = dataArray1.concat(dataArray2);
    console.log(newArray)

Answer 3

Es gibt eine Reihe von Antworten zu folgenden Themen Array.prototype.push.apply . Hier ist ein klares Beispiel:

var dataArray1 = [1, 2];
var dataArray2 = [3, 4, 5];
var newArray = [ ];
Array.prototype.push.apply(newArray, dataArray1); // newArray = [1, 2]
Array.prototype.push.apply(newArray, dataArray2); // newArray = [1, 2, 3, 4, 5]
console.log(JSON.stringify(newArray)); // Outputs: [1, 2, 3, 4, 5]

Wenn Sie ES6-Syntax haben:

var dataArray1 = [1, 2];
var dataArray2 = [3, 4, 5];
var newArray = [ ];
newArray.push(...dataArray1); // newArray = [1, 2]
newArray.push(...dataArray2); // newArray = [1, 2, 3, 4, 5]
console.log(JSON.stringify(newArray)); // Outputs: [1, 2, 3, 4, 5]

Answer 4

Wir haben zwei Array a und b. der Code, was hier getan hat, ist Array ein Wert in Array b geschoben.

let a = [2, 4, 6, 8, 9, 15]

function transform(a) {
    let b = ['4', '16', '64']
    a.forEach(function(e) {
        b.push(e.toString());
    });
    return b;
}

transform(a)

[ '4', '16', '64', '2', '4', '6', '8', '9', '15' ]

Answer 5

Versuchen Sie dies:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayB.reduce((pre, cur) => [...pre, ...cur], arrayA);
console.log(newArray)