Die sogenannte numerische Form besteht darin, ein Komma zwischen zwei Ziffern von einzelnen Ziffern hinzuzufügen. Zum Beispiel "10.000". Um diese Anforderung zu befriedigen, habe ich zunächst eine solche Funktion geschrieben:
Die Codekopie lautet wie folgt:
// Methode 1
Funktion Tothausend (num) {
var result = [], counter = 0;
Num = (num || 0) .ToString (). Split ('');
für (var i = num.length-1; i> = 0; i--) {
Zähler ++;
result.unshift (num [i]);
if (! (counter % 3) && i! = 0) {result.unshift (','); }
}
Rückgabeergebnis.Join ('');
}
Der Ausführungsprozess von Method One besteht darin, die Zahlen in Zeichenfolgen umzuwandeln, sie in ein Array zu unterteilen und dann vom Ende zu beginnen, die Elemente im Array zum Beginn des Neuarrays (Ergebnis) einzulegen. Jedes Mal, wenn ein Element eingefügt wird, zählt der Zähler die Zahl (add 1). Wenn der Zähler ein Vielfaches von 3 ist, wird ein Komma eingefügt, aber achten Sie darauf, dass am Anfang kein Komma erforderlich ist (wenn ich 0 ist). Schließlich wird das Ergebnis erhalten, indem die Join -Methode des Neuarrays aufgerufen wird.
Die Methode war klarer und einfacher zu verstehen und wurde auch für eine Weile im Projekt verwendet. Aber die Intuition sagt mir, dass es nicht gut funktioniert.
Methode 2 - String -Version der Methode 1
Die Codekopie lautet wie folgt:
// Methode 2
Funktion Tothausend (num) {
var result = '', counter = 0;
Num = (num || 0) .ToString ();
für (var i = num.length-1; i> = 0; i--) {
Zähler ++;
result = num.charat (i) + result;
if (! (counter % 3) && i! = 0) {result = ',' + result; }
}
Rückgabeergebnis;
}
Methode 2 ist eine verbesserte Version der Methode 1. Sie unterteilt Strings nicht in Arrays und arbeitet immer auf Zeichenfolgen.
Methode 3 - Loop entspricht den drei Zahlen am Ende
Die Codekopie lautet wie folgt:
// Methode 3
Funktion Tothausend (num) {
var num = (num || 0) .ToString (), re = // d {3} $/, result = '';
while (re.test (num)) {
result = regexp.lastMatch + Ergebnis;
if (num! == regexp.lastMatch) {
Ergebnis = ',' + Ergebnis;
num = regexp.leftcontext;
} anders {
num = '';
brechen;
}
}
if (num) {result = num + result; }
Rückgabeergebnis;
}
Methode 3 ist ein völlig anderer Algorithmus. Die drei Zahlen am Ende werden durch eine reguläre Ausdrucksschleife abgestimmt. Jedes Mal, wenn das Match abgestimmt ist, werden das Komma und der Matching -Inhalt am Anfang der Ergebniszeichenfolge eingefügt, und dann wird das übereinstimmende Ziel (NUM) dem Inhalt zugeordnet, der noch nicht übereinstimmt (regexp.leftcontext). Bitte beachten Sie bitte:
1. Wenn die Anzahl der Ziffern ein Vielfaches von 3 ist, muss die letzte Übereinstimmung drei Zahlen betragen, es müssen jedoch kein Komma vor den ersten drei Zahlen hinzugefügt werden.
2. Wenn die Anzahl der Bits einer Zahl kein Vielfaches von 3 ist, hat die Num -Variable am Ende definitiv 1 bis 2 Zahlen übrig. Nach der Schleife sollten die verbleibenden Zahlen am Anfang der Ergebniszeichenfolge eingefügt werden.
Obwohl Methode drei die Anzahl der Schleifen verringert (drei Zeichen werden gleichzeitig verarbeitet), wird der Verbrauch aufgrund der Verwendung regulärer Ausdrücke in gewissem Maße erhöht.
Methode 4 - String -Version von Methode 3
Die Codekopie lautet wie folgt:
// Methode 4
Funktion Tothausend (num) {
var num = (num || 0) .ToString (), result = '';
while (num.length> 3) {
result = ',' + num.slice (-3) + Ergebnis;
num = num.lice (0, num.length - 3);
}
if (num) {result = num + result; }
Rückgabeergebnis;
}
Tatsächlich kann die Funktion des Abfangens der letzten drei Zeichen durch die Sicht-, Substr- oder Substring -Methode des String -Typs erreicht werden. Dies vermeidet regelmäßige Ausdrücke.
Methode 5 - Kombination und Konvergenzmethode
Die Codekopie lautet wie folgt:
// Methode 5
Funktion Tothausend (num) {
var num = (num || 0) .ToString (), temp = num.Length % 3;
Switch (temp) {
Fall 1:
Num = '00' + num;
brechen;
Fall 2:
Num = '0' + num;
brechen;
}
return num.match (// d {3}/g) .Join (','). Ersetzen (/^0+/, '');
}
Machen Sie zunächst die Anzahl der Ziffern in Vielfachen von 3, schneiden Sie sie in Gruppen von drei Zahlen durch reguläre Ausdrücke aus, fügen Sie dann Kommas durch die Join -Methode hinzu und entfernen Sie schließlich die Komplement 0.
Methode 6 - Lazy Methode
Die Codekopie lautet wie folgt:
// Methode 6
Funktion Tothausend (num) {
return (num || 0) .ToString (). Ersetzen (/(/d) (? = (?:/d {3})+$)/g, '$ 1,');
}
Ich habe immer das Gefühl, dass diese Formatierung durch einen regelmäßigen Ausdrucksersatz gemacht werden kann, aber ich muss Behauptungen und andere Schreibmethoden anwenden, aber ich bin mit diesem Teil nicht vertraut. Nachdem ich es gegoogelt hatte, fand ich einen so regelmäßigen Ausdruck, der wahrscheinlich die kürzeste Implementierung des Codes ist.
Testergebnisse
| Nummer | Zeit für 5000 Mal (MS) verbracht | |||||
|---|---|---|---|---|---|---|
| Methode 1 | Methode 2 | Methode 3 | Methode 4 | Methode 5 | Methode 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 | Einundzwanzig | 4 | 3 | 1 | 6 | 3 |
| 100000 | Einundzwanzig | 3 | 2 | 1 | 5 | 6 |
Ein starker Vergleich zwischen Methode 1 und Methode 2 zeigt, dass die Effizienz von String -Operationen viel höher ist als der von Array -Operationen. Die Testergebnisse der Methode 6 zeigen uns, dass die Länge des Codes nichts mit der Leistung zu tun hat. Methode 4 hat die beste umfassende Leistung (aber warum nimmt Num ab, wenn 100 Num wirklich unlösbar ist), der Hauptgrund ist:
1. Vergleichen Sie die Methoden 1 und 2, betreiben Sie jedes Mal 3 Zeichen anstelle von 1 Zeichen, um die Anzahl der Schleifen zu verringern.
2. Vergleichsmethoden 3, 5 und 6, ohne regelmäßige Ausdrücke zu verwenden, verringern Sie den Verbrauch.
Schließlich wählte ich Method Four als endgültige Optimierungslösung. Leser können Kommentare abgeben, wenn sie über bessere Implementierungsmethoden oder Vorschläge verfügen.