L'efficacité de JavaScript dans la mise en boucle de tableaux de grande capacité n'est pas satisfaisante. J'ai déjà fait une comparaison avec les tableaux VBS, la vitesse de boucle du tableau VBS est à peu près un ordre de grandeur plus rapide que celle de JS ( http://community.csdn.net /Expert/TopicView. asp?id=4313487 ). Nous ne prêtons pas beaucoup d'attention à l'efficacité des tableaux JS dans la programmation générale : vous ne pouvez même pas déterminer l'efficacité d'un tableau avec seulement quelques dizaines d'éléments, mais le nombre de nœuds est grand, comme des milliers ou des dizaines de milliers. de nœuds. Si un grand nombre de boucles de tableau sont utilisées, le problème d'efficacité devient le principal problème à prendre en compte. La récupération de tableaux de grande capacité a généralement les applications suivantes : correspondance rapide lors de la sélection de combos, requêtes arborescentes, tri ou récupération de tables, etc.
Laissez-moi faire un test. Tout d'abord, je crée un tableau de grande capacité :
<SCRIPT LANGUAGE="JavaScript">.
var n = 100000; //La capacité maximale du tableau
var a = nouveau tableau ();
pour(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
</SCRIPT>
De cette façon, j'ai créé un tableau de caractères d'une longueur de 100 000, puis j'ai récupéré la chaîne commençant par 0,9999 et l'ai stockée dans un autre tableau.
<LANGUE SCRIPT="JavaScript">
var n = 100000; //La capacité maximale du tableau
var a = nouveau tableau ();
pour(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
var start = new Date().getTime();
var b = nouveau tableau ();
pour(var i=0; i<n; i++)
{
si(a[i].indexOf("0.9999")==0)
{
b[b.longueur] = a[i];
}
}
document.write("Longueur du tableau : "+ n);
document.write("<br>La méthode de boucle traditionnelle prend du temps" + (new Date().getTime() - start)
+" millisecondes ! Résultats de la récupération : <strong title=""+ b.join(" ")
+"'>Enregistrements "+ b.length +" récupérés !</strong>");
</SCRIPT>
Cette étape de l'opération prend ici environ 2800 millisecondes. Pour expliquer, la boucle ici est très simple. Il n'y a qu'un jugement if et une opération d'affectation. Si le jugement ici est un peu plus compliqué, cela prendra plus de temps et ce sera une augmentation d'un ordre de grandeur. Alors, existe-t-il de bonnes solutions d'optimisation pour ce problème ? La réponse est bien sûr oui, sinon tout ce que je dirais dans ce post serait un gaspillage de mots. Mais nous ne pouvons plus utiliser notre pensée traditionnelle pour optimiser ce problème, car aucune meilleure façon d’écrire ne peut être trouvée dans la pensée traditionnelle.
La solution est la suivante : commencez par join() le tableau dans une grande chaîne, puis utilisez des expressions régulières pour faire correspondre et récupérer la grande chaîne. Cette méthode peut être considérée comme mon originalité personnelle. J'ai trouvé une astuce tordue pendant le processus d'écriture des arbres, mais l'efficacité n'est vraiment pas mauvaise. J'ai déjà discuté de l'efficacité de join() ( http://blog.csdn.net/meizz/archive/2005/12/14/552260.aspx Vitesse JavaScript : l'efficacité de la combinaison et de l'épissage des chaînes). Ce plan d'optimisation nécessite un certain niveau de compétences en expressions régulières.
<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="Boucle traditionnelle" onclick="txt.innerHTML += method_for()">
<input type="button" value="Correspondance régulière" onclick="txt.innerHTML += method_regexp()">
<div id="txt"></div>
<SCRIPT LANGUAGE="JavaScript">
var txt = document.getElementById("txt");
var a = nouveau tableau();
fonction array_init()
{
var n = parseInt(document.getElementById("count").value);
a.longueur = 0 ;
pour(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
return "longueur du tableau : "+ n ;
}
fonction méthode_for()
{
var n = a.longueur;
var start = new Date().getTime();
var b = nouveau tableau ();
pour(var i=0; i<n; i++)
{
si(a[i].indexOf("0.9999")==0)
{
b[b.longueur] = a[i];
}
}
return ("<br>La méthode de boucle traditionnelle prend du temps" + (new Date().getTime() - start)
+" millisecondes ! Résultats de la récupération : <strong title=""+ b.join(" ")
+"'>Enregistrements "+ b.length +" récupérés !</strong>");
}
fonction méthode_regexp()
{
var start = new Date().getTime();
var b = nouveau tableau ();
var s = a.join("x0f");
var r = new RegExp().compile("0\.9999\d+", "g");
b = s.match(r); s = "";
return ("<br>La méthode de correspondance régulière prend du temps" + (new Date().getTime() - start)
+" millisecondes ! Résultats de la récupération : <strong title=""+ b.join(" ")
+"'>Enregistrements "+ b.length +" récupérés !</strong>");
}
</SCRIPT>
Vous pouvez le tester pour voir quelle est la différence d'efficacité entre les deux méthodes ci-dessus ! Le code est mort, les gens sont vivants. Si vous changez de façon de penser ou de modèle, l’efficacité sera très différente.
Il m’a fallu beaucoup d’intelligence pour trouver cette astuce, et je suis vraiment réticent à la partager. Je vais maintenant l’utiliser pour féliciter tout le monde pour le début de la nouvelle année 2006.