è l’operatore + meno performante di StringBuffer.append ()

Nella mia squadra, solitamente facciamo concatenazioni di stringhe come questa:

var url = // some dynamically generated URL var sb = new StringBuffer(); sb.append("click here"); 

Ovviamente quanto segue è molto più leggibile:

 var url = // some dynamically generated URL var sb = "click here"; 

Ma gli esperti di JS affermano che l’operatore + è meno performante di StringBuffer.append() . È proprio vero?

Internet Explorer è l’unico browser che soffre davvero di questo nel mondo di oggi. (Le versioni 5, 6 e 7 erano lente al cane 8 non mostra la stessa degradazione). Inoltre, IE diventa più lento e lento più lunga è la stringa.

Se hai delle stringhe lunghe da concatenare, usa sicuramente una tecnica array.join. (Oppure un wrapper StringBuffer attorno a questo, per la leggibilità.) Ma se le tue stringhe sono brevi non preoccuparti.

Il tuo esempio non è buono in quanto è molto improbabile che la performance sia significativamente diversa. Nel tuo esempio, la leggibilità dovrebbe superare le prestazioni perché il guadagno di prestazioni dell’uno contro l’altro è trascurabile. I vantaggi di un array (StringBuffer) sono evidenti solo quando si eseguono molte concatenazioni. Anche allora il tuo chilometraggio può dipendere molto dal tuo browser.

Ecco un’analisi dettagliata delle prestazioni che mostra le prestazioni utilizzando tutti i diversi metodi di concatenazione JavaScript su molti diversi browser; String Performance and Analysis

join () una volta, concat () una volta, join () per, + = for, concat () per

Di Più:
Ajaxian >> Performance delle corde in IE: Array.join vs + = continua

Sì, è vero, ma non dovresti preoccupartene. Vai con quello che è più facile da leggere. Se devi confrontare la tua app, concentrati sui colli di bottiglia.

Direi che la concatenazione delle stringhe non sarà il collo di bottiglia.

D’accordo con Michael Haren .

Considera anche l’uso di matrici e unisciti se la prestazione è davvero un problema.

 var buffer = ["click here"]; buffer.push("More stuff"); alert(buffer.join("")); 

Prova questo:

 var s = ["click here"].join(""); 

JavaScript non ha un object StringBuffer nativo, quindi suppongo che provenga da una libreria che stai utilizzando o da una caratteristica di un ambiente host insolito (cioè non un browser).

Dubito che una libreria (scritta in JS) possa produrre qualcosa di più veloce, anche se un object StringBuffer nativo potrebbe. La risposta definitiva può essere trovata con un profiler (se sei in esecuzione in un browser, Firebug ti fornirà un profiler per il motore JS trovato in Firefox).

Come già alcuni utenti hanno notato: questo è irrilevante per le stringhe piccole.

E i nuovi motori JavaScript in Firefox, Safari o Google Chrome lo ottimizzano

 "click here"; 

è veloce come

 ["click here"].join(""); 

Nelle parole di Knuth, “l’ottimizzazione prematura è la radice di tutto il male!” La piccola differenza in entrambi i casi molto probabilmente non avrà molto effetto alla fine; Sceglierei il più leggibile.

Il metodo più facile da leggere consente agli utenti di risparmiare una notevole quantità di tempo quando guardano il codice, mentre il metodo “più veloce” consuma solo impercettibili e probabilmente trascurabili quantità di tempo quando le persone navigano nella pagina.

So che questo post è zoppo, ma ho postato per sbaglio qualcosa di completamente diverso pensando che questo era un thread diverso e non so come eliminare i post. Colpa mia…

È abbastanza facile impostare un benchmark rapido e verificare le variazioni delle prestazioni di Javascript usando jspref.com . Che probabilmente non c’era quando è stata posta questa domanda. Ma per le persone che inciampano su questa domanda dovrebbero prendere in considerazione il sito.

Ho fatto un rapido test sui vari metodi di concatenazione su http://jsperf.com/string-concat-methods-test .

Mi piace usare lo stile funzionale, come ad esempio:

 function href(url,txt) { return "" +txt+ "" } function li(txt) { return "
  • " +txt+ "
  • " } function ul(arr) { return "
      " + arr.map(li).join("") + "
    " } document.write( ul( [ href("http://url1","link1"), href("http://url2","link2"), href("http://url3","link3") ] ) )

    Questo stile sembra leggibile e trasparente. Porta alla creazione di utilità che riducono la ripetizione nel codice.

    Anche questo tende ad usare automaticamente le stringhe intermedie.

    Per quanto ne so, ogni concatenazione implica una ridistribuzione della memoria. Quindi il problema non è l’operatore utilizzato per farlo, la soluzione è ridurre il numero di concatenazioni. Per esempio fai le concatenazioni al di fuori delle strutture di iterazione quando puoi.

    Sì, secondo i consueti parametri di riferimento. Ad esempio: http://mckoss.com/jscript/SpeedTrial.htm .

    Ma per le stringhe piccole, questo è irrilevante. Ti interessano solo le esibizioni su stringhe molto grandi. Inoltre, nella maggior parte degli script JS, il collo della bottiglia è raramente sulle manipolazioni di stringhe poiché non ce n’è abbastanza.

    Faresti meglio a guardare la manipolazione del DOM.