Placa de veículo

Validar

• JavaScript, biblioteca
• Python, biblioteca10 casos falham
• Go, biblioteca5 casos falham
• Ruby, biblioteca9 casos falham
• Rust, biblioteca7 casos falham
• .NET, biblioteca5 casos falham
• Erlang, biblioteca17 casos falham

Valida uma placa no formato antigo (ABC1234) ou no padrão Mercosul (ABC1D23), em maiúsculas ou minúsculas, com ou sem hífen ou espaço.

• options.format restringe a checagem a um formato: "LLLNNNN" (antigo, ABC1234) ou "LLLNLNN" (Mercosul, ABC1D23), os códigos que licensePlate.getFormat retorna e licensePlate.generate recebe. Sem ele, ou com qualquer outro valor, os dois formatos são aceitos. Até a 2.4.0 a opção não existia e os dois formatos eram sempre aceitos.
• Qualquer outra sequência de letras e dígitos, ou caracteres a mais, torna a placa inválida.
• A máscara (espaço, ., - ou /, sozinha ou em sequência) só é aceita entre o terceiro caractere e os quatro últimos, os espaços nas pontas da placa são ignorados, e a verificação ignora maiúsculas e minúsculas.
• Um caractere de máscara em outro lugar, ou qualquer outro caractere (A@BC1234, um emoji), torna a placa inválida em vez de ser removido. Até a 2.4.0 esses caracteres eram removidos (A@B#C1$2%3^4 era true).
• licensePlate.getFormat retorna null exatamente quando esta função retorna false.
• A sequência antiga de motos, já extinta, LLLNNLN (ABC12D3) é inválida.

import { isValidLicensePlate } from '@brazilian-utils/brazilian-utils';

isValidLicensePlate('ABC1234'); // true (formato brasileiro)
isValidLicensePlate('ABC-1234'); // true (formato brasileiro com hífen)
isValidLicensePlate('ABC 1234'); // true (máscara com espaço)
isValidLicensePlate('ABC1D23'); // true (formato Mercosul)
isValidLicensePlate('ABC12D3'); // false (não é uma sequência Mercosul)
isValidLicensePlate('ABC1234EXTRA'); // false (caracteres em excesso)
isValidLicensePlate('A-BC1234'); // false (a máscara só fica depois do terceiro caractere)
isValidLicensePlate('ABC1234!'); // false (qualquer outro caractere é rejeitado)
isValidLicensePlate('ABC1D23', { format: 'LLLNLNN' }); // true
isValidLicensePlate('ABC1234', { format: 'LLLNLNN' }); // false (placa no formato antigo)
isValidLicensePlate('ABC-1234', { format: 'LLLNNNN' }); // true

Formatar

• JavaScript, biblioteca
• Python, biblioteca17 casos falham
• Go, biblioteca8 casos falham
• Ruby, biblioteca15 casos falham
• Rust, biblioteca17 casos falham
• .NET, biblioteca17 casos falham
• Erlang, biblioteca17 casos falham

Formata uma placa em maiúsculas. Placas no formato antigo (LLLNNNN) ganham um hífen (ABC-1234). Placas Mercosul (LLLNLNN) não têm separador.

• Um valor parcial é formatado até onde vai, então a função serve como máscara de entrada: o hífen aparece assim que o quarto caractere é um dígito (abc1 dá ABC-1), e um quinto caractere que é letra mantém a forma Mercosul (abc1d dá ABC1D).
• Todo caractere que não seja letra ASCII ou dígito é descartado antes, e só os 7 primeiros ficam. Diferente de licensePlate.isValid, a máscara pode estar em qualquer posição.
• Retorna uma string vazia quando o valor não pode ser o início de uma placa válida (1234567, abc12d3, abc1da2).
• Um valor que não é string retorna uma string vazia.

import { formatLicensePlate } from '@brazilian-utils/brazilian-utils';

formatLicensePlate('abc1234'); // 'ABC-1234'
formatLicensePlate('abc1d23'); // 'ABC1D23'
formatLicensePlate('abc1'); // 'ABC-1' (um valor parcial é formatado até onde vai)
formatLicensePlate('abc1d'); // 'ABC1D'

Interpretar

• JavaScript, biblioteca
• Python, biblioteca
• Go, biblioteca
• Ruby, biblioteca
• Rust, biblioteca
• .NET, biblioteca
• Erlang, biblioteca

Remove de uma placa todo caractere que não seja letra ASCII ou dígito, converte para maiúsculas e limita a 7 caracteres (abc-1234 dá ABC1234).

• Não valida: use licensePlate.isValid para isso. A máscara pode estar em qualquer posição, diferente de licensePlate.isValid.
• Um valor que não é string retorna uma string vazia.

import { parseLicensePlate } from '@brazilian-utils/brazilian-utils';

parseLicensePlate('abc-1234'); // 'ABC1234'

Gerar

• JavaScript, biblioteca
• Python, biblioteca4 casos falham
• Go, biblioteca3 casos falham
• Ruby, biblioteca4 casos falham
• Rust, biblioteca2 casos falham
• .NET, biblioteca3 casos falham
• Erlang, biblioteca4 casos falham

Gera uma placa aleatória e válida, sem máscara.

• format é LLLNLNN (Mercosul, o padrão) ou LLLNNNN (formato antigo). Qualquer outro valor usa o padrão.
• O quinto caractere de uma placa Mercosul é sorteado de K a Z. A a J só é usado na conversão de uma placa do formato antigo (Resolução CONTRAN nº 969/2022, Anexo II, item 2), então uma placa nova nunca o traz. Até a 2.4.0 podia ser qualquer letra.
• Um formato fora dos dois literais usa o padrão, então o resultado é sempre uma placa que licensePlate.isValid aceita. A 2.3.0 usava uma string desconhecida como veio.
• Usa uma fonte aleatória não criptográfica.

import { generateLicensePlate } from '@brazilian-utils/brazilian-utils';

generateLicensePlate(); // 'ABC1K23' (Mercosul, o padrão)
generateLicensePlate('LLLNNNN'); // 'ABC1234'
generateLicensePlate('LLLNNLN'); // 'ABC1K23' (um formato fora dos dois em circulação cai no padrão)

Convert to mercosul

• JavaScript, biblioteca
• Python, biblioteca8 casos falham
• Go, biblioteca
• Ruby, biblioteca
• Rust, biblioteca
• .NET, biblioteca
• Erlang, biblioteca8 casos falham

Converte uma placa no formato antigo (LLLNNNN) para o padrão Mercosul (LLLNLNN). O 5º caractere, um dígito, vira uma letra, de 0 a 9 para A a J (ABC1234 vira ABC1C34). O resultado fica em maiúsculas e sem máscara.

A conversão segue a tabela do Anexo II da Resolução CONTRAN nº 969/2022. Todos os outros caracteres ficam como estão.

• A placa é lida como licensePlate.isValid a lê: qualquer caixa, a máscara (ABC-1234, ABC 1234) aceita, espaços nas pontas ignorados, e um caractere de máscara ou qualquer outro caractere em outra posição a torna inválida. Até a 2.4.0 esses caracteres eram removidos, então A-BC1234 era convertida.
• Retorna uma string vazia, não null, quando o valor não é uma placa válida no formato antigo: uma placa que já é Mercosul (ABC1D23), a sequência extinta LLLNNLN, um tamanho errado ou um valor inválido.

import { convertLicensePlateToMercosul } from '@brazilian-utils/brazilian-utils';

convertLicensePlateToMercosul('ABC1234'); // 'ABC1C34'
convertLicensePlateToMercosul('abc-1234'); // 'ABC1C34'
convertLicensePlateToMercosul('ABC1D23'); // '' (já está no formato Mercosul)

Get format

• JavaScript, biblioteca
• Python, biblioteca
• Go, biblioteca3 casos falham
• Ruby, biblioteca
• Rust, biblioteca
• .NET, biblioteca
• Erlang, biblioteca11 casos falham

Detecta o formato de uma placa: LLLNNNN para o formato antigo, LLLNLNN para Mercosul.

• A placa é lida como licensePlate.isValid a lê: qualquer caixa, espaços nas pontas ignorados, e a máscara (espaço, ., - ou /) aceita só entre o terceiro caractere e os quatro últimos. Um caractere de máscara em outro lugar, ou qualquer outro caractere, torna o valor inválido. Até a 2.4.0 esses caracteres eram removidos, então A-BC1234 dava LLLNNNN.
• Retorna null quando o valor não tem 7 letras e dígitos em um dos dois formatos, inclusive a sequência extinta LLLNNLN.
• Retorna null exatamente quando licensePlate.isValid retorna false.

import { getFormatLicensePlate } from '@brazilian-utils/brazilian-utils';

getFormatLicensePlate('ABC-1234'); // 'LLLNNNN'
getFormatLicensePlate('ABC1D23'); // 'LLLNLNN'
getFormatLicensePlate('ABC12D3'); // null (não é uma sequência Mercosul)
getFormatLicensePlate('INVALID'); // null
getFormatLicensePlate('ABC1234EXTRA'); // null (caracteres em excesso)