La llamada forma numérica es agregar una coma entre cada tres dígitos a partir de un solo dígito. Por ejemplo, "10,000". Para abordar este requisito, inicialmente escribí una función como esta:
La copia del código es la siguiente:
// Método 1
función toth mils (num) {
resultado var = [], contador = 0;
num = (num || 0) .ToString (). Split ('');
para (var i = num.length-1; i> = 0; i--) {
contador ++;
resultado.unshift (num [i]);
if (! (contador % 3) && i! = 0) {result.unshift (','); }
}
return result.Join ('');
}
El proceso de ejecución del método uno es convertir los números en cadenas, dividirlos en una matriz y luego comenzar desde el final, inserte los elementos en la matriz al comienzo de la nueva matriz (resultado). Cada vez que se inserta un elemento, el contador cuenta el número (agregue 1). Cuando el contador es un múltiplo de 3, se inserta una coma, pero tenga cuidado de que no se requiere coma al principio (cuando es 0). Finalmente, el resultado se obtiene llamando al método de unión de la nueva matriz.
El método fue más claro y más fácil de entender, y también se usó en el proyecto durante un tiempo. Pero la intuición me dice que no está funcionando bien.
Método 2 - Versión de cadena del método 1
La copia del código es la siguiente:
// Método 2
función toth mils (num) {
resultado var = '', contador = 0;
num = (num || 0) .ToString ();
para (var i = num.length-1; i> = 0; i--) {
contador ++;
resultado = num.charat (i) + resultado;
if (! (contador % 3) && i! = 0) {result = ',' + resultado; }
}
resultado de retorno;
}
El método 2 es una versión mejorada del método 1. No divide las cadenas en matrices y siempre funciona en cadenas.
Método 3: el bucle coincide con los tres números al final
La copia del código es la siguiente:
// Método 3
función toth mils (num) {
var num = (num || 0) .ToString (), re = // d {3} $/, resultado = '';
while (re.test (num)) {
resultado = regexp.lastMatch + resultado;
if (num! == regexp.lastMatch) {
resultado = ',' + resultado;
num = regexp.leftContext;
} demás {
num = '';
romper;
}
}
if (num) {resultado = num + resultado; }
resultado de retorno;
}
El método 3 es un algoritmo completamente diferente. Los tres números al final coinciden a través de un bucle de expresión regular. Cada vez que se combina la coincidencia, la coma y el contenido coincidente se insertan al comienzo de la cadena de resultados, y luego el objetivo coincidente (NUM) se asigna al contenido que aún no ha coincidido (regexp.leftcontext). Además, tenga en cuenta:
1. Si el número de dígitos es un múltiplo de 3, el último partido debe ser tres números, pero no hay necesidad de agregar una coma antes de los primeros tres números;
2. Si el número de bits de un número no es un múltiplo de 3, entonces la variable NUM definitivamente tendrá 1 a 2 números al final. Después del bucle, los números restantes deben insertarse al comienzo de la cadena de resultados.
Aunque el método tres reduce el número de bucles (tres caracteres se procesan a la vez), el consumo se incrementa en cierta medida debido al uso de expresiones regulares.
Método 4 - Versión de cadena del método 3
La copia del código es la siguiente:
// Método 4
función toth mils (num) {
var num = (num || 0) .ToString (), resultado = '';
while (num.length> 3) {
resultado = ',' + num.slice (-3) + resultado;
num = num.slice (0, num.length - 3);
}
if (num) {resultado = num + resultado; }
resultado de retorno;
}
De hecho, la función de interceptar los últimos tres caracteres se puede lograr a través del método de corte, substr o subcadena del tipo de cadena. Esto evita expresiones regulares.
Método 5 - Método de combinación y convergencia
La copia del código es la siguiente:
// Método 5
función toth mils (num) {
var num = (num || 0) .ToString (), temp = num.length % 3;
Switch (temp) {
Caso 1:
num = '00' + num;
romper;
Caso 2:
num = '0' + num;
romper;
}
return num.match (// d {3}/g) .Join (','). Reemplazar (/^0+/, '');
}
Primero, invente el número de dígitos en múltiplos de 3, córtelos en grupos de cada tres números a través de expresiones regulares, luego agregue comas a través del método de unión y finalmente elimine el complemento 0.
Método 6 - Método perezoso
La copia del código es la siguiente:
// Método 6
función toth mils (num) {
return (num || 0) .ToString (). reemplazar (/(/d) (? = (?:/d {3})+$)/g, '$ 1,');
}
Siempre siento que este formato puede hacerse mediante un reemplazo de expresión regular, pero necesito usar afirmaciones y otros métodos de escritura, pero no estoy familiarizado con esta parte. Después de buscarlo en Google, encontré una expresión tan regular, que es probablemente la implementación más corta del código.
Resultados de las pruebas
| número | Tiempo dedicado a 5000 veces (MS) | |||||
|---|---|---|---|---|---|---|
| Método 1 | Método 2 | Método 3 | Método 4 | Método 5 | Método 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 | veintiuno | 4 | 3 | 1 | 6 | 3 |
| 100000 | veintiuno | 3 | 2 | 1 | 5 | 6 |
Una fuerte comparación entre el método 1 y el método 2 muestra que la eficiencia de las operaciones de cadena es mucho más alta que la de las operaciones de matriz; Los resultados de la prueba del Método 6 nos dicen que la longitud del código no tiene nada que ver con el rendimiento. El método 4 tiene el mejor rendimiento integral (pero ¿por qué la NUM disminuye cuando 100 NUM es realmente insoluble), la razón principal es:
1. Compare los métodos 1 y 2, opere 3 caracteres en lugar de 1 caracteres cada vez para reducir el número de bucles;
2. Métodos de comparación 3, 5 y 6, sin usar expresiones regulares, reduciendo el consumo.
Finalmente, elegí el método cuatro como la solución de optimización final. Los lectores pueden comentar si tienen mejores métodos o sugerencias de implementación.