Au cours du processus de développement du script, une grande chaîne est souvent combinée et épissée pour être sortie selon une certaine règle. Par exemple, lors de l'écriture d'un contrôle de script, la sortie de la balise HTML qui contrôle l'apparence de l'ensemble du contrôle, ou lors de l'analyse et de la création dynamiques de balises HTML après avoir obtenu la valeur de retour côté serveur en AJAX, mais je ne discuterai pas de l'application spécifique de épissage des chaînes ici. Je veux juste discuter de l'efficacité de l'épissage ici.
Lorsque nous écrivons l'épissage de chaînes, nous utilisons toujours l'opérateur "+=", s += String ; C'est la méthode d'écriture la plus familière. Je ne sais pas si vous avez remarqué que la capacité de la chaîne combinée est lorsque le nombre est. des dizaines voire des centaines de K, l'exécution du script est très lente et l'utilisation du processeur est extrêmement élevée, par exemple :
var str = "01234567891123456789212345678931234567894123456789" ;
str+= "51234567896123456789712345678981234567899123456789n";
var résultat = "";
for(var i=0; i<2000; i++) result += str;
En une seule étape, la chaîne de résultat est de 200 Ko, cela prend 1,1 seconde (cela est lié à la configuration de l'ordinateur) et la valeur maximale du processeur est de 100. %. (Afin de voir l'effet de manière plus intuitive, j'ai fait quelques boucles supplémentaires). Il est concevable qu'une telle étape d'opération consomme plus d'une seconde de mon temps. Couplée à la consommation de temps d'autres codes, le temps d'exécution de l'ensemble du bloc de script devient insupportable. Existe-t-il une solution d'optimisation ? Y a-t-il un autre moyen ? La réponse est bien sûr oui, sinon cela n’aurait aucun sens de ma part d’écrire cet article.
Le moyen le plus rapide consiste à utiliser un tableau lors de l'épissage dans une boucle, au lieu de l'épisser en une chaîne, la chaîne est placée dans un tableau, et enfin array.join("") est utilisé pour obtenir l'exemple de code de chaîne résultante. :
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n";
var résultat = "", a = new Array();
pour(var i=0; i<2000; i++) a[i] = str;
result = a.join(""); a = null;
Vous pouvez tester le temps nécessaire pour combiner une chaîne de même taille. Le résultat que j'ai testé ici est : <15 millisecondes. ce qui signifie que pour assembler une telle chaîne de 200K, la consommation de temps des deux modes est de près de deux ordres de grandeur. qu'est-ce que cela signifie? Cela signifie que ce dernier a fini de travailler et est revenu du déjeuner, tandis que le premier travaille toujours dur. J'ai écrit une page de test. Vous pouvez copier le code suivant et l'enregistrer en tant que fichier HTM et l'ouvrir sur la page Web pour tester la différence d'efficacité entre les deux. Quoi qu'il en soit, ce que j'ai testé, c'est que le premier prend une demi-minute. , et ce dernier Ou cela peut être fait en 0,07 seconde (boucle 10 000 fois).
<corps>
Nombre de concaténations de chaînes<input id="totle" value="1000" size="5" maxlength="5">
<input type="button" value="Méthode d'épissage de chaîne" onclick="method1()">
<input type="button" value="Méthode de jointure d'affectation de tableau" onclick="method2()"><br>
<div id="method1"> </div>
<div id="method2"> </div>
<textarea id="show" style="largeur : 100 % ; hauteur : 400"></textarea>
<LANGUE SCRIPT="JavaScript">
<!--
//La longueur de cette chaîne épissée est de 100 octets auteur : meizz
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n"
//Méthode 1
fonction méthode1()
{
var résultat = "";
var totle = parseInt(document.getElementById("totle").value);
var n = new Date().getTime();
for(var i=0; i<totle; i++)
{
résultat += chaîne ;
}
document.getElementById("show").value = result;
var s = "Méthode d'épissage de chaîne : la longueur de la grande chaîne après l'épissage"+ result.length +"bytes,"+
"L'épissage prend du temps" + (new Date().getTime()-n) + "Millisecondes !";
document.getElementById("method1").innerHTML = s;
}
//Méthode 2
fonction méthode2()
{
var résultat = "";
var totle = parseInt(document.getElementById("totle").value);
var n = new Date().getTime();
var a = new Array();
pour(var i=0; i<total; i++)
{
a[i] = chaîne ;
}
result = a.join(""); a=null;
document.getElementById("show").value = result;
var s = "Méthode de jointure d'affectation de tableau : la longueur de la grande chaîne après l'épissage"+ result.length +"bytes,"+
"L'épissage prend du temps" + (new Date().getTime()-n) + "Millisecondes !";
document.getElementById("method2").innerHTML = s;
}
//-->
</SCRIPT>
Enfin, permettez-moi de dire quelques mots. La jointure de tableau sera-t-elle utilisée pour l'épissage de chaînes à l'avenir ? Cela dépend de vos besoins réels. Pour les combinaisons ordinaires de quelques octets ou de niveau K, il n'est pas nécessaire d'utiliser la méthode du tableau, car l'ouverture des variables du tableau est également coûteuse. S'il existe plusieurs combinaisons de chaînes K, l'efficacité du réseau est élevée.
-------------------------------------------------- ----------
IE 6.0 :
Méthode d'épissage de chaîne : la grande chaîne épissée mesure 1 010 000 octets et l'épissage prend 22 089 millisecondes !
Méthode de jointure d'affectation de tableau : la grande chaîne épissée mesure 1 010 000 octets de long et l'épissage prend 218 millisecondes !
Firefox 1.0 :
Méthode d'épissage de chaîne : la grande chaîne épissée mesure 1 010 000 octets de long et l'épissage prend 1 044 millisecondes !
Méthode de jointure d'affectation de tableau : la grande chaîne épissée mesure 1 010 000 octets de long et l'épissage prend 1 044 millisecondes !
Mozilla 1.7 :
Méthode d'épissage de chaîne : la grande chaîne épissée mesure 1 010 000 octets de long et l'épissage prend 1 045 millisecondes !
Méthode de jointure d'affectation de tableau : la grande chaîne épissée mesure 1 010 000 octets de long et l'épissage prend 1 044 millisecondes !
Netscape 7.0 :
Méthode d'épissage de chaîne : la grande chaîne épissée mesure 1 010 000 octets et l'épissage prend 10 273 millisecondes !
Méthode de jointure d'affectation de tableau : la grande chaîne épissée mesure 1 010 000 octets de long et l'épissage prend 1 138 millisecondes !
Opéra 7.54 :
Méthode d'épissage de chaîne : la grande chaîne épissée mesure 1 010 000 octets et l'épissage prend 6 968 millisecondes !
Méthode de jointure d'affectation de tableau : la grande chaîne épissée mesure 1 010 000 octets et l'épissage prend 6 922 millisecondes !
Les résultats des tests de bouclage 10 000 fois montrent que l'efficacité peut être considérablement améliorée dans IE et Netscape, tandis que la consommation de temps des deux méthodes dans Firefox Mozilla Opera est fondamentalement similaire. Ces données sont suffisantes pour déterminer que la méthode de jointure de tableau est meilleure que. épissage de cordes traditionnel.