Copia serie de elemente într-o altă matrice

Utilizați concat funcție, astfel:

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

Valoarea de newArray va fi[1, 2, 3, 4] (arrayA " și " arrayB rămâne neschimbată; concat creează și returnează o nouă gamă de rezultat).

Condiția tablouri nu sunt foarte mari (a se vedea avertismentul de mai jos), puteți folosi push()metoda de matrice la care doriți să adăugați valori.push()poate avea mai mulți parametri, astfel încât să puteți utiliza acesteia se aplică () metoda pentru a trece matrice de valori să fie împins ca o listă de parametrii funcției. Acest lucru are avantajul de-a lungul folosindconcat()` adăugarea de elemente în matrice în loc, mai degrabă decât crearea unei noi matrice.

Cu toate acestea, se pare că pentru tablouri de mari dimensiuni (de ordinul a 100.000 de membri sau mai mult), acest truc poate eșua. Pentru o astfel de matrice, folosind o buclă este o abordare mai bună. Vezi https://stackoverflow.com/a/17368101/96100 pentru detalii.

var newArray = [];
newArray.push.apply(newArray, dataArray1);
newArray.push.apply(newArray, dataArray2);

Ați putea dori pentru a generaliza acest lucru într-o funcție:

function pushArray(arr, arr2) {
    arr.push.apply(arr, arr2);
}

... sau adăugați-l la "Matrice" 's de prototip:

Array.prototype.pushArray = function(arr) {
    this.push.apply(this, arr);
};

var newArray = [];
newArray.pushArray(dataArray1);
newArray.pushArray(dataArray2);

... sau imite originalul push() metoda prin care permite mai multor parametri folosind faptul că concat(), ca push(), permite mai multor parametri:

Array.prototype.pushArray = function() {
    this.push.apply(this, this.concat.apply([], arguments));
};

var newArray = [];
newArray.pushArray(dataArray1, dataArray2);

Aici's-o bază de buclă versiune de ultimul exemplu, potrivit pentru rețele mari și toate browserele majore, inclusiv IE <= 8:

Array.prototype.pushArray = function() {
    var toPush = this.concat.apply([], arguments);
    for (var i = 0, len = toPush.length; i < len; ++i) {
        this.push(toPush[i]);
    }
};

Voi adăuga unul mai mult "de viitor" răspuns

În ECMAScript 6, puteți utiliza Răspândirea sintaxa:

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

console.log(arr1)

Răspândirea sintaxa nu este încă inclusă în toate browserele majore. Pentru curent de compatibilitate, a se vedea (actualizat continuu) tabelul de compatibilitate.

Cu toate acestea, puteți utiliza răspândit cu sintaxa Babel.js.

edit:

Vezi Jack Giffin's de răspuns de mai jos pentru mai multe comentarii pe performanță. Se pare concat este mai bine și mai repede decât răspândirea operator.

A găsit un mod elegant de MDN

var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];

// Merge the second array into the first one
// Equivalent to vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']

Sau poti folosi `a răspândit operator caracteristică a ES6:

let fruits = [ 'apple', 'banana'];
const moreFruits = [ 'orange', 'plum' ];

fruits.push(...moreFruits); // ["apple", "banana", "orange", "plum"]

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)

Asta rezolva problema ta ?

Următoarele pare mai simplu pentru mine:

var newArray = dataArray1.slice();
newArray.push.apply(newArray, dataArray2);

Ca "push" are un număr variabil de argumente, puteți folosi "aplică" metoda de tip "push" funcție pentru a împinge toate elementele de un alt tablou. Se construiește un apel pentru a împinge folosind primul argument ("newArray" aici) ca "acest" și elementele de matrice ca și celelalte argumente.

Pe felie în prima declarație devine o copie a primei matrice, astfel încât să don't de a modifica aceasta.

Update Dacă utilizați o versiune de javascript cu felie disponibile, puteți simplifica "push", în expresia sa:

newArray.push(...dataArray2)

Funcția de mai jos nu't au o problemă cu lungimea de matrice și se comportă mai bine decât toate soluțiile propuse:

function pushArray(list, other) {
    var len = other.length;
    var start = list.length;
    list.length = start + len;
    for (var i = 0; i < len; i++ , start++) {
        list[start] = other[i];
    }
}

din păcate, jspref refuză să accepte cererile, asa ca aici sunt rezultatele folosind benchmark.js

        Name            |   ops/sec   |  ± %  | runs sampled
for loop and push       |      177506 |  0.92 | 63
Push Apply              |      234280 |  0.77 | 66
spread operator         |      259725 |  0.40 | 67
set length and for loop |      284223 |  0.41 | 66

în cazul în care

pentru buclă și împingeți este:

    for (var i = 0, l = source.length; i < l; i++) {
        target.push(source[i]);
    }

Împinge Aplica:

target.push.apply(target, source);

răspândirea operator:

    target.push(...source);

și, în final 'set lungime și buclă pentru' este funcția de mai sus

Există un număr de răspunsuri vorbesc despre Matrice.prototip.împinge.aplica. Aici este un exemplu clar:

var dataArray1 = [1, 2]; var dataArray2 = [3, 4, 5]; var newArray = [ ]; Matrice.prototip.împinge.aplica(newArray, dataArray1); // newArray = [1, 2] Matrice.prototip.împinge.aplica(newArray, dataArray2); // newArray = [1, 2, 3, 4, 5] console.log(JSON.stringify(newArray)); // Iesiri: [1, 2, 3, 4, 5]

Dacă aveți ES6 sintaxa:

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]

Cu JavaScript ES6, puteți utiliza ... operator ca o răspândire operator care, în esență, va converti matrice în valori. Apoi, puteți face ceva de genul asta:

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

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

În timp ce sintaxa este concis, nu știu cum funcționează la nivel intern și ce implicații de performanță sunt pe tablouri de mari dimensiuni.

Aici's ES6 mod

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

metoda De mai sus este bun pentru a merge pentru cele mai multe dintre cazuri si cazuri, nu este vă rugăm să ia în considerare concat, ca ai sute de mii de elemente în matrice.

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

𝗥𝗲𝘀𝗲𝗮𝗿𝗰𝗵 𝗔𝗻𝗱 𝗥𝗲𝘀𝘂𝗹𝘁𝘀

Pentru fapte, un test de performanță la jsperf și verificarea unele lucruri in consola sunt efectuate. Pentru cercetare, site-ul irt.org este folosit. Mai jos este o colecție de toate aceste surse pus împreună, plus un exemplu de funcție în partea de jos.

╔═══════════════╦══════╦═════════════════╦═══════════════╦═════════╦══════════╗ 
║ Metoda ║Concat║felie&push.aplica ║ împinge.aplica x2 ║ ForLoop ║Răspândit ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║ mopuri/Sec ║179 ║104 ║ 76 ║ 81 ║28 ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║ Tablouri rare ║DA! ║Doar felii ║ nu ║ Poate2  ║nu ║ 
║ ținut rare ║ ║array (1 arg) ║ ║ ║ ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║ Suport ║microsoft internet explorer 4║microsoft internet explorer 5.5 ║ microsoft internet explorer 5.5 ║ microsoft internet explorer 4 ║C 12 ║ 
║ (sursa) ║NNav 4║NNav 4.06 ║ NNav 4.06 ║ NNav 3 ║MSIE NNav ║ 
╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ 
║Matrice-ca acte║nu ║Numai împins ║ DA! ║ DA! ║Dacă au ║ 
║ca o matrice ║ ║array (2 arg) ║ ║ ║iterator1 ║ 
╚═══════════════╩══════╩═════════════════╩═══════════════╩═════════╩══════════╝ 
1 în Cazul în matrice ca obiect nu are o Simbol.iterator proprietate, apoi încearcă 
 să se răspândească se va arunca o excepție. 
2 Depinde de cod. Următorul exemplu de cod "DA" păstrează răzleț.

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;
}

Cum am văzut mai sus, aș spune că Concat este aproape întotdeauna calea de a merge pentru performanță și capacitatea de a reține răzleț de schimb tablouri. Apoi, pentru array-i place (cum ar fi DOMNodeLists ca document.corpul.copii`), mi-ar recomanda utilizarea pentru bucla pentru că este atât de-al 2-lea cel mai performant și singura metodă care păstrează tablouri rare. Mai jos, vom trece rapid peste ceea ce se înțelege prin tablouri rare și matrice-i place pentru a clarifica confuzia.

𝗧𝗵𝗲 𝗙𝘂𝘁𝘂𝗿𝗲

La început, unii oameni ar putea crede că aceasta este o întâmplare și că browser-furnizori în cele din urmă va obține în jurul valorii de pentru optimizarea Matrice.prototip.împinge să fie suficient de rapid pentru a bate Matrice.prototip.concat. GRESIT! Matrice.prototip.concat va fi întotdeauna mai repede (în principiu, cel puțin), pentru că este un simplu copy-n-paste peste date. Mai jos este simplificată persuado-vizuale diagrama de ce un 32-bit matrice de implementare ar putea arata ca (vă rugăm să rețineți real implementări sunt MULT mai complicate)

Byte ║ Date aici 
═════╬═══════════ 
0x00 ║ int nonNumericPropertiesLength = 0x00000000 
0x01 ║ ibidem 
0x02 ║ ibidem 
0x03 ║ ibidem 
0x00 ║ int lungime = 0x00000001 
0x01 ║ ibidem 
0x02 ║ ibidem 
0x03 ║ ibidem 
0x00 ║ int valueIndex = 0x00000000 
0x01 ║ ibidem 
0x02 ║ ibidem 
0x03 ║ ibidem 
0x00 ║ int valueType = JS_PRIMITIVE_NUMBER 
0x01 ║ ibidem 
0x02 ║ ibidem 
0x03 ║ ibidem 
0x00 ║ uintptr_t valuePointer = 0x38d9eb60 (sau oriunde este în memorie) 
0x01 ║ ibidem 
0x02 ║ ibidem 
0x03 ║ ibid

// 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, javascript vă permite să inițializați schimb tablouri cu ușurință.

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

𝗔𝗿𝗿𝗮𝘆-𝗟𝗶𝗸𝗲𝘀

O matrice-ca este un obiect care are cel puțin o "lungime" de proprietate, dar nu a fost inițializat cu noua Matrice " sau " []`; De exemplu, mai jos de obiecte sunt clasificate ca matrice-ca.

{0: "foo", 1: "bar", lungime:2}

document.corpul.copii

nou Uint8Array(3)

(function(){întoarcere argumente})()

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}() ));

• NOTĂ: nu este un exercițiu bun pentru a apela felie pe funcția de argumente, deoarece de performanță. Observați ce se întâmplă, folosind o metodă care nu nu constrânge matrice-i place în tablouri ca concat.

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}() ));

Avem două matrice a și b. codul ceea ce a făcut aici este matrice o valoare este împins în matrice b.

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' ]

Dacă doriți să modificați matrice inițială, vă pot răspândi și împingeți:

`JavaScript var source = [1, 2, 3]; var interval = [5, 6, 7]; var lungime = sursa.push (raza);

console.log(sursa); // [ 1, 2, 3, 5, 6, 7 ] console.log(lungime); // 6 ``

Dacă doriți să vă asigurați că numai elemente de același tip, du-te la "sursă" array (nu de amestecare numere si siruri de caractere, de exemplu), apoi utilizați mașina de Scris.

``TypeScript /**

• Adaugă elementele din intervalul specificat matrice la sfârșitul sursa matrice.
• Utilizați această funcție pentru a vă asigura că numai elemente de același tip, du-te in sursa matrice. */ funcția addRange(sursa: T[], gama: T[]) { sursa.push (raza); } ``

în loc de push() utilizați funcția concat funcția pentru IE. de exemplu,

var a=a.concat(a,new Array('amin'));

Acesta este un cod de lucru și funcționează bine:

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))}