Kopieren von array-Elemente in ein anderes array

Verwenden Sie die concat - Funktion, etwa so:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayA.concat(arrayB);

Den Wert newArray wird [1, 2, 3, 4] (arrayA und arrayB bleiben unverändert; concat erstellt und gibt ein neues array für das Ergebnis).

Werde ich eine weitere hinzufügen "future-proof" Antworten

In ECMAScript 6, die Sie verwenden können, die Verbreiten syntax:

JS:

let arr1 = [0, 1, 2];
let arr2 = [3, 4, 5];
arr1.push(...arr2);

console.log(arr1)

Verbreiten syntax ist noch nicht in allen gängigen Browsern. Für die aktuelle Kompatibilität, siehe dieser (ständig aktualisierten) Kompatibilitäts-Tabelle.

Sie können jedoch, verwenden, verbreiten syntax mit Babel.js.

edit:

Sehen Jack Giffin ' s Antwort weiter unten für mehr Kommentare auf die Leistung. Es scheint, concat ist immer noch besser und schneller als der spread-operator.

var a=new Array('a','b','c');
var b=new Array('d','e','f');
var d=new Array('x','y','z');
var c=a.concat(b,d)

Nicht, dass Ihr problem lösen ?

Gibt es eine Reihe von Antworten reden Array.der Prototyp.push.bewerben. Hier ist ein klares Beispiel:

JS:

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:

JS:

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]

Mit JavaScript ES6, können Sie den ... - operator, wie in spread-operator, die im wesentlichen konvertieren Sie das array-Werte. Dann können Sie etwas wie das hier tun:

const myArray = [1,2,3,4,5];
const moreData = [6,7,8,9,10];

const newArray = [
  ...myArray,
  ...moreData,
];

Während die syntax ist kurz, ich weiß nicht, wie diese intern arbeitet und was die Auswirkungen auf die Leistung sind auf großen arrays.

???????? ??? ???????

Für die Tatsachen, die eine performance test bei jsperf und die überprüfung einige Dinge in der Konsole durchgeführt werden. Für die Forschung, die website irt.org verwendet wird. Unten ist eine Auflistung von alle diese Quellen zusammen plus eine Beispiel-Funktion am Ende.

╔═══════════════╦══════╦═════════════════╦═══════════════╦═════════╦══════════╗ 
║ Methode ║Concat║slice&drücken.gelten ║ schieben.bewerben x2 ║ ForLoop ║Verbreiten ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║ mOps/Sec ║179 ║104 ║ 76 ║ 81 ║28 ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║ Sparse arrays ║JA! ║Nur die geschnittenen ║ Nein ║ Vielleicht2  ║Nein ║ 
║ gehalten spärlich ║ ║array (1. arg) ║ ║ ║ ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║ Unterstützung ║MSIE 4║MSIE 5.5 ║ MSIE 5.5 ║ MSIE 4 ║Edge 12 ║ 
║ (Quelle) ║NNav 4║NNav 4.06 ║ NNav 4.06 ║ NNav 3 ║MSIE NNav ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║Array-wie wirkt║Nein ║Nur geschoben ║ JA! ║ JA! ║Wenn ║ 
║wie ein array ║ ║array (2. arg) ║ ║ ║iterator1 ║ 
╚═══════════════╩══════╩═════════════════╩═══════════════╩═════════╩══════════╝ 
1, Wenn die array-artiges Objekt nicht über eine Symbol.iterator - Eigenschaft, dann versuchen 
um Sie zu verbreiten, wird eine Ausnahme ausgelöst. 
2 Hängt der code. Der folgende Beispiel-code, "JA" bewahrt Kargheit.

function mergeCopyTogether(inputOne, inputTwo){
   var oneLen = inputOne.length, twoLen = inputTwo.length;
   var newArr = [], newLen = newArr.length = oneLen + twoLen;
   for (var i=0, tmp=inputOne[0]; i !== oneLen; ++i) {
        tmp = inputOne[i];
        if (tmp !== undefined || inputOne.hasOwnProperty(i)) newArr[i] = tmp;
    }
    for (var two=0; i !== newLen; ++i, ++two) {
        tmp = inputTwo[two];
        if (tmp !== undefined || inputTwo.hasOwnProperty(two)) newArr[i] = tmp;
    }
    return newArr;
}

