Como implementar a validação do CPF em JS
Quem lida com a criação de softwares para a internet, muitas vezes precisa lidar com campos de formulários que exigem um CPF válido, certo? Na maioria das ocasiões isso ocorre quando é necessário fazer um teste para submissão dos atributos desenvolvidos.
Diante desse cenário, a dúvida mais comum até mesmo entre programadores experientes, gira em torno de como funciona o processo de validar o CPF em JS.
A boa notícia é que a coisa é bem mais simples do que parece inicialmente. Na sequência você entende o porquê.
Função e análise do código para verificar JS
De modo geral, o primeiro detalhe a ter em mente é que a validação é feita a partir da fórmula do CPF. Mas o que isso significa?
Na prática quer dizer que o fato de um número ser válido não significa exatamente que se trata de um CPF de uma pessoa real cadastrado na Receita Federal.
Na verdade, a verificação atesta apenas que se trata de um padrão numérico coerente, ou seja, que segue os padrões de criação de um CPF normal.
Isso é o suficiente para que os desenvolvedores de softwares tenham números que sejam aceitos nos testes dos sistemas desenvolvidos sem que isso implique em problemas futuros na aplicação.
Dito isso, para quem deseja saber se um número de CPF de fato existe e qual é a situação cadastral do mesmo, é preciso consultar diretamente no site da Receita Federal.
Agora, com tudo esclarecido, vamos à função para validar CPF em Javascript. Para isso, temos então o seguinte código:
'use strict';
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
(function () {
var root = (typeof self === 'undefined' ? 'undefined' : _typeof(self)) === 'object' && self.self === self && self || (typeof global === 'undefined' ? 'undefined' : _typeof(global)) === 'object' && global.global === global && global || this;
var CPF = function CPF() { };
if (typeof exports !== 'undefined' && !exports.nodeType) {
if (typeof module !== 'undefined' && !module.nodeType && module.exports) {
exports = module.exports = CPF;
}
exports.CPF = CPF;
} else {
root.CPF = CPF;
}
var calcChecker1 = function calcChecker1(firstNineDigits) {
var sum = null;
for (var j = 0; j < 9; ++j) {
sum += firstNineDigits.toString().charAt(j) * (10 - j);
}
var lastSumChecker1 = sum % 11;
var checker1 = lastSumChecker1 < 2 ? 0 : 11 - lastSumChecker1;
return checker1;
};
var calcChecker2 = function calcChecker2(cpfWithChecker1) {
var sum = null;
for (var k = 0; k < 10; ++k) {
sum += cpfWithChecker1.toString().charAt(k) * (11 - k);
}
var lastSumChecker2 = sum % 11;
var checker2 = lastSumChecker2 < 2 ? 0 : 11 - lastSumChecker2;
return checker2;
};
CPF.validate = function (value) {
if (!value || value === true) {
return;
}
if (typeof value === 'number') {
value = String(value);
}
var cleanCPF = value.replace(/[^d]/g, '');
var firstNineDigits = cleanCPF.substring(0, 9);
var checker = cleanCPF.substring(9, 11);
if (cleanCPF.length !== 11) {
return false;
}
// Checking if all digits are equal
for (var i = 0; i < 10; i++) {
if ('' + firstNineDigits + checker === Array(12).join(i)) {
return false;
}
}
var checker1 = calcChecker1(firstNineDigits);
var checker2 = calcChecker2('' + firstNineDigits + checker1);
if (checker.toString() === checker1.toString() + checker2.toString()) {
return true;
} else {
return false;
}
};
return CPF;
})();Note que com a variável “cleanCPF“, todos os caracteres que não constituem números são removidos e alocados como parâmetro. Isso elimina uma possível máscara.
Além disso, é importante observar a variável “firstNineDigits” que pega os primeiros 9 dígitos da string gerada a partir da variável “cleanCPF“, enquanto a variável “checker” pega os últimos 2 dígitos.
Essa parte é fundamental para que, se aplicado o algoritmo do CPF sobre um valor como “111.111.111-11” ele identifique que embora este tenha os dígitos verificadores ideais, ele NÃO é um CPF válido.
Além disso, temos a variável (calcChecker1), a parte da verificação que determina o primeiro dígito verificador consoante ao algoritmo, obtido a partir da variável “firstNineDigits“.
Por outro lado, a variável (calcChecker2) tem a missão de obter o segundo dígito verificador da variável “firstNineDigits“, o que é feito após a verificação do primeiro.
Finalmente, o processo final da validade do número CPF é realizada mediante a comprovação da variável “checker” com a combinação das os resultados das variáveis “calccChecker1” e “calcChecker2“. Se os números coincidem então o CPF é considerado válido.
Exemplo de Javascript para CPF em execução
Nosso sistema para gerar CPF aqui no site utiliza um modelo similar. A boa notícia, portanto, é que você enquanto desenvolvedor, não precisa desenvolver uma função javascript particular para obter CPFs válidos para testar em seu sistema.
Em vez disso, basta visitar nossa ferramenta para gerar e atestar a validade do CPF. Além disso, você também pode entender sobre como: