test nino
v2.0.0
O gerador e validador mais rápido do Nino (número de seguro nacional do Reino Unido). Gera e valida os números NI do Reino Unido para as especificações do NIM39110 no Gov.uk.
test-nino é um desempenho focado e possui zero dependências. Os benchmarks falam por si.
Começando
Instalar
Importar
Funções disponíveis
aleatório
incremental
validar
normalizar
Benchmarks
O que é um número de seguro nacional válido do Reino Unido?
Quantos números de seguros nacionais válidos do Reino Unido existem?
Você pode instalar o pacote Test-Nino a partir do NPM:
npm i test-nino
// ESM/TIPOTIPTIMPORT * como testnino de 'test-nino'; // Commonjscronst testnino = requer ('test-nino'); // denoimport * como testnino de "https://deno.land/x/test_nino@vx .Xx/mod.ts ";Usado para gerar um nino aleatório:
const nino = testnino.random (); // retorna um número de seguro nacional válido do Reino Unido, por exemplo, aa000000A
Aviso: não é garantido que você não poderia gerar o mesmo nino mais de uma vez usando esse método. Se você precisar de um Nino exclusivo todas as vezes, sugiro que você use o gerador incremental.
Este método é melhor se você deseja garantir que não gere um nino duplicado. Esta função utiliza um gerador JavaScript para enumerar através de todos os números NI válidos do Reino Unido AA000000A-ZY999999D (existem 1.492.000.000 no total).
O gerador enumerará em prefixo, número e sufixo.
// Crie um gerador InstanceConst UniqueNigEnerator = testnino.incremental (); para (vamos i = 0; i <= 10000000; i ++) {uniquenegenerator.next () // retorna a próxima instância do gerador // na 1ª iteração dele retornará {value: 'aa000000a', feito: false} // Na 2ª iteração, ele retornará {value: 'aa000000b', feito: false} // ... // Na 10000000th iteração, ele retornará {value: 'AC500000A', feito: false}}A propriedade
donesó retornarátruequando todas as combinações possíveis forem enumeradas.
Esta função validará o Nino fornecido e retornará um objeto que detalha que as regras foram aprovadas ou falhadas.
Espera -se que o Nino já esteja sem formatação etc. - Você pode usar
normalisepara preparar o Nino, se necessário.
// um ninotestnino.validado válido ("ab123456c"); // {// regras: {// type: true, // comprimento: true, // prefixo: true, // número: true, // sufixo: //}, // resultado: true //} // um ninotestnino.validado inválido (1); // {// regras: {// type: false, //}, // OutCome: false //}O objeto retornado sempre terá uma propriedade
outcome, mas a função falha rapidamente e, portanto, retornará apenas um resultado para cada elemento testado do nino.
Essa função normalizará ninos, removendo o espaço em branco e convertendo -o em caracteres maiúsculos.
testnino.Normalise ('aa 00 00 00 a') // aa000000atestnino.normalise ('bb 123456 b') // bb123456bIsso pode ser usado como um primer para a função
validate
Todos os benchmarks são executados usando o benchmark.js no nó v18.16.0. As importações de CommonJs são usadas para todos os pacotes para manter as coisas justas. Você pode executar os benchmarks a partir da pasta benchmarks . Os resultados foram arredondados para 3 números significativos para suavizar variações entre as execuções e fornecer resultados mais comparáveis.
test-nino é mais de 2,6x mais rápido que o próximo gerador de números ni aleatório mais rápido:
| pacote | versão | Ops/Sec |
|---|---|---|
| Fake-Nino | 0.0.1 | 5.810.000 |
| Random_uk_nino | 1.0.3 | 6.340.000 |
| Avris-gerador | 0.8.2 | 2.900.000 |
| teste-nino | mais recente | 17.000.000 |
Outros pacotes usam loops que passam pelo processo de
Generate random NINO > is it valid? > no > repeat, até que um nino válido seja fornecido. Isso custa tempo precioso da CPU e bloqueia o loop de eventos do nó.test-ninoé diferente e, em vez disso, armazena a lista completa de prefixos válidos que são escolhidos aleatoriamente. Nenhuma loops resulta em desempenho consistente que não é garantido com outros pacotes.
test-nino é mais de 14x mais rápido que a próxima função de validação mais rápida ao validar um nino válido:
| pacote | versão | Válido (AA000000A) | inválido (a) | inválido (nulo) | inválido (AAX00000A) | inválido (AA00000XA) |
|---|---|---|---|---|---|---|
| válido-nino | 1.0.0 | 34.000.000 | 84.600.000 | 64.100.000 | 75.200.000 | 27.000.000 |
| Número de seguro-nacional-nacional | 1.0.0 | 42.800.000 | 1.030.000.000 | 1.030.000.000 | 80.000.000 | 33.000.000 |
| Avris-gerador | 0.8.2 | 4.190.000 | 232.000 (lances) | 105.000 (lances) | 230.000 (lances) | 230.000 (lances) |
| teste-nino | mais recente | 609.000.000 | 1.030.000.000 | 1.030.000.000 | 1.020.000.000 | 601.000.000 |
A maioria dos outros pacotes depende de padrões REGEX, a função Validar no
test-ninoutiliza pesquisas de caracteres indexadas, que são muito mais rápidas. A função também falha rapidamente, o que significa ganhos ainda maiores para cenários inválidos específicos.
Para citar as regras no momento da implementação do Gov.uk:
Um nino é composto de 2 letras, 6 números e um sufixo, que é sempre A, B, C ou D.
Parece algo assim: qq 12 34 56 a
Todos os prefixos são válidos, exceto:
Os caracteres d, f, i, q, u e v não são usados como a primeira ou a segunda letra de um prefixo nino.
A letra O não é usada como a segunda letra de um prefixo.
Prefixos BG, GB, KN, NK, NT, TN e ZZ não devem ser usados
Primeiro, vamos considerar as restrições nas duas primeiras letras do prefixo Nino:
Os personagens d, f, i, q, u e v não são usados como a primeira ou a segunda letra do prefixo, então há 20 opções possíveis para a primeira letra (AZ excluindo d, f, i, q, u , e v) e 19 opções possíveis para a segunda letra (AZ excluindo d, f, i, q, u, v e o).
Os prefixos BG, GB, KN, NK, NT, TN e ZZ não devem ser usados; portanto, existem 20 x 19 - 7 = 373 combinações possíveis das duas primeiras letras.
Em seguida, vamos considerar as restrições na carta final, que é o sufixo:
O sufixo só pode ser A, B, C ou D, então existem 4 sufixos possíveis.
Finalmente, vamos considerar os seis números no Nino:
Cada um dos seis números pode ter 10 valores possíveis (0-9), portanto, existem 10^6 (1 milhão) possíveis combinações dos seis números.
Juntando tudo isso, o número de ninos únicos possíveis seria:
373 (para as duas primeiras letras) x 10^6 (para os seis números) x 4 (para a letra final) = 1.492.000.000 de ninos possíveis.