Wie oben gesehen, würde ich behaupten, dass Concat ist fast immer der Weg zu gehen für Leistung und die Fähigkeit zu behalten, die Kargheit des Ersatz-arrays. Dann für die array-mag (wie DOMNodeLists wie document.body.children), ich würde empfehlen die Verwendung der for-Schleife, weil es sowohl die 2. performantester und die einzige andere Methode, bei der sparse-arrays. Im folgenden werden wir schnell über das, was gemeint ist, von sparse-arrays und array-likes zu klären, die Verwirrung.

??? ??????

Zunächst, einige Leute denken vielleicht, dass dies eine Eintagsfliege, und dass browser-Anbieter schließlich erhalten rund um die Optimierung von Array.der Prototyp.drücken, um schnell genug zu schlagen Array.der Prototyp.concat. FALSCH! Array.der Prototyp.concat wird immer schneller (zumindest im Prinzip), weil es eine einfache copy-n-paste über die Daten. Unten ist eine vereinfachte persuado-visuelle Diagramm, was ein 32-bit array-Implementierung könnte so Aussehen (bitte beachten Sie realen Implementierungen sind VIEL komplizierter)

Byte ║ Daten hier 
═════╬═══════════ 
0x00 ║ int nonNumericPropertiesLength = 0x00000000 
0x01 ║ EBD 
0x02 ║ EBD 
0x03 ║ EBD 
0x00 ║ int length = 0x00000001 
0x01 ║ EBD 
0x02 ║ EBD 
0x03 ║ EBD 
0x00 ║ int valueIndex = 0x00000000 
0x01 ║ EBD 
0x02 ║ EBD 
0x03 ║ EBD 
0x00 ║ int valueType = JS_PRIMITIVE_NUMBER 
0x01 ║ EBD 
0x02 ║ EBD 
0x03 ║ EBD 
0x00 ║ uintptr_t valuePointer = 0x38d9eb60 (oder wo auch immer es in Erinnerung) 
0x01 ║ EBD 
0x02 ║ EBD 
0x03 ║ EBD

Wie oben gesehen, ist alles was Sie tun müssen, um zu kopieren, sowas ist fast so einfach wie kopieren, byte-für-byte. Mit Array.der Prototyp.push.gelten, es ist viel mehr als ein einfaches copy-n-paste über die Daten. Die ".anwenden" ist zu prüfen, jeder index im array und wandelt es in eine Reihe von Argumenten, vor der übergabe an Array.der Prototyp.push. Dann, Array.der Prototyp.push hat außerdem mehr Speicher zuzuweisen, jedes mal, und (bei einigen browser-Implementierungen), vielleicht sogar neu berechnen einige position-lookup-Daten für Kargheit.

Einen alternativen Weg zu denken ist. Das Quell-array ist ein großer Stapel Papiere zusammen geheftet. Das Quell-array zwei ist auch noch ein großer Stapel Papiere. Wäre es schneller für Sie zu

1. Den laden gehen, kaufen Sie genug Papier benötigt, um eine Kopie von jedem Quell-array. Dann setzen Sie jede Quell-Arrays, Stapel von Papier durch eine Kopie-Maschine, und Heften Sie die daraus resultierenden zwei Kopien zusammen.
2. Den laden gehen, kaufen Sie genug Papier für eine Ausgabe der ersten source-array. Kopieren Sie dann die Quell-array in das neue Papier von hand, dafür zu sorgen füllen Sie in eine leere lichten Flecken. Dann, zurück in den laden gehen, kaufen Sie genügend Papier für den zweiten source-array. Dann gehen Sie durch die zweite source-array und kopieren Sie es während der Gewährleistung keine leere Lücken in der Kopie. Dann Heften die kopierten Papiere zusammen.

In der obigen Analogie, option #1 repräsentiert Array.der Prototyp.concat, während #2 repräsentiert Array.der Prototyp.push.gelten. Lassen Sie uns testen Sie dies mit einem ähnlichen JSperf die sich nur in, dass diese tests der Methoden über sparse arrays, keine festen arrays. Kann man es gleich hier.

Also, ich rest mein Fall, der die Zukunft der performance für diesen Anwendungsfall liegt nicht in der Reihe.der Prototyp.push, sondern in der Reihe.der Prototyp.concat.

??????????????

????? ??????

Wenn bestimmte Elemente des Arrays sind einfach nicht vorhanden ist. Zum Beispiel:

JS:

//This is just as an example. In actual code, 
//do not mix different types like this.
var mySparseArray = [];
mySparseArray[0] = "foo";
mySparseArray[10] = undefined;
mySparseArray[11] = {};
mySparseArray[12] =  10;
mySparseArray[17] = "bar";
console.log("Length:   ", mySparseArray.length);
console.log("0 in it:  ", 0 in mySparseArray);
console.log("arr[0]:   ", mySparseArray[0]);
console.log("10 in it: ", 10 in mySparseArray);
console.log("arr[10]   ", mySparseArray[10]);
console.log("20 in it: ", 20 in mySparseArray);
console.log("arr[20]:  ", mySparseArray[20]);

Alternativ mit javascript können Sie zum initialisieren Ersatz-arrays leicht.

var mySparseArray = ["foo",,,,,,,,,,undefined,{},10,,,,,"bar"];

?????-?????

Eines Arrays wird ein Objekt, für das mindestens ein length Eigenschaft, aber wurde nicht initialisiert, mit new Array oder []; Zum Beispiel die unter-Objekte werden klassifiziert als array-like.

{0: "foo", 1: "bar", Länge:2}

Dokument.Körper.Kinder

neue Uint8Array(3)

• Dies ist array-like, denn obwohl es eine(n) (Eingabe) array, Zwang es in ein array von änderungen der Konstruktor.

(function(){return arguments})()

Beobachten, was passiert mit eine Methode, die zwingen array-mag in arrays wie slice.

JS:

var slice = Array.prototype.slice;
//For arrays:
console.log(slice.call(["not an array-like, rather a real array"]));
//For array-likes:
console.log(slice.call({0: "foo", 1: "bar", length:2}));
console.log(slice.call(document.body.children));
console.log(slice.call(new Uint8Array(3)));
console.log(slice.call( function(){return arguments}() ));

• HINWEIS: Es ist eine schlechte Praxis zu nennen-slice-Funktion Argumente wegen der Leistung.

Beobachten, was passiert mit eine Methode, die nicht zwingen array-mag in arrays wie z.B. concat.

JS:

var empty = [];
//For arrays:
console.log(empty.concat(["not an array-like, rather a real array"]));
//For array-likes:
console.log(empty.concat({0: "foo", 1: "bar", length:2}));
console.log(empty.concat(document.body.children));
console.log(empty.concat(new Uint8Array(3)));
console.log(empty.concat( function(){return arguments}() ));

Wenn Sie möchten, ändern Sie die original-array, können Sie zu verbreiten und drücken Sie:

var source = [1, 2, 3];
var range = [5, 6, 7];
var length = source.push(...range);

console.log(source); //[ 1, 2, 3, 5, 6, 7 ]
console.log(length); //6

Wenn Sie sicherstellen möchten, dass nur Elemente des gleichen Typs gehen in der source array (mischen nicht zahlen und strings zum Beispiel), dann verwenden Sie Typoskript.

/**
 * Adds the items of the specified range array to the end of the source array.
 * Use this function to make sure only items of the same type go in the source array.
 */
function addRange<T>(source: T[], range: T[]) {
    source.push(...range);
}

Dies ist eine funktionierende code-und es funktioniert:

var els = document.getElementsByTagName('input'), i;
var invnum = new Array();
var k = els.length;
for(i = 0; i < k; i++){invnum.push(new Array(els[i].id,els[i].value))}