Un modo migliore per unire un array in un array in javascript

C’è un modo migliore di questo per unire un array in un altro array in javascript

var string = 'theArray.splice('+start+', '+number+',"'+newItemsArray.join('","')+'");'; eval(string); 

Puoi usare apply per evitare la valutazione:

 var args = [start, number].concat(newItemsArray); Array.prototype.splice.apply(theArray, args); 

La funzione apply viene utilizzata per chiamare un’altra funzione, con un determinato contesto e argomenti, forniti come matrice, ad esempio:

Se chiamiamo:

 var nums = [1,2,3,4]; Math.min.apply(Math, nums); 

La funzione apply verrà eseguita:

 Math.min(1,2,3,4); 

AGGIORNAMENTO: versione ES6

Se la tua codifica in ES6 è ansible utilizzare l’operatore di “spread” (…)

 array.splice(index, 0, ...arrayToInsert); 

Per ulteriori informazioni sull’operatore di diffusione, consultare la documentazione di mozilla .

Il “vecchio” modo ES5

Se avvolgi la risposta superiore in una funzione ottieni questo:

 function insertArrayAt(array, index, arrayToInsert) { Array.prototype.splice.apply(array, [index, 0].concat(arrayToInsert)); } 

Lo useresti in questo modo:

 var arr = ["A", "B", "C"]; insertArrayAt(arr, 1, ["x", "y", "z"]); alert(JSON.stringify(arr)); // output: A, x, y, z, B, C 

Puoi verificarlo in questo jsFiddle: http://jsfiddle.net/luisperezphd/Wc8aS/

Questa domanda è davvero vecchia, ma con ES6, c’è un modo più semplice per farlo usando l’operatore di spread:

 sourceArray.splice(index, 0, ...insertedArray) 

Se stai utilizzando javascript non compilato nel browser, assicurati di verificare se è supportato nel browser di destinazione all’indirizzo https://kangax.github.io/compat-table/es6/#test-spread_(…)_operator .


Inoltre, questo potrebbe essere leggermente fuori tema, ma se non vuoi o devi modificare l’array originale, ma potresti usare un nuovo array, considera questo approccio:

 mergedArray = sourceArray.slice(0, index).concat(insertedArray, sourceArray.slice(index)) 

È inoltre ansible aggiungere una funzione simile al prototipo Array, se si desidera qualcosa che è quasi identico al metodo di giunzione. Per esempio

 Array.prototype.spliceArray = function(index, n, array) { return Array.prototype.splice.apply(this, [index, n].concat(array)); } 

Quindi l’utilizzo sarebbe semplicemente:

 var array = ["A","B","C","","E","F"]; array.splice(3,1,"D"); // array is ["A","B","C","D","E","F"] array.spliceArray(3,3,["1","2","3"]); // array is ["A","B","C","1","2","3"] 

Guardalo in azione qui: http://jsfiddle.net/TheMadDeveloper/knv2f8bb/1/

Alcune note:

  • La funzione splice modifica direttamente l’array, ma restituisce un array di elementi che sono stati rimossi … non l’array spliced.
  • Mentre di solito non è consigliabile estendere le classi javascript core, questo è relativamente benigno con la maggior parte dei framework standard.
  • L’estensione Array non funziona nei casi in cui vengono utilizzate classi di array specializzate, ad esempio i dati ImageData Uint8ClampedArray.

Le risposte sopra che coinvolgono splice.apply e inseriscono l’array in un unico liner farà esplodere lo stack in un overflow dello stack per un array di grandi dimensioni. Vedi esempio qui: http://jsfiddle.net/gkohen/u49ku99q/ Potrebbe essere necessario affettare e spingere ogni elemento della parte inserita e rimanente dell’array originale affinché funzioni. Vedi fiddle: http://jsfiddle.net/gkohen/g9abppgy/26/

 Array.prototype.spliceArray = function(index, insertedArray) { var postArray = this.splice(index); inPlacePush(this, insertedArray); inPlacePush(this, postArray); function inPlacePush(targetArray, pushedArray) { // Not using forEach for browser compatability var pushedArrayLength = pushedArray.length; for (var index = 0; index < pushedArrayLength; index++) { targetArray.push(pushedArray[index]); } } } 

Volevo avere una funzione che richiedesse solo una parte dell’array sorgente, quindi ho la mia leggermente diversa sulla base della risposta del CMS

 function spliceArray(array, index, howmany, source, start, end) { var arguments; if( source !== undefined ){ arguments = source.slice(start, end); arguments.splice(0,0, index, howmany); } else{ arguments = [index, howmany]; } return Array.prototype.splice.apply(array, arguments) } Array.prototype.spliceArray = function(index, howmany, source, start, end) { return spliceArray(this, index, howmany, source, start, end); } 

Puoi vederlo su: https://jsfiddle.net/matthewvukomanovic/nx858uz5/

Ci sono molte risposte intelligenti qui, ma la ragione per cui usi la giunzione è che mette gli elementi nell’array corrente senza crearne un altro. Se devi creare una matrice su concat() modo che tu possa usare apply() allora stai creando 2 ulteriori array di rifiuti! Sorta sconfigge l’intero scopo di scrivere Javascript esoterico. Inoltre, se non ti importa di quella roba di utilizzo della memoria (e dovresti) basta dest = src1.concat(src2) ; è infinitamente più leggibile. Quindi ecco il mio più piccolo numero di linee pur restando una risposta efficiente.

 for( let item of src ) dest.push( item ); 

Oppure se desideri eseguire il polyfill e riprendere un po ‘meglio il supporto del browser:

 src.forEach( function( x ) { dest.push(x); }); 

Sono sicuro che il primo è più performante (è una parola;), ma non è supportato in tutti i browser là fuori in natura.

Controlla questo link, spero che funzionerà

Controlla questo link