Pendant le développement du script, une grande chaîne est souvent combinée et épissée en une grande chaîne pour la sortie en fonction d'une certaine règle. Par exemple, lors de l'écriture de contrôles de script, la sortie des balises HTML qui contrôlent l'apparence de l'ensemble du contrôle. Par exemple, lors de l'analyse dynamiquement des balises HTML après avoir obtenu la valeur arrière côté serveur dans AJAX, je ne discuterai pas de l'application spécifique des chaînes d'épissage ici. Je veux juste discuter de l'efficacité de l'épissage ici.
Lorsque nous écrivons du code, nous utilisons l'opérateur "+ =", S + = String; C'est la façon la plus familière d'écrire. Je me demande si vous l'avez remarqué. Lorsque la capacité de chaîne combinée est de dizaines de K ou même des centaines de K, le script est très lent à exécuter et le taux d'utilisation du processeur est très élevé, par exemple:
La copie de code est la suivante:
var str = "01234567891123456789212345678931234567894123456789";
str + = "51234567896123456789712345678981234567899123456789 / n";
var result = "";
pour (var i = 0; i <2000; i ++) résultat + = str;
En une seule étape, la chaîne de résultats générée est de 200k, ce qui prend 1,1 seconde (ceci est lié à la configuration de l'ordinateur), et le pic du CPU est de 100%. (J'ai fait plus de boucles pour voir l'effet plus intuitivement). On peut imaginer qu'une seule étape d'opération m'a pris plus d'une seconde et, associée au temps passé sur d'autres codes, le temps d'exécution de l'ensemble du bloc de script serait insupportable. Y a-t-il donc une solution d'optimisation? Y a-t-il une autre façon? Bien sûr, il y a une réponse, sinon je serais absurde d'écrire cet article.
Un moyen plus rapide consiste à utiliser un tableau. Lors de la diffusion de boucles, il ne s'agit pas de l'épisser dans une certaine chaîne, mais de mettre la chaîne dans un tableau, et enfin d'utiliser le tableau.join ("") pour obtenir la chaîne de résultats. Exemple de code:
La copie de code est la suivante:
var str = "01234567891123456789212345678931234567894123456789";
str + = "51234567896123456789712345678981234567899123456789 / n";
var result = "", a = new Array ();
pour (var i = 0; i <2000; i ++) a [i] = str;
résultat = a.join (""); a = null;
Vous pouvez tester et tester le temps nécessaire pour combiner une chaîne de la même taille. Le résultat que j'ai testé ici est: <15 millisecondes. Veuillez noter que son unité est une milliseconde. C'est-à-dire, combinant une telle chaîne de 200K, la consommation temporelle des deux modes est d'environ deux ordres de grandeur. qu'est-ce que cela signifie? Cela signifie que le second a terminé son travail et est revenu du déjeuner, tandis que le premier travaille toujours comme coolie. J'écrirai 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, je teste le premier qui prend une demi-minute pour terminer, et le second qui prend 0,07 seconde (10 000 boucles).
La copie de code est la suivante:
<body>
Nombre de temps d'épissage de chaîne <ID Input = "totle" value = "1000" size = "5" maxLength = "5">
<entrée type = "Button" Value = "String Splicing Method" onClick = "Method1 ()">
<input type = "Button" value = "Array Affectation Join Method" onClick = "Method2 ()"> <br>
<div id = "Method1"> </div>
<div id = "Method2"> </div>
<textArea id = "show"> </ textarea>
<Script linguisse = "javascript">
<! -
// La longueur de cette chaîne en cours d'épissage est de 100 octets Auteur: Meizz
var str = "01234567891123456789212345678931234567894123456789";
str + = "51234567896123456789712345678981234567899123456789 / n";
// Méthode 1
Fonction Method1 ()
{
var result = "";
var totle = parseInt (document.getElementById ("totle"). valeur);
var n = new Date (). getTime ();
pour (var i = 0; i <totle; i ++)
{
Résultat + = str;
}
document.getElementById ("Show"). Value = result;
var s = "String Splicing Method: la grande chaîne épissée est longue" + result.length + "byte," +
"Split Time" + (new Date (). GetTime () - n) + "millisecondes!";
document.getElementById ("Method1"). InnerHtml = S;
}
// Méthode 2
Fonction Method2 ()
{
var result = "";
var totle = parseInt (document.getElementById ("totle"). valeur);
var n = new Date (). getTime ();
var a = nouveau array ();
pour (var i = 0; i <totle; i ++)
{
a [i] = str;
}
résultat = a.join (""); a = null;
document.getElementById ("Show"). Value = result;
var s = "Méthode de jointure d'affectation de tableau: la grande chaîne épissée est longue" + result.length + "byte," +
"Split Time" + (new Date (). GetTime () - n) + "millisecondes!";
document.getElementById ("Method2"). InnerHtml = s;
}
// ->
</cript>
Enfin, je dirai quelques mots supplémentaires. Tous les épissements de chaînes utiliseront-ils des jointures à tableau à l'avenir? Cela dépend de vos besoins réels. Il n'est pas nécessaire d'utiliser la méthode du tableau pour des combinaisons ordinaires de plusieurs octets de niveau K, car les variables d'ouverture du tableau sont également consommées. S'il y a plus de quelques combinaisons de chaînes K, cela signifie que le tableau est efficace.
IE 6.0:
Méthode d'épissage de chaîne: la grande chaîne épissée mesure 1010 000 octets de long, et l'épissage prend 22 089 millisecondes!
Méthode de jointure d'attribution du tableau: La grande chaîne épissée mesure 1010 000 octets de long, et il faut 218 millisecondes pour épisser!
Firefox 1.0:
Méthode d'épissage de chaîne: la grande chaîne épissée mesure 1010 000 octets de long, et l'épissage prend 1044 millisecondes!
Méthode de jointure d'attribution du tableau: La grande chaîne épissée mesure 1010 000 octets de long et l'épissage prend 1044 millisecondes!
Mozilla 1.7:
Méthode d'épissage de chaîne: la grande chaîne épissée mesure 1010 000 octets de long, et l'épissage prend 1045 millisecondes!
Méthode de jointure d'attribution du tableau: La grande chaîne épissée mesure 1010 000 octets de long et l'épissage prend 1044 millisecondes!
Netscape 7.0:
Méthode d'épissage de chaîne: la grande chaîne épissée mesure 1010 000 octets de long, et l'épissage prend 10 273 millisecondes!
Méthode de jointure d'attribution du tableau: La grande chaîne épissée mesure 1010 000 octets de long, et il faut 1138 millisecondes à épisser!
Opéra 7.54:
Méthode d'épissage de chaîne: la grande chaîne épissée mesure 1010 000 octets de long et l'épissage prend 6968 millisecondes!
Méthode de jointure d'attribution du tableau: La grande chaîne épissée mesure 1010 000 octets de long et l'épissage prend 6922 millisecondes!
Les résultats des tests de 10 000 cycles montrent que l'efficacité peut être considérablement améliorée dans IE et Netscape, tandis que dans Firefox Mozilla Opera, les deux méthodes prennent presque au même moment. Ces données peuvent être suffisantes pour déterminer que la méthode de jointure du tableau est meilleure que l'épissage traditionnel de chaîne.