Je vois quelques solutions de projet de code .
Mais existe-t-il une implémentation régulière en JavaScript?
Je vois quelques solutions de projet de code .
Mais existe-t-il une implémentation régulière en JavaScript?
Réponses:
Si vous devez écrire du code pour Internet Explorer, assurez-vous d'avoir choisi une implémentation qui utilise des jointures de tableau. La concaténation des chaînes avec l' opérateur +
ou +=
est extrêmement lente sur IE. Cela est particulièrement vrai pour IE6. Sur les navigateurs modernes, +=
c'est généralement aussi rapide que les jointures de tableaux.
Lorsque je dois faire beaucoup de concaténations de chaînes, je remplis généralement un tableau et n'utilise pas de classe de générateur de chaînes:
var html = [];
html.push(
"<html>",
"<body>",
"bla bla bla",
"</body>",
"</html>"
);
return html.join("");
Notez que les push
méthodes acceptent plusieurs arguments.
[foo(), "bar", "baz"].join("");
fonctionne également.
push
pouvais accepter plusieurs arguments. Les choses aléatoires que vous apprenez.
Je viens de revérifier les performances sur http://jsperf.com/javascript-concat-vs-join/2 . Les cas de test concaténent ou rejoignent l'alphabet 1000 fois.
Dans les navigateurs actuels (FF, Opera, IE11, Chrome), "concat" est environ 4 à 10 fois plus rapide que "join".
Dans IE8, les deux renvoient des résultats à peu près égaux.
Dans IE7, «rejoindre» est malheureusement environ 100 fois plus rapide.
Non, il n'y a pas de prise en charge intégrée pour la création de chaînes. Vous devez utiliser la concaténation à la place.
Vous pouvez, bien sûr, créer un tableau de différentes parties de votre chaîne, puis appeler join()
ce tableau, mais cela dépend alors de la façon dont la jointure est implémentée dans l'interpréteur JavaScript que vous utilisez.
J'ai fait une expérience pour comparer la vitesse de la str1+str2
méthode par rapport à la array.push(str1, str2).join()
méthode. Le code était simple:
var iIterations =800000;
var d1 = (new Date()).valueOf();
str1 = "";
for (var i = 0; i<iIterations; i++)
str1 = str1 + Math.random().toString();
var d2 = (new Date()).valueOf();
log("Time (strings): " + (d2-d1));
var d3 = (new Date()).valueOf();
arr1 = [];
for (var i = 0; i<iIterations; i++)
arr1.push(Math.random().toString());
var str2 = arr1.join("");
var d4 = (new Date()).valueOf();
log("Time (arrays): " + (d4-d3));
Je l'ai testé dans Internet Explorer 8 et Firefox 3.5.5, tous deux sur un Windows 7 x64.
Au début j'ai testé sur un petit nombre d'itérations (quelques centaines, quelques milliers d'éléments). Les résultats étaient imprévisibles (parfois la concaténation de chaînes prenait 0 millisecondes, parfois 16 millisecondes, la même chose pour la jonction de tableaux).
Lorsque j'ai augmenté le nombre à 50000, les résultats étaient différents selon les navigateurs - dans Internet Explorer, la concaténation des chaînes était plus rapide (94 millisecondes) et la jointure était plus lente (125 millisecondes), tandis que dans Firefox, la jointure du tableau était plus rapide (113 millisecondes) que jonction de chaînes (117 millisecondes).
Puis j'ai augmenté le nombre à 500'000. Désormais, la concaténation de chaînesarray.join()
était plus lente que la concaténation de chaînes dans les deux navigateurs: la concaténation de chaînes était de 937 ms dans Internet Explorer, de 1155 ms dans Firefox, de la jointure de tableau 1265 dans Internet Explorer et de 1207 ms dans Firefox.
Le nombre maximum d'itérations que j'ai pu tester dans Internet Explorer sans avoir "le script prend trop de temps à s'exécuter" était de 850 000. Ensuite, Internet Explorer était de 1593 pour la concaténation de chaînes et 2046 pour la jointure de tableau, et Firefox avait 2101 pour la concaténation de chaîne et 2249 pour la jointure de tableau.
Résultats - si le nombre d'itérations est petit, vous pouvez essayer de l'utiliser array.join()
, car cela pourrait être plus rapide dans Firefox. Lorsque le nombre augmente, la string1+string2
méthode est plus rapide.
J'ai effectué le test sur Internet Explorer 6 (Windows XP). Le processus s'est arrêté pour répondre immédiatement et ne s'est jamais terminé, si j'essayais le test sur plus de 100 000 itérations. Sur 40000 itérations, les résultats ont été
Time (strings): 59175 ms
Time (arrays): 220 ms
Cela signifie que si vous devez prendre en charge Internet Explorer 6, choisissez celui array.join()
qui est bien plus rapide que la concaténation de chaînes.
join()
fait partie d'ECMAScript et afaik chaque interpréteur JavaScript l'implémente. Pourquoi cela «dépendrait-il»?
Ce code ressemble à l'itinéraire que vous souhaitez emprunter avec quelques modifications.
Vous voudrez changer la méthode d'ajout pour qu'elle ressemble à ceci. Je l'ai changé pour accepter le numéro 0 et pour le faire revenir this
afin que vous puissiez enchaîner vos appendices.
StringBuilder.prototype.append = function (value) {
if (value || value === 0) {
this.strings.push(value);
}
return this;
}
null
, false
, des chaînes vides, undefined
ou NaN
.
La version ECMAScript 6 (alias ECMAScript 2015) de JavaScript a introduit des littéraux de chaîne .
var classType = "stringbuilder";
var q = `Does JavaScript have a built-in ${classType} class?`;
Notez que les rétro-graduations, au lieu des guillemets simples, entourent la chaîne.
En C #, vous pouvez faire quelque chose comme
String.Format("hello {0}, your age is {1}.", "John", 29)
En JavaScript, vous pouvez faire quelque chose comme
var x = "hello {0}, your age is {1}";
x = x.replace(/\{0\}/g, "John");
x = x.replace(/\{1\}/g, 29);
{0}
est remplacé contient {1}
.
Pour les personnes intéressées, voici une alternative à l'appel de Array.join:
var arrayOfStrings = ['foo', 'bar'];
var result = String.concat.apply(null, arrayOfStrings);
console.log(result);
La sortie, comme prévu, est la chaîne 'foobar'. Dans Firefox, cette approche surpasse Array.join mais est surperformée par la concaténation +. Étant donné que String.concat nécessite que chaque segment soit spécifié comme argument distinct, l'appelant est limité par toute limite de nombre d'arguments imposée par le moteur JavaScript en cours d'exécution. Jetez un œil à la documentation de Function.prototype.apply () pour plus d'informations.
J'ai défini cette fonction:
function format() {
var args = arguments;
if (args.length <= 1) {
return args;
}
var result = args[0];
for (var i = 1; i < args.length; i++) {
result = result.replace(new RegExp("\\{" + (i - 1) + "\\}", "g"), args[i]);
}
return result;
}
Et peut être appelé comme c #:
var text = format("hello {0}, your age is {1}.", "John", 29);
Résultat:
bonjour John, tu as 29 ans.
Quand je me retrouve à faire beaucoup de concaténation de chaînes en JavaScript, je commence à chercher des modèles. Handlebars.js fonctionne assez bien en gardant le HTML et le JavaScript plus lisibles. http://handlebarsjs.com
Que diriez-vous d' sys.StringBuilder()
essayer l'article suivant.