Während der Arbeit stoßen Sie häufig auf das Problem der Verkettung von 2 oder mehr Stringen in eine Zeichenfolge. Es gibt im Allgemeinen drei Möglichkeiten, mit dieser Art von Problem in JS umzugehen. Hier sind die Liste von ihnen nacheinander und vergleiche ihre Leistung.
Die erste Methode verwendet den Anschluss "+", um die angeschlossene Zeichenfolge zu verbinden:
str = "a"; str+= "b";
Es besteht kein Zweifel, dass diese Methode die bequemste und schnellste ist. Wenn Sie nur weniger als 100 Zeichenfolgen anschließen, wird empfohlen, diese Methode zu verwenden.
Die zweite Methode verwendet ein Array als Vermittler, um die Zeichenfolge mit Join zu verbinden:
var arr = new array (); arr.push (a); arr.push (b); var str = arr.join ("");Die W3School -Website führt vor, dass diese Methode weniger Ressourcen verbraucht als die erste und schneller. Wir werden später überprüfen, ob dies durch Experimente der Fall ist.
Die dritte Methode verwendet Objekteigenschaften, um Zeichenfolgen zu verbinden
function stringconnect () {this._str_ = new Array ();} StringConnect.Prototype.Append = Funktion (a) {this._str_.push (a);} stringconnect.prototype.toString = function () {return this.str_.str_.join (); mystr.append ("a"); var str = mystr.toString ();Verwenden Sie den folgenden Code, um die Leistung der drei Methoden zu vergleichen und die Anzahl der Verbindungszeichenfolgen anzupassen, indem Sie den Wert von C ändern:
var str = ""; var d1, d2; var c = 5000; // Anzahl der Verbindung Saiten // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mystr.append ("a"); } str = mystr.toString (); D2 = neues Datum (); console.log (d2.getTime ()-d1.getTime ()); // -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Date (); console.log (d2.getTime ()-d1.getime ()); // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Ich stellte C auf 5000, 50000, 500000 bzw. 50000000 ein. Jeder Wert wurde 10 -mal gemessen, und das Endergebnis war wie folgt:
C = 5000
Durchschnittszeit in Millisekunden
Der dritte Typ 3 2 2 3 1 2 2 1 1 1 1 1,8
Der zweite Typ 1 3 0 3 1 3 4 1 4 2 2.2
Der erste Typ 0 0 0 0 0 1 1 1 1 1 1 0.5
C = 50000
Der dritte Typ 22 12 9 14 12 13 13 13 10 17 13,5
Der zweite Typ 8 13 12 8 11 11 8 9 8 9 9,7
Der erste Typ 7 12 5 11 10 10 10 13 16 12 10.6
C = 500000
Der dritte Typ 104 70 74 69 76 77 69 102 73 73 78.7
Der zweite Typ 78 100 99 99 100 98 96 71 94 97 93.2
Der erste Typ 90 87 83 85 85 83 84 83 88 86 85.4
C = 5000000
Der dritte Typ 651 871 465 444 1012 436 787 449 432 444 599.1
Der zweite Typ 568 842 593 747 417 747 719 549 573 563 631.8
Der erste Typ 516 279 616 161 466 416 201 495 510 515 417.5
Beim Zählen von 5000000 werden zufällige Parameter in die Adressleiste hinzugefügt, die die Auswirkungen von Cache vermeiden sollte. Nach den Ergebnissen zu urteilen, verbraucht die erste Methode nicht mehr als die beiden anderen Methoden, und es ist noch vorteilhafter, was offensichtlich mit den Anweisungen im Handbuch unvereinbar ist.
Testsystem: Gewinnen Sie 7 Flaggschiff
Browser: Chrom 52.0.2739.0 m
In dem obigen Artikel werden die drei String -Verbindungsmethoden und Leistungsvergleiche in JS kurz erläutert, die alle Inhalte sind, die ich mit Ihnen teile. Ich hoffe, Sie können Ihnen eine Referenz geben und ich hoffe, Sie können wulin.com mehr unterstützen.