Ausführliche Erklärung der Zeichenfolgenverkettung in den Javascript-Kenntnissen

Kürzlich gab es beim Studium von „Javascript Advanced Programming“ eine Beschreibung der Eigenschaften von Strings. Der Originaltext lautet ungefähr wie folgt: Strings in ECMAScript sind unveränderlich, das heißt, sobald Strings erstellt wurden, sind ihre Werte ​​​sind nicht veränderbar. Um die in einer Variablen gespeicherte Zeichenfolge zu ändern, zerstören Sie zunächst die ursprüngliche Zeichenfolge und füllen Sie die Variable dann mit einer anderen Zeichenfolge, die den neuen Wert enthält, zum Beispiel:

Code kopieren Der Code lautet wie folgt:

var lang = "Java";
lang = lang "Skript";

Der Prozess zur Implementierung dieser Operation ist wie folgt: Erstellen Sie zunächst eine neue Zeichenfolge, die 10 Zeichen enthalten kann, füllen Sie diese Zeichenfolge dann mit „Java“ und „Script“ und zerstören Sie im letzten Schritt die ursprüngliche Zeichenfolge „Java“. und „Script“, da diese beiden Zeichenfolgen nicht mehr nützlich sind. In Browsern niedrigerer Versionen (z. B. IE6) ist die Geschwindigkeit der Zeichenfolgenverkettung jedoch ein sehr leistungsintensiver Prozess.

Das erinnert mich an Java. Der String-Mechanismus in Java ähnelt dem von js (das heißt, er kann nicht geändert werden, sobald er erstellt wurde, und der ursprüngliche Wert kann nur zerstört werden, wenn Sie ihn ändern möchten). verfügt über einen StringBuffer, um das Problem der String-Unfähigkeit zu lösen. Das Problem besteht darin, dass es in js keine ähnliche Methode gibt. Aber wir können diesen Puffermechanismus simulieren. Das Prinzip besteht darin, Arrays zum Spleißen zu verwenden. Der Quellcode lautet wie folgt:

Code kopieren Der Code lautet wie folgt:

Funktion StringBuffer() {
This.__strings__ = new Array();
}
StringBuffer.prototype.append = Funktion (str) {
This.__strings__.push(str);
Return this; //Bequemer Kettenbetrieb
}
StringBuffer.prototype.toString = function () {
Geben Sie this.__strings__.join("");
zurück }

/*Test*/
var buffer = new StringBuffer();
buffer.append("Hallo").append("javascript");

var result = buffer.toString();
Warnung(Ergebnis);

ps: Die Hauptadresse lautet wie folgt: https://gist.github.com/hehongwei44/fe71f10e4d2d9295aeab

Wir haben den Mechanismus simuliert, aber wie unterschiedlich ist die Leistung dieser Methode vom String-Splicing? Wir können ihn wie folgt testen:

Code kopieren Der Code lautet wie folgt:

var d1 = neues Datum();
var str = "";
for(var i = 0; i < 10000; i ){
str = "text ";
}
var d2 = neues Datum();
document.write("Einen Kostentest: " (d2.getTime() - d1.getTime())/1000 "seconds" "
");

var oBuffer = new StringBuffer();
d3 = neues Datum();
for(var i = 0; i < 10000; i ){
oBuffer.append("text ");
}
var sResult = oBuffer.toString();
d4 = neues Datum();
document.write("Test 2 cost: " (d4.getTime() - d3.getTime())/1000 "seconds");

Die Testergebnisse lauten wie folgt: (Die Testergebnisse können je nach Umgebung unterschiedlich sein):

1. Basierend auf einem Vergleich von 1000 Malen sind die beiden Ausführungen sehr schnell (im Grunde ein paar Millisekunden) und der Zeitverbrauch ist ähnlich. Der Unterschied zwischen letzterem und ersterem wird 10 Millisekunden nicht überschreiten.
2. Mit dem 10.000-fachen als Basis sind die Ausführungsergebnisse ähnlich wie oben, für ersteres fallen jedoch unter IE6 höhere Anrufgebühren an.
3. Wenn man 100.000 Mal als Basis verwendet, dauert das Spleißen von Zeichenfolgen unter IE6 offensichtlich länger. Andere Browser sind nicht viel anders und einige sind kürzer als StringBuffer.

Fazit

1. Wenn die Anzahl der verbundenen Wörter weniger als 1.000 beträgt, verwenden Sie mutig das erstere. Im Allgemeinen stoßen wir selten auf Situationen, in denen die Anzahl der verbundenen Wörter Tausende beträgt.
2. Andere Browser haben keine Leistungsprobleme beim Spleißen, hauptsächlich IE6. Wenn die Anzahl der Spleißen Zehntausende oder Hunderttausende beträgt, wird empfohlen, die StringBuffer-Simulation nur für IE6 zu verwenden.