Die Effizienz von JavaScript beim Schleifen von Arrays mit großer Kapazität ist unbefriedigend. Im Vergleich zu VBS-Arrays ist die Array-Loop-Geschwindigkeit von VBS ungefähr eine Größenordnung schneller als die von JS ( http://community.csdn.net/Expert/TopicView. asp?id=4313487 ). Wir schenken der Effizienz von JS-Arrays in der allgemeinen Programmierung nicht viel Aufmerksamkeit: Man kann nicht einmal die Effizienz eines Arrays mit nur ein paar Dutzend Elementen sagen, aber die Anzahl der Knoten ist groß, beispielsweise Tausende oder Zehntausende Wenn eine große Anzahl von Array-Schleifen verwendet wird, ist das Problem der Effizienz das Hauptproblem, das berücksichtigt werden muss. Das Abrufen von Arrays mit großer Kapazität hat im Allgemeinen die folgenden Anwendungen: schnelles Matching bei der Auswahl von Kombinationsfeldern, Baumabfragen, Tabellensortierung oder -abruf usw.
Lassen Sie mich einen Test durchführen. Zuerst erstelle ich ein Array mit großer Kapazität:
<SCRIPT LANGUAGE="JavaScript">
var n = 100000; //Die maximale Kapazität des Arrays
var a = new Array();
for(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
</SCRIPT>
Auf diese Weise habe ich ein Zeichenarray mit einer Länge von 100.000 erstellt und dann die Zeichenfolge ab 0,9999 abgerufen und in einem anderen Array gespeichert.
<SCRIPT LANGUAGE="JavaScript">
var n = 100000; //Die maximale Kapazität des Arrays
var a = new Array();
for(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
var begin = new Date().getTime();
var b = new Array();
for(var i=0; i<n; i++)
{
if(a[i].indexOf("0.9999")==0)
{
b[b.length] = a[i];
}
}
document.write("Array-Länge: "+ n);
document.write("<br>Traditionelle Schleifenmethode braucht Zeit" + (new Date().getTime() - begin)
+" Millisekunden! Abrufergebnisse: <strong title='"+ b.join(" ")
+"'>Retrieved „+ b.length +“ Datensätze!</strong>");
</SCRIPT>
Dieser Operationsschritt dauert hier etwa 2800 Millisekunden. Es gibt nur eine if-Beurteilung und eine Zuweisungsoperation. Es wird mehr Zeit in Anspruch nehmen, es wird eine Steigerung um eine Größenordnung sein. Gibt es also gute Optimierungslösungen für dieses Problem? Die Antwort ist natürlich ja, sonst wäre alles, was ich in diesem Beitrag sagen würde, eine Wortverschwendung. Aber wir können unser traditionelles Denken nicht mehr nutzen, um dieses Problem zu optimieren, weil es im traditionellen Denken keine bessere Schreibweise gibt.
Die Lösung besteht darin, zuerst das Array in eine große Zeichenfolge zu verknüpfen () und dann reguläre Ausdrücke zu verwenden, um die große Zeichenfolge abzugleichen und abzurufen. Diese Methode kann als meine persönliche Originalität angesehen werden. Ich habe mir beim Schreiben von Bäumen einen krummen Trick ausgedacht, aber die Effizienz ist wirklich nicht schlecht. Ich habe die Effizienz von join() bereits besprochen ( http://blog.csdn.net/meizz/archive/2005/12/14/552260.aspx JavaScript Speed: The Efficiency of Combining and Splicing Strings). Dieser Optimierungsplan erfordert ein gewisses Maß an Fähigkeiten im Bereich regulärer Ausdrücke.
<input id="count" value="50000" size="7" maxlength="6">
<input type="button" value="Array Initial Hua" onclick="txt.innerHTML = array_init()"><br>
<input type="button" value="Traditionelle Schleife" onclick="txt.innerHTML += method_for()">
<input type="button" value="Regular Matching" onclick="txt.innerHTML += method_regexp()">
<div id="txt"></div>
<SCRIPT LANGUAGE="JavaScript">
var txt = document.getElementById("txt");
var a = new Array();
function array_init()
{
var n = parseInt(document.getElementById("count").value);
a.length = 0;
for(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
return „Array-Länge: „+ n;
}
Funktion method_for()
{
var n = a.length;
var begin = new Date().getTime();
var b = new Array();
for(var i=0; i<n; i++)
{
if(a[i].indexOf("0.9999")==0)
{
b[b.length] = a[i];
}
}
return ("<br>Traditionelle Schleifenmethode braucht Zeit" + (new Date().getTime() - begin)
+" Millisekunden! Abrufergebnisse: <strong title='"+ b.join(" ")
+"'>Retrieved „+ b.length +“ Datensätze!</strong>");
}
Funktion method_regexp()
{
var begin = new Date().getTime();
var b = new Array();
var s = a.join("x0f");
var r = new RegExp().compile("0\.9999\d+", "g");
b = s.match(r); s = "";
return ("<br>Reguläre Matching-Methode braucht Zeit" + (new Date().getTime() - begin)
+" Millisekunden! Abrufergebnisse: <strong title='"+ b.join(" ")
+"'>Retrieved „+ b.length +“ Datensätze!</strong>");
}
</SCRIPT>
Sie können es testen, um zu sehen, wie groß der Effizienzunterschied zwischen den beiden oben genannten Methoden ist! Code ist tot, Menschen leben. Wenn Sie Ihre Denkweise oder Ihr Modell ändern, wird die Effizienz ganz anders sein.
Es hat mich sehr viel Köpfchen gekostet, sich diesen Trick auszudenken, und jetzt möchte ich ihn nur ungern teilen, um allen zum Beginn des neuen Jahres 2006 zu gratulieren.