Quale metodo è più veloce?Array Join vs String Concat
Array registrazione:
var str_to_split = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z";
var myarray = str_to_split.split(",");
var output=myarray.join("");
String Concat:
var str_to_split = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z";
var myarray = str_to_split.split(",");
var output = "";
for (var i = 0, len = myarray.length; i<len; i++){
output += myarray[i];
}
La concatenazione di stringhe è più veloce in ECMAScript. Ecco un punto di riferimento che ho creato visualizzare:
Safari sembra essere l'unico browser in cui sono testa a testa. – AlienWebguy
20 alfabeti cuciti e il benchmark rimane coerente. – AlienWebguy
Ho anche pensato in modo opposto ma ho trovato un altro esempio http://jsperf.com/join-concat/2. Perché? String non è immutabile in ECMAScript? –
posso sicuramente dire che l'uso di Array.join() è più veloce. Ho lavorato su alcune parti del codice JavaScript e velocizzato notevolmente le prestazioni rimuovendo la manipolazione delle stringhe a favore degli array.
Gli ultimi test lo confermano: https://github.com/nodejs/node/issues/6610 –
Secondo this Google document titled 'Optimizing JavaScript code' stringa concat è più lento di serie unirsi ma a quanto pare questo non è vero per i moderni motori Javascript.
Ho fatto a benchmark for the Fibonacci test example che hanno usato nel documento e mostra che concatenando (incollando) la stringa è quasi 4x veloce quanto usando Arrayjoin.
Il benchmark non è molto buono in quanto non si confronta solo la concatenazione di stringhe con l'unione un array ma nel caso di join crea anche un nuovo array nel benchmark. – dpr
partire dal 2011 e fino al giorno moderno ...
vedere il seguente join riscrittura usando concatenazione di stringhe, e quanto più lento è che l'implementazione standard.
// Number of times the standard `join` is faster, by Node.js versions:
// 0.10.44: ~2.0
// 0.11.16: ~4.6
// 0.12.13: ~4.7
// 4.4.4: ~4.66
// 5.11.0: ~4.75
// 6.1.0: Negative ~1.2 (something is wrong with 6.x at the moment)
function join(sep) {
var res = '';
if (this.length) {
res += this[0];
for (var i = 1; i < this.length; i++) {
res += sep + this[i];
}
}
return res;
}
La morale è - non concatenare stringhe manualmente, sempre utilizzare lo standard join.
Mi sono imbattuto in questo argomento e le altre risposte sono forse corrette nel 2011, ma in questo momento il join è davvero migliore. – Cageman
L'operatore diffusione, scritto con tre punti consecutivi (...), è nuovo in ES6 e ti dà la possibilità di ampliare, o diffusi, oggetti iterabili in più elementi.
const books = ["Don Quixote", "The Hobbit", "Alice in Wonderland", "Tale of Two Cities"];
console.log(...books);stampe: Don Chisciotte Lo Hobbit Alice in Wonderland due città
Questo funziona solo se la tua funzione accetta più argomenti ('' resto'). 'console.log' è un esempio. Tuttavia, questo non sempre risponde alla domanda dell'OP perché potresti utilizzare una funzione che accetta solo 1 parametro stringa, nel qual caso l'operatore di spread fallirebbe. – chharvey
manuale concatenazione è più veloce, per una matrice numerica di lunghezza fissa.
Here's a JSPerf test that tests these two operations:
zxy.join('/')
// versus
zxy[0] + '/' + zxy[1] + '/' + zxy[2]
// given the array
zxy = [1, 2, 3]
// resulting in the string '0/1/2'
`` `
Risultati: usare Chrome 64.0.3282.186, Array.join era più lento del 46%.
Dipende da ciò che si desidera. Il metodo String è leggermente più semplice. La modalità di join di Array potrebbe essere un po 'più veloce (puoi testare su jsperf.com). – andrewmu
Qual è il ciclo for esattamente? Basta copiare o stai elaborando. Esistono modi più veloci per copiare un array. – epascarello
epascarello, sono solo degli stupidi esempi per testare questi 2 metodi – ajax333221