La forme dite numérique consiste à ajouter une virgule entre trois chiffres à partir d'un seul chiffre. Par exemple, "10 000". Pour répondre à cette exigence, j'ai initialement écrit une fonction comme celle-ci:
La copie de code est la suivante:
// Méthode 1
fonction toth millise (num) {
var résultat = [], compteur = 0;
num = (num || 0) .toString (). Split ('');
pour (var i = num.length - 1; i> = 0; i--) {
compteur ++;
résultat.unshift (num [i]);
if (! (Counter% 3) && i! = 0) {result.unshift (','); }
}
return result.join ('');
}
Le processus d'exécution de la méthode est de convertir les nombres en chaînes, de les diviser en un tableau, puis de commencer à partir de la fin, d'insérer les éléments du tableau au début du nouveau tableau (résultat). Chaque fois qu'un élément est inséré, le compteur compte le nombre (Ajouter 1). Lorsque le compteur est un multiple de 3, une virgule est insérée, mais veillez à ce qu'il n'y ait pas de virgule requise au début (quand je suis 0). Enfin, le résultat est obtenu en appelant la méthode de jointure du nouveau tableau.
La méthode était plus claire et plus facile à comprendre, et elle a également été utilisée dans le projet pendant un certain temps. Mais l'intuition me dit que ça ne fonctionne pas bien.
Méthode 2 - version de chaîne de la méthode 1
La copie de code est la suivante:
// Méthode 2
fonction toth millise (num) {
var result = '', compteur = 0;
num = (num || 0) .toString ();
pour (var i = num.length - 1; i> = 0; i--) {
compteur ++;
résultat = num.charat (i) + résultat;
if (! (Counter% 3) && i! = 0) {result = ',' + résultat; }
}
Résultat de retour;
}
La méthode 2 est une version améliorée de la méthode 1. Il ne divise pas les chaînes en tableaux et fonctionne toujours sur les chaînes.
Méthode 3 - Loop correspond aux trois nombres à la fin
La copie de code est la suivante:
// Méthode 3
fonction toth millise (num) {
var num = (num || 0) .toString (), re = // d {3} $ /, result = '';
while (re.test (num)) {
result = regexp.lastmatch + résultat;
if (num! == regexp.lastmatch) {
résultat = ',' + résultat;
num = regexp.leftContext;
} autre {
num = '';
casser;
}
}
if (num) {result = num + result; }
Résultat de retour;
}
La méthode 3 est un algorithme complètement différent. Les trois nombres à la fin sont appariés par une boucle d'expression régulière. Chaque fois que le match est apparié, la virgule et le contenu correspondant sont insérés au début de la chaîne de résultats, puis la cible correspondante (NUM) est affectée au contenu qui n'a pas encore apparié (regexp.leftContext). De plus, veuillez noter:
1. Si le nombre de chiffres est un multiple de 3, la dernière correspondance doit être de trois nombres, mais il n'est pas nécessaire d'ajouter une virgule avant les trois premiers numéros;
2. Si le nombre de bits d'un nombre n'est pas un multiple de 3, la variable NUM aura certainement 1 à 2 nombres à la fin. Après la boucle, les nombres restants doivent être insérés au début de la chaîne de résultats.
Bien que la méthode trois réduit le nombre de boucles (trois caractères sont traités à la fois), la consommation est augmentée dans une certaine mesure en raison de l'utilisation d'expressions régulières.
Méthode 4 - version de chaîne de la méthode 3
La copie de code est la suivante:
// Méthode 4
fonction toth millise (num) {
var num = (num || 0) .toString (), result = '';
while (num.length> 3) {
result = ',' + num.slice (-3) + résultat;
num = num.slice (0, num.length - 3);
}
if (num) {result = num + result; }
Résultat de retour;
}
En fait, la fonction d'interception des trois derniers caractères peut être réalisée via la méthode Slice, substr ou sous-chaîne du type de chaîne. Cela évite les expressions régulières.
Méthode 5 - Méthode de combinaison et de convergence
La copie de code est la suivante:
// Méthode 5
fonction toth millise (num) {
var num = (num || 0) .toString (), temp = num.length% 3;
commutateur (temp) {
Cas 1:
num = '00' + num;
casser;
Cas 2:
num = '0' + num;
casser;
}
return num.match (// d {3} / g) .join (','). remplacer (/ ^ 0 + /, '');
}
Tout d'abord, composez le nombre de chiffres en multiples de 3, les coupez en groupes de tous les trois nombres par des expressions régulières, puis ajoutez des virgules via la méthode de jointure et supprimez enfin le complément 0.
Méthode 6 - Méthode paresseuse
La copie de code est la suivante:
// Méthode 6
fonction toth millise (num) {
return (num || 0) .toString (). Remplace (/ (/ d) (? = (?: / d {3}) + $) / g, '1,');
}
Je pense toujours que ce formatage peut être fait par un remplacement d'expression régulière, mais j'ai besoin d'utiliser des affirmations et d'autres méthodes d'écriture, mais je ne connais pas cette partie. Après l'avoir googlé, j'ai trouvé une telle expression régulière, qui est probablement l'implémentation la plus courte du code.
Résultats des tests
| nombre | Temps passé sur 5000 fois (MS) | |||||
|---|---|---|---|---|---|---|
| Méthode 1 | Méthode 2 | Méthode 3 | Méthode 4 | Méthode 5 | Méthode 6 | |
| 1 | 4 | 1 | 3 | 1 | 14 | 2 |
| 10 | 14 | 1 | 3 | 0 | 7 | 2 |
| 100 | 12 | 1 | 2 | 4 | 5 | 3 |
| 1000 | 13 | 2 | 3 | 2 | 9 | 5 |
| 10000 | vingt-et-un | 4 | 3 | 1 | 6 | 3 |
| 100000 | vingt-et-un | 3 | 2 | 1 | 5 | 6 |
Une forte comparaison entre la méthode 1 et la méthode 2 montre que l'efficacité des opérations de chaîne est beaucoup plus élevée que celle des opérations de tableau; Les résultats des tests de la méthode 6 nous indiquent que la longueur du code n'a rien à voir avec les performances. La méthode 4 a les meilleures performances complètes (mais pourquoi Num diminue lorsque 100 num est vraiment insoluble), la raison principale est:
1. Comparez les méthodes 1 et 2, utilisez 3 caractères au lieu de 1 caractère à chaque fois pour réduire le nombre de boucles;
2. Méthodes de comparaison 3, 5 et 6, sans utiliser d'expressions régulières, réduisant la consommation.
Enfin, j'ai choisi la méthode quatre comme solution d'optimisation finale. Les lecteurs peuvent commenter s'ils ont de meilleures méthodes ou suggestions de mise en œuvre.