Kürzlich gibt es in der Studie von "JavaScript Advanced Programing" eine Beschreibung der Eigenschaften von Saiten. Der ursprüngliche Text ist ungefähr wie folgt: Zeichenfolgen in ECMAScript sind unveränderlich, dh nach Erstellen von Zeichenfolgen können ihre Werte nicht geändert werden. Um die gespeicherte Zeichenfolge einer Variablen zu ändern, zerstören Sie zuerst die ursprüngliche Zeichenfolge und füllen Sie dann die Variable mit einer anderen Zeichenfolge, die den neuen Wert enthält, zum Beispiel:
Die Codekopie lautet wie folgt:
var lang = "java";
Lang = Lang + "Skript";
Der Prozess der Implementierung dieses Vorgangs ist wie folgt: Erstellen Sie zuerst eine neue Zeichenfolge mit 10 Zeichen und füllen Sie ihn dann mit "Java" und "Skript" in dieser Zeichenfolge. Der letzte Schritt besteht darin, die ursprünglichen Saiten "Java" und "Skript" zu zerstören, da diese beiden Saiten nutzlos sind. In niedrigeren Versionen von Browsern (z. B. IE6) ist die String-Spleißgeschwindigkeit jedoch ein leistungssteigernder Prozess.
Daraus denke ich an Java. Der String -Mechanismus in Java ähnelt JS (dh nach der Erstellung kann er nicht geändert werden, und es kann nur den ursprünglichen Wert zerstören), aber Java hat einen StringBuffer, der das Problem der Unveränderlichkeit von String löst, und JS hat keine ähnliche Methode. Aber wir können diesen Puffermechanismus simulieren. Das Prinzip besteht darin, Arrays zum Spleißen zu verwenden. Der Quellcode lautet wie folgt:
Die Codekopie lautet wie folgt:
Funktion StringBuffer () {
Dies .__ Strings__ = New Array ();
}
StringBuffer.prototype.append = function (str) {
diese .__ Saiten __. Push (str);
gib dies zurück; // bequemer Kettenbetrieb
}
StringBuffer.Prototype.toString = function () {
Geben Sie diese zurück .__ Saiten __. Join ("");
}
/*prüfen*/
var buffer = new StringBuffer ();
Buffer.Append ("Hallo"). append ("javaScript");
var result = buffer.toString ();
Alarm (Ergebnis);
PS: GIST -Adresse laut
Wir haben den Mechanismus simuliert, aber es gibt einen Unterschied in der Leistung zwischen dieser Methode und dem Stringspleißen. Wir können es testen und der Testcode lautet wie folgt:
Die Codekopie lautet wie folgt:
var d1 = neues Datum ();
var str = "";
für (var i = 0; i <10000; i ++) {
str += "text";
}
var d2 = neues Datum ();
document.write ("Einen Kosten testen:" + (d2.getTime () - d1.getTime ())/1000 + "Sekunden" + "<br/>");
var Obuffer = new StringBuffer ();
D3 = neues Datum ();
für (var i = 0; i <10000; i ++) {
Obuffer.Append ("Text");
}
var sresult = obuffer.toString ();
D4 = neues Datum ();
document.write ("Testen Sie zwei Kosten:" + (d4.getTime () - d3.getTime ())/1000 + "Sekunden");
Die Testergebnisse sind wie folgt: (Die Testergebnisse können in verschiedenen Umgebungen unterschiedlich sein):
1. Beim Vergleich von 1000 -mal als Basis ist die Ausführung von beiden sehr schnell (grundlegende Millisekunden) und dauert ungefähr zur gleichen Zeit. Der letztere Unterschied zwischen den ersteren wird 10 Millisekunden nicht überschreiten.
2. Mit 10.000 Mal als Basis ähnelt das Ausführungsergebnis dem oben genannten, aber ersterer hat mehr Telefonrechnungen unter dem IE6.
3. Mit 100.000 Mal als Basis dauert das String -Spleißen in IE6 offensichtlich mehr Zeit, und andere Browser sind nicht viel unterschiedlich, und einige sind kürzer als Stringbuffer.
abschließend
1. Wenn die Anzahl der Spleißwörter weniger als 1.000 Mal beträgt, verwenden Sie mutig die ersteren, und wir begegnen selten Tausende von Spleißzeiten.
2. Andere Browser haben keine Leistungsprobleme beim Spleißen, hauptsächlich IE6. Wenn die Spleißzeiten Zehntausende oder Hunderttausende kosten, wird empfohlen, StringBuffer zu verwenden, um IE6 allein zu simulieren.