O chamado formulário numérico é adicionar uma vírgula entre cada três dígitos, a partir de um dígito único. Por exemplo, "10.000". Para atender a esse requisito, inicialmente escrevi uma função como esta:
A cópia do código é a seguinte:
// Método 1
função toth milhares (num) {
var resultado = [], contador = 0;
num = (num || 0) .ToString (). Split ('');
for (var i = num.length-1; i> = 0; i--) {
contador ++;
resultado.unshift (num [i]);
if (! (contador % 3) && i! = 0) {resultado.unshift (','); }
}
resultado de retorno.Join ('');
}
O processo de execução do método um é converter os números em strings, dividi -los em uma matriz e iniciar do final, inserir os elementos na matriz no início da nova matriz (resultado). Toda vez que um elemento é inserido, o contador conta o número (adicione 1). Quando o contador é um múltiplo de 3, uma vírgula é inserida, mas tenha cuidado para que não haja vírgula necessária no início (quando eu sou 0). Finalmente, o resultado é obtido chamando o método de junção da nova matriz.
O método era mais claro e mais fácil de entender, e também foi usado no projeto por um tempo. Mas a intuição me diz que não está com bom desempenho.
Método 2 - Versão da string do método 1
A cópia do código é a seguinte:
// Método 2
função toth milhares (num) {
var resultado = '', contador = 0;
num = (num || 0) .ToString ();
for (var i = num.length-1; i> = 0; i--) {
contador ++;
resultado = num.Charat (i) + resultado;
if (! (contador % 3) && i! = 0) {resultado = ',' + resultado; }
}
resultado de retorno;
}
O método 2 é uma versão aprimorada do método 1. Ele não divide strings em matrizes e sempre opera em strings.
Método 3 - Loop corresponde aos três números no final
A cópia do código é a seguinte:
// Método 3
função toth milhares (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;
} outro {
num = '';
quebrar;
}
}
if (num) {resultado = num + resultado; }
resultado de retorno;
}
O método 3 é um algoritmo completamente diferente. Os três números no final são correspondidos através de um loop de expressão regular. Cada vez que a correspondência é correspondida, a vírgula e o conteúdo correspondente são inseridos no início da sequência de resultados e, em seguida, o destino correspondente (NUM) é atribuído ao conteúdo que ainda não correspondeu (regexp.leftContext). Além disso, observe:
1. Se o número de dígitos for um múltiplo de 3, a última partida deve ter três números, mas não há necessidade de adicionar uma vírgula antes dos três primeiros números;
2. Se o número de bits de um número não for um múltiplo de 3, a variável num definitivamente terá 1 a 2 números restantes no final. Após o loop, os números restantes devem ser inseridos no início da string de resultado.
Embora o método três reduz o número de loops (três caracteres são processados por vez), o consumo é aumentado até certo ponto devido ao uso de expressões regulares.
Método 4 - Versão da String do Método 3
A cópia do código é a seguinte:
// Método 4
função toth milhares (num) {
var num = (num || 0) .ToString (), resultado = '';
enquanto (num.length> 3) {
resultado = ',' + num.slice (-3) + resultado;
num = num.slice (0, num.length - 3);
}
if (num) {resultado = num + resultado; }
resultado de retorno;
}
De fato, a função de interceptar os três últimos caracteres pode ser alcançada através do método de fatia, substring ou substring do tipo de sequência. Isso evita expressões regulares.
Método 5 - Método de combinação e convergência
A cópia do código é a seguinte:
// Método 5
função toth milhares (num) {
var num = (num || 0) .ToString (), temp = num.length % 3;
Switch (temp) {
Caso 1:
num = '00' + num;
quebrar;
Caso 2:
num = '0' + num;
quebrar;
}
retornar num.match (// d {3}/g) .Join (','). Substitua (/^0+/, '');
}
Primeiro, compense o número de dígitos em múltiplos de 3, corte -os em grupos de cada três números através de expressões regulares, adicione vírgulas através do método de junção e, finalmente, remova o complemento 0.
Método 6 - Método preguiçoso
A cópia do código é a seguinte:
// Método 6
função toth milhares (num) {
return (num || 0) .toString (). Substitua (/(/d) (? = (?:/d {3})+$)/g, '$ 1,');
}
Eu sempre sinto que essa formatação pode ser feita por uma substituição regular de expressão, mas preciso usar afirmações e outros métodos de escrita, mas não estou familiarizado com essa parte. Depois de pesquisar no Google, encontrei uma expressão tão regular, que provavelmente é a mais curta implementação do código.
Resultados do teste
| número | Tempo gasto em 5000 vezes (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 | vinte e um | 4 | 3 | 1 | 6 | 3 |
| 100000 | vinte e um | 3 | 2 | 1 | 5 | 6 |
Uma forte comparação entre o método 1 e o método 2 mostra que a eficiência das operações de string é muito maior que a das operações de matriz; Os resultados do teste do método 6 nos dizem que o comprimento do código não tem nada a ver com o desempenho. O método 4 tem o melhor desempenho abrangente (mas por que o NUM diminui quando 100 NUM é realmente insolúvel), o principal motivo é:
1. Compare os métodos 1 e 2, opere 3 caracteres em vez de 1 caractere a cada vez para reduzir o número de loops;
2. Métodos de comparação 3, 5 e 6, sem usar expressões regulares, reduzindo o consumo.
Finalmente, escolhi o método quatro como a solução de otimização final. Os leitores podem comentar se tiverem melhores métodos ou sugestões de implementação.