Während des Skriptentwicklungsprozesses wird häufig eine große Zeichenfolge kombiniert und für die Ausgabe nach einer bestimmten Regel gespleißt. Zum Beispiel beim Schreiben eines Skriptsteuerelements, der HTML-Tag-Ausgabe, die das Erscheinungsbild des gesamten Steuerelements steuert, oder beim dynamischen Analysieren und Erstellen von HTML-Tags nach dem Erhalten des serverseitigen Rückgabewerts in AJAX, aber ich werde nicht auf die spezifische Anwendung eingehen Hier möchte ich nur die Effizienz des Spleißens besprechen.
Wenn wir String-Spleißen schreiben, verwenden wir immer den Operator „+=“, s += String; Ich weiß nicht, ob Sie bemerkt haben, dass die Kapazität der kombinierten Zeichenfolge ist Zehn oder sogar Hunderte von K, die Skriptausführung ist sehr langsam und die CPU-Auslastung ist extrem hoch, zum Beispiel:
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n";
var result = "";
for(var i=0; i<2000; i++) result += str;
In nur einem Schritt beträgt die Ergebniszeichenfolge 200 KB, es dauert 1,1 Sekunden (dies hängt mit der Computerkonfiguration zusammen) und der CPU-Spitzenwert beträgt 100 %. (Um den Effekt intuitiver zu sehen, habe ich einige weitere Schleifen erstellt.) Es ist denkbar, dass ein solcher Arbeitsschritt mehr als eine Sekunde meiner Zeit in Anspruch nimmt. In Verbindung mit dem Zeitverbrauch anderer Codes wird die Ausführungszeit des gesamten Skriptblocks unerträglich. Gibt es eine Optimierungslösung? Gibt es eine andere Möglichkeit? Die Antwort ist natürlich ja, sonst wäre es für mich Unsinn, diesen Artikel zu schreiben.
Der schnellere Weg besteht darin, ein Array zu verwenden, anstatt es in einen String zu spleißen. Anschließend wird der String in ein Array eingefügt und schließlich wird array.join("") verwendet, um den Ergebnisstring zu erhalten :
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n";
var result = "", a = new Array();
for(var i=0; i<2000; i++) a[i] = str;
result = a.join(""); a = null;
Sie können die Zeit testen, die zum Kombinieren einer Zeichenfolge derselben Größe benötigt wird. Das Ergebnis, das ich hier getestet habe, ist: <15 Millisekunden. Das bedeutet, dass der Zeitaufwand der beiden Modi für den Aufbau einer solchen 200-KByte-Reihe fast zwei Größenordnungen beträgt. was bedeutet das? Das bedeutet, dass letzterer seine Arbeit beendet hat und vom Mittagessen zurückgekehrt ist, während ersterer noch hart arbeitet. Ich habe eine Testseite geschrieben. Sie können den folgenden Code kopieren, als HTM-Datei speichern und auf der Webseite öffnen, um den Effizienzunterschied zwischen den beiden zu testen. Was ich jedoch getestet habe, ist, dass ersteres eine halbe Minute dauert , und letzteres Oder es kann in 0,07 Sekunden durchgeführt werden (10.000-malige Schleife).
<Körper>
Anzahl der Zeichenfolgenverkettungen<input id="totle" value="1000" size="5" maxlength="5">
<input type="button" value="String splicing method" onclick="method1()">
<input type="button" value="Array-Zuweisungs-Join-Methode" onclick="method2()"><br>
<div id="method1"> </div>
<div id="method2"> </div>
<textarea id="show" style="width: 100%; height: 400"></textarea>
<SCRIPT LANGUAGE="JavaScript">
<!--
// Die Länge dieser gespleißten Zeichenfolge beträgt 100 Byte. Autor: meizz
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n"
//Methode 1
Funktion method1()
{
var result = "";
var totle = parseInt(document.getElementById("totle").value);
var n = new Date().getTime();
for(var i=0; i<totle; i++)
{
Ergebnis += str;
}
document.getElementById("show").value = result;
var s = „String-Spleißmethode: die Länge der großen Zeichenfolge nach dem Spleißen“+ result.length +“bytes,“+
„Splicing braucht Zeit“ + (new Date().getTime()-n) + „Millisekunden!“;
document.getElementById("method1").innerHTML = s;
}
//Methode 2
Funktion method2()
{
var result = "";
var totle = parseInt(document.getElementById("totle").value);
var n = new Date().getTime();
var a = new Array();
for(var i=0; i<totle; i++)
{
a[i] = str;
}
result = a.join(""); a=null;
document.getElementById("show").value = result;
var s = „Array-Zuweisungs-Join-Methode: die Länge der großen Zeichenfolge nach dem Spleißen“+ result.length +“bytes,“+
„Splicing braucht Zeit“ + (new Date().getTime()-n) + „Millisekunden!“;
document.getElementById("method2").innerHTML = s;
}
//-->
</SCRIPT>
Lassen Sie mich abschließend noch ein paar Worte sagen: Wird Array-Join in Zukunft zum String-Spleißen verwendet? Dies hängt von Ihren tatsächlichen Anforderungen ab. Für gewöhnliche Kombinationen von wenigen oder K-Level-Bytes ist die Verwendung der Array-Methode nicht erforderlich, da das Öffnen von Array-Variablen ebenfalls teuer ist. Wenn mehr als ein paar K-String-Kombinationen vorhanden sind, ist die Effizienz des Arrays hoch.
-------------------------------------------------- ----------
IE 6.0:
String-Spleißmethode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 22.089 Millisekunden!
Array-Zuweisungs-Join-Methode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 218 Millisekunden!
Firefox 1.0:
String-Spleißmethode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 1.044 Millisekunden!
Array-Zuweisungs-Join-Methode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 1.044 Millisekunden!
Mozilla 1.7:
String-Spleißmethode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 1.045 Millisekunden!
Array-Zuweisungs-Join-Methode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 1.044 Millisekunden!
Netscape 7.0:
String-Spleißmethode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 10.273 Millisekunden!
Array-Zuweisungs-Join-Methode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 1.138 Millisekunden!
Opera 7.54:
String-Spleißmethode: Die gespleißte große Zeichenfolge ist 1.010.000 Bytes lang und das Spleißen dauert 6.968 Millisekunden!
Array-Zuweisungs-Join-Methode: Die gespleißte große Zeichenfolge ist 1010000 Bytes lang und das Spleißen dauert 6922 Millisekunden!
Die Testergebnisse der 10.000-maligen Schleife zeigen, dass die Effizienz in IE und Netscape erheblich verbessert werden kann, während der Zeitverbrauch der beiden Methoden in Firefox Mozilla Opera im Wesentlichen ähnlich ist. Diese Daten reichen aus, um festzustellen, dass die Array-Join-Methode besser ist traditionelles Saitenspleißen.