Artigos Delphi Validando o CNPJ em uma Aplicação Delphi

Cadastro de Pessoa Física (CNPJ)
Este artigo apresenta como é realizada a validação de um número de CNPJ que é o documento de identificação do contribuinte Pessoa Jurídica perante a Receita Federal.

O CNPJ é um número formado por 14 dígitos dos quais os dois últimos são chamados de dígitos verificadores (DV). Cada DV é calculado com base nos dígitos anteriores e juntos servem para validar o número do CNPJ como um todo. Assim, torna-se importante quando um número de CNPJ é digitado pelo usuário final em uma aplicação utilizar a função isCNPJ, implementada na biblioteca de códigos "ValidaCNPJ" apresentada na Listagem 1, para verificar se o número informado está correto evitando, por exemplo, o cadastro de CNPJs inválidos.

Para exemplificar o algoritmo de verificação do CNPJ será utilizado como exemplo o CNPJ número 14.572.457.0001-85.

O cálculo dos DVs é executado em duas etapas usando para isto o módulo de divisão 11 (módulo de divisão é a parte inteira do resultado de uma divisão):

Para calcular o 1º dígito verificador:
a) Cada um dos doze primeiros números do CNPJ, a partir do 12º número até o 1º, é multiplicado por um peso que começa de 2 e que vai sendo incrementado de 1 a cada passo, somando-se as parcelas calculadas. Sempre que o peso atingir o valor 10 ele deve novamente receber o valor inicial 2:
1 0 0 0 7 5 4 2 7 5 4 1  
X X X X X X X X X X X X  
2 3 4 5 6 7 8 9 2 3 4 5  
2 0 0 0 42 35 32 18 14 15 16 5 soma das parcelas = 179

b) calcula-se o dígito através da seguinte expressão:
  179 % 11 = 3
obs. se o resto da divisão (operador %) calculado for 0 ou 1, o dígito verificador será 0; nos outros casos, o dígito verificador é definido pela expressão: 11 - 3 = 8

Para calcular o 2º dígito verificador:
a) Cada um dos treze primeiros números do CNPJ, a partir do primeiro DV (13º número) até o 1º, é multiplicado por um peso que começa de 2 e que vai sendo incrementado de 1 a cada passo, somando-se as parcelas calculadas. Sempre que o peso atingir o valor 10 ele deve novamente receber o valor inicial 2:
8 1 0 0 0 7 5 4 2 7 5 4 1  
X X X X X X X X X X X X X  
2 3 4 5 6 7 8 9 2 3 4 5 6  
16 3 0 0 0 49 40 36 4 21 20 20 6 soma das parcelas = 215

b) calcula-se o dígito através da seguinte expressão:
  215 % 11 = 6
obs. se o resto da divisão (operador %) calculado for 0 ou 1, o dígito verificador será 0; nos outros casos, o dígito verificador é definido pela expressão: 11 - 6 = 5

Desenvolvendo a Aplicação Delphi
Criar uma nova aplicação no ambiente de desenvolvimento Delphi 7 através da opção do menu "File|New|Application..." e realizar os três passos descritos a seguir:

1º Passo:
Desenvolver o formulário principal da aplicação como sugere a Figura 1. Atenção: observe que as caixas de textos explicativos utilizadas na figura apresentam a ordem sequencial e o nome do componente, a página da sua localização e as propriedades que devem ser alteradas com os respectivos valores.


Figura 1. Formulário principal da aplicação.

2º Passo:
Na unidade de códigos (unit), apresentada na Listagem 1, construída através da opção do menu "File|New|Unit" deve-se implementar os subprogramas:
 a) isCNPJ- retorna um valor booleano que indica se o número de CNPJ é válido ou inválido;
b) imprimeCNPJ- retorna o CNPJ formatado na máscara: 99.999.999.9999-99.

Listagem 1. Unit "ValidaCNPJ" com as funções "isCNPJ" e "imprimeCNPJ". 

unit ValidaCNPJ;

interface
function isCNPJ(CNPJ: string): boolean;
function imprimeCNPJ(CNPJ: string): string;

implementation
uses SysUtils; // necessário para utilizar a função "StrToInt"

function isCNPJ(CNPJ: string): boolean;
var   dig13, dig14: string;
    sm, i, r, peso: integer;
begin
// length - retorna o tamanho da string do CNPJ (CNPJ é um número formado por 14 dígitos)
  if ((CNPJ = '00000000000000') or (CNPJ = '11111111111111') or
      (CNPJ = '22222222222222') or (CNPJ = '33333333333333') or
      (CNPJ = '44444444444444') or (CNPJ = '55555555555555') or
      (CNPJ = '66666666666666') or (CNPJ = '77777777777777') or
      (CNPJ = '88888888888888') or (CNPJ = '99999999999999') or
      (length(CNPJ) <> 14))
     then begin
            isCNPJ := false;
            exit;
          end;

// "try" - protege o código para eventuais erros de conversão de tipo através da função "StrToInt"
  try
{ *-- Cálculo do 1o. Digito Verificador --* }
    sm := 0;
    peso := 2;
    for i := 12 downto 1 do
    begin
// StrToInt converte o i-ésimo caractere do CNPJ em um número
      sm := sm + (StrToInt(CNPJ[i]) * peso);
      peso := peso + 1;
      if (peso = 10)
         then peso := 2;
    end;
    r := sm mod 11;
    if ((r = 0) or (r = 1))
       then dig13 := '0'
    else str((11-r):1, dig13); // converte um número no respectivo caractere numérico

{ *-- Cálculo do 2o. Digito Verificador --* }
    sm := 0;
    peso := 2;
    for i := 13 downto 1 do
    begin
      sm := sm + (StrToInt(CNPJ[i]) * peso);
      peso := peso + 1;
      if (peso = 10)
         then peso := 2;
    end;
    r := sm mod 11;
    if ((r = 0) or (r = 1))
       then dig14 := '0'
    else str((11-r):1, dig14);

{ Verifica se os digitos calculados conferem com os digitos informados. }
    if ((dig13 = CNPJ[13]) and (dig14 = CNPJ[14]))
       then isCNPJ := true
    else isCNPJ := false;
  except
    isCNPJ := false
  end;
end;

function imprimeCNPJ(CNPJ: string): string;
begin
{ máscara do CNPJ: 99.999.999.9999-99 }
  imprimeCNPJ := copy(CNPJ, 1, 2) + '.' + copy(CNPJ, 3, 3) + '.' +
    copy(CNPJ, 6, 3) + '.' + copy(CNPJ, 9, 4) + '-' + copy(CNPJ, 13, 2);
end;

end.

As unidades ou bibliotecas de códigos (unit's) representam no Delphi a forma de disponibilizar um conjunto de subprogramas (functions e/ou procedures) destinados a solucionar uma série de tarefas bastante corriqueiras, como por exemplo, a função para validar números de CNPJ. Na Listagem 2 pode-se observar a estrutura básica de uma unit.

Listagem 2. Estrutura básica de uma unit.
// Cabeçalho da unidade de códigos.
// Atenção: O nome interno da unit deve ser o mesmo nome dado ao arquivo fonte
unit NomeDaUnit;

interface
// Comunicação entre dois meios (dispositivos). Contêm o cabeçalho
// dos procedimentos e funções declarados na unit, declaração
// de objetos globais e o uso de outras unidades.

implementation
// Corpo dos procedimentos e funções anunciados na seção de
// interface e declarações de objetos locais.
end.

Outro aspecto destacável da programação foi a utilização da estrutura de controle de erros "try – except - end" que irá proteger o código para eventuais erros de conversão de tipo com a função "StrToInt".

3º Passo:
Agora novamente no formulário principal da aplicação deve-se:
3.1: fazer a referência a unit "ValidaCNPJ", implementada no passo 2, através da opção do menu "File|Use Unit..." . A conclusão deste passo resulta na seguinte linha de código:
uses ValidaCNPJ;

3.2: implementar o seguinte código no evento "onClick" do botão "Verificar CNPJ":
// usando as funções isCNPJ e imprimeCNPJ da unit "ValidaCNPJ"
if isCNPJ(CNPJ.Text)
   then Result.Caption := imprimeCNPJ(CNPJ.Text)
else Result.Caption := 'Erro: CNPJ inválido !!!';

Veja também: Validando o CPF em uma Aplicação Delphi.

Ilustrando a execução da aplicação::
1. CNPJ 44.444.444.4444-44 é inválido:

 2. CNPJ é um número formado por 14 dígitos:
3. Existem caracteres alfabéticos no CNPJ:
 
4. CNPJ informado está correto (ou válido):
 

Obrigado e um abraço.

Prof. Omero Francisco Bertol (http://www.pb.utfpr.edu.br/omero/)
Aplicações Delphi (http://www.pb.utfpr.edu.br/omero/Delphi/Exercicios.htm)
Download da Aplicação (http://www.pb.utfpr.edu.br/omero/Delphi/Artigos/CNPJ_Delphi.rar)