1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

validação NIF

Discussão em 'Web Development' iniciada por tonebiclas, 20 de Fevereiro de 2009. (Respostas: 14; Visualizações: 11231)

  1. tonebiclas

    tonebiclas Power Member

    Boas, alguém têm algum script para validação de NIF's em PHP e/ou javascript ?

    já procurei e não encontrei, se alguem me puder ajudar agradeço.


    cumps ;)
     
  2. K0mA

    K0mA Power Member

    A titulo de curiosidade, e lembro que alguem ca no forum o perguntou, aqui fica a formula para validação do numero de contribuinte.

    Quote:
    Mensagem Original de CONTRIBUINTE
    - Tem que ter 9 dígitos
    - O primeiro dígito tem que ser 1, 2, 5, 6, 8 ou 9
    - A soma de controle dada por 9xd1+8xd2+7xd3+6xd4+5xd5+4xd6+3xd7+2xd8+d9 tem que ser múltipla de 11 (congruente com o módulo 11, isto é, dê resto 0 quando dividida por 11). d1 é o dígito mais à esquerda, e d9 o digito mais à direita (digito de controle).
    - d9, em alguns casos, precisava de ter o valor 10, para que a soma de controle fosse divisível por 11. Neste caso d9 tomará o valor 0. Nitidamente uma decisão mal tomada, pois um dígito de controle igual a zero, poderá significar uma soma de controle correcta ou uma cujo resto da divisão por onze dá 1. O dígito de controle deveria ser, por exemplo, uma letra com os 11 possíveis valores de A a K. Por curiosidade, o mesmo erro, existe na validação dos BI.


    Quote:
    Mensagem Original de BILHETE DE IDENTIDADE
    A- Tomemos o número 8074662-4 como exemplo, e onde o último 4 é o algarismo mistério.
    B- Para verificar a veracidade deste número multiplica-se o último algarismo por 1 (4x1), o penúltimo algarismo por 2 (2x2), o antepenúltimo por 3 (6x3), e assim sucessivamente. Somando no final todos estes produtos, obtem-se 176.
    [(4x1) + (2x2) + (6x3) + (6x4) + (4x5) + (7x6) + (0x7) + (8x8) = 176]
    C- Divide-se este resultado por 11 e chega-se a um número que deverá ser inteiro
    [176 : 11 = 16].
    D- Se o resultado dessa divisão por 11 não der número inteiro, isso significa que o vosso B.I. é falso.
     
    Última edição pelo moderador: 20 de Fevereiro de 2009
  3. eralha

    eralha Power Member

    Não conhecia estes calculos de validações, apesar de saber que existiam, como nunca precisei em nenhum projecto. Fica já o conhecimento :D
     
  4. hostmake

    hostmake Power Member

    Tu também postaste isto no PortugalCode, e eu respondi-te lá no fórum.
    Mas como partilhar o conhecimento é engraçado, eu deixo aqui também a função que fiz.

    PHP:
    <?php
    function validarNIF($nif) {
        if ( (!
    is_null($nif)) && (is_numeric($nif)) && (strlen($nif)==9) && ($nif[0]==|| $nif[0]==|| $nif[0]==|| $nif[0]==|| $nif[0]==|| $nif[0]==9) ) {
            
    $dC $nif[0] * 9;
            for (
    $i=2;$i<=8;$i++)
                
    $dC += ($nif[$i-1])*(10-$i);
            
    $dC 11-($dC 11);
            
    $dC = ($dC>=10)?0:$dC;
            if (
    $dC==$nif[8])
                return 
    TRUE;
        }
    }

    $var validarNIF("123456789");

    if (
    $var)
    echo 
    "é valido";
    else
    echo 
    "é invalido";
    ?>
     
  5. tonebiclas

    tonebiclas Power Member

  6. boas

    ja tentei tudo e nao sei o que é que esta errado no meu calculo do nif
    o codigo esta em C#

    private Boolean ValidateContribuinte()
    {

    Boolean resultado = false;


    str_nif = tb_contribuinte.Text.Trim();
    double nif =0;


    try
    {
    nif = int.Parse(str_nif);




    if (str_nif.Length != 9)
    {
    resultado = false;
    }
    else
    {
    if (str_nif.StartsWith("1") || str_nif.StartsWith("2")
    || str_nif.StartsWith("5") || str_nif.StartsWith("6")
    || str_nif.StartsWith("7") || str_nif.StartsWith("8")
    || str_nif.StartsWith("9")
    )
    {

    int control = Convert.ToInt32(str_nif[0]) * 9;
    for (int j = 2; j <= 8; j++)
    {
    control += (10 - j) * Convert.ToInt32(str_nif[j-1]);
    }


    control = 11 - (control % 11);
    if (control >= 10)
    {
    control = 0;
    }


    if (control == Convert.ToInt32(str_nif[8]))
    {
    resultado = true;
    }
    else
    {
    resultado = false;
    }


    }


    }

    }
    catch
    {
    resultado = false;
    }
    return resultado;
    }
     
  7. ByMySlf

    ByMySlf Power Member

    Creio que assim funcionará...

    Código:
            Match match = Regex.Match(str_nif, @"\d{9}");
            
            if (match.Success)
            {
                 //Se o NIF for válido....    
            }
    
     
  8. obrigado pela dica tiras me um if/ else, e fica mais bonito o código

    eu verifiquei todas a condições 1 a 1 e o erro tem de estar neste pedaço de código

    int control = Convert.ToInt32(str_nif[0]) * 9;
    for (int j = 2; j <= 8; j++)
    {
    control += (10 - j) * Convert.ToInt32(str_nif[j-1]);
    }


    control = 11 - (control % 11);
    if (control >= 10)
    {
    control = 0;
    }


    if (control == Convert.ToInt32(str_nif[8]))
    {
    resultado = true;
    }
    else
    {
    resultado = false;
    }
     
  9. ByMySlf

    ByMySlf Power Member

    Aquele código substitui todo o teu código! Faz uso de expressões regulares para validar a string. No caso de um NIF, a string terá que ser composta por 9 algarismos.

    Código:
        private Boolean ValidateContribuinte(string str_nif) {
               Match match = Regex.Match(str_nif, @"\d{9}");
            
              if (match.Success)
              {
                    return true;   
              }
    
              return false;
        }
    
     
    Última edição: 25 de Junho de 2013
  10. Zalex

    Zalex Power Member

  11. ByMySlf

    ByMySlf Power Member

    Isto é o que faz ler somente o título e o resto, praticamente, ignorar! Portanto, estava somente a exemplificar uma validação básica.

    Para me redimir da estupidez anterior:

    Código:
         public bool IsValidNIF(string nif)
        {
            if (!Regex.IsMatch(nif, @"\d{9}"))
            {
                return false;
            }
            
            char firstChar = nif[0];
            if (firstChar.Equals('1') 
                || firstChar.Equals('2') 
                || firstChar.Equals('5') 
                || firstChar.Equals('6') 
                || firstChar.Equals('8') 
                || firstChar.Equals('9'))
            {
                int checkDigit = (Convert.ToInt32(firstChar.ToString()) * 9);
                for (int i = 2; i <= 8; ++i)
                {
                    checkDigit += Convert.ToInt32(nif[i - 1].ToString()) * (10 - i);
                }
    
                checkDigit = 11 - (checkDigit % 11);
                if (checkDigit >= 10) 
                {
                    checkDigit = 0;
                }
    
                [B]if (checkDigit.ToString() == nif[8].ToString())[/B]
                {
                    return true;
                }
            }
    
            return false;
        }
    
    O que está a bold no código acims é, precisamente, onde o teu está a falhar! Ao converteres o char para inteiro retorna-te o valor do caractere Unicode.

    Convert.ToInt32 Method (Char)
     
  12. Peter1986

    Peter1986 Power Member

    Desculpem o desenterrar do tópico mas segue validador atualizado em T-SQL:

    Código:
    declare @nif int
    set @nif = 'NIF A TESTAR' <-- PREENCHER AQUI
    declare @nifNVARCHAR nvarchar(9)
    set @nifNVARCHAR = CONVERT(nvarchar,@nif)
    declare @nifVerificar nvarchar(9)
    set @nifVerificar = ''
    declare @checkdigit int
    
    --NIF e Número de Contribuinte – Número de Identificação Fiscal
    --1 – pessoa singular
    --2 – pessoa singular
    --NIPC – Número de Identificação de Pessoa Colectiva
    --5 (pessoa colectiva),
    --6 (pessoa colectiva pública),
    --8 (empresário em nome individual),
    --9 (pessoa colectiva irregular ou número provisório).
    if(Len(@nifNVARCHAR)=9)
    begin  
        if(SUBSTRING(@nifNVARCHAR,1,1)=1 or SUBSTRING(@nifNVARCHAR,1,1)=2 or SUBSTRING(@nifNVARCHAR,1,1)=5 or SUBSTRING(@nifNVARCHAR,1,1)=6 or SUBSTRING(@nifNVARCHAR,1,1)=8 or SUBSTRING(@nifNVARCHAR,1,1)=9)
        begin
    --Para calcular o digito de controlo iremos multiplicar individualmente e por ordem os restantes 8 algarismos, fazendo-o da seguinte forma:
    --O 1.º digito multiplicamos por 9,
    --o 2.º dígito por 8,
    --3.º dígito por 7,
    --4.º dígito por 6,
    --5.º dígito por 5,
    --6.º dígito por 4,
    --7.º dígito por 3 e o
    -- 8.º dígito por 2.
    --Iremos somar todos os resultados da operação anterior.
    --Com o resultado da soma anterior iremos dividir por 11 e aproveitar o resto dessa divisão.
    --Se o resto for 0 ou 1, o dígito de controle será 0, caso seja outro algarismo, o dígito de controle será o resultado de 11 – resto.
    
        set @checkdigit = (convert(int,SUBSTRING(@nifNVARCHAR,1,1)) * 9 +
                        CONVERT(int,substring(@nifNVARCHAR,2,1)) * 8 +
                        CONVERT(int,substring(@nifNVARCHAR,3,1)) * 7 +
                        CONVERT(int,substring(@nifNVARCHAR,4,1)) * 6 +
                        CONVERT(int,substring(@nifNVARCHAR,5,1)) * 5 +
                        CONVERT(int,substring(@nifNVARCHAR,6,1)) * 4 +
                        CONVERT(int,substring(@nifNVARCHAR,7,1)) * 3 +
                        CONVERT(int,substring(@nifNVARCHAR,8,1)) * 2) % 11
        if(@checkdigit = 0 or @checkdigit = 1)
        begin
            set @nifVerificar = (SUBSTRING(@nifNVARCHAR,1,1)+
                                substring(@nifNVARCHAR,2,1)+
                                substring(@nifNVARCHAR,3,1)+
                                substring(@nifNVARCHAR,4,1)+
                                substring(@nifNVARCHAR,5,1)+
                                substring(@nifNVARCHAR,6,1)+
                                substring(@nifNVARCHAR,7,1)+
                                substring(@nifNVARCHAR,8,1)+'0')
            --select @nifVerificar                          
        end
        else
        begin
            set @nifVerificar = (SUBSTRING(@nifNVARCHAR,1,1)+
                                substring(@nifNVARCHAR,2,1)+
                                substring(@nifNVARCHAR,3,1)+
                                substring(@nifNVARCHAR,4,1)+
                                substring(@nifNVARCHAR,5,1)+
                                substring(@nifNVARCHAR,6,1)+
                                substring(@nifNVARCHAR,7,1)+
                                substring(@nifNVARCHAR,8,1)+
                                convert(nvarchar,[email protected]))
            --select @nifVerificar
        end
        if(@nifNVARCHAR like @nifVerificar)
        begin
            select 'NIF válido'
        end
        else
        begin
            select 'NIF não válido'
        end
    end
    end
    
    Fica a dica!

    Edit: Não encontrei nada de SQL na NET. Limitei-me a ler as regras e construir em SQL.
     
    Última edição: 11 de Maio de 2017
  13. Desde já obrigado pela dica... mas tenho um problema ao copiar o código:

    Na parte "set @nifVerificar " tens "convert(nvarchar,[email protected]))"

    O que é que deve estar no "email protected"?
     
  14. Microsoft SQL

    VALIDAR NIF


    Código:
    CREATE FUNCTION [dbo].[ValidarNIF]
    (
        @nif varchar(20)
    )
    RETURNS bit
    AS
    BEGIN
        -- Limpar NIF
        SET @nif=REPLACE(LTRIM(RTRIM(@nif)), ' ', '');
    
        -- Tem nove caracteres?
        IF LEN(@nif) <> 9 RETURN 0
        -- É númerico?
        IF ISNUMERIC(@nif)=0 RETURN 0
        -- O primeiro digíto tem de ser 1, 2, 5, 6, 8 ou 9
        IF SUBSTRING(@nif, 1, 1) NOT IN (1, 2, 5, 6, 8, 9) RETURN 0
    
        -- Calcular digíto de controlo
        DECLARE @digitoControlo int=(
            SUBSTRING(@nif, 1, 1) * 9 +
            SUBSTRING(@nif, 2, 1) * 8 +
            SUBSTRING(@nif, 3, 1) * 7 +
            SUBSTRING(@nif, 4, 1) * 6 +
            SUBSTRING(@nif, 5, 1) * 5 +
            SUBSTRING(@nif, 6, 1) * 4 +
            SUBSTRING(@nif, 7, 1) * 3 +
            SUBSTRING(@nif, 8, 1) * 2
        ) % 11;
    
        SET @digitoControlo=CASE WHEN @digitoControlo > 1 THEN 11 - @digitoControlo ELSE 0 END
    
        RETURN CASE WHEN @digitoControlo = SUBSTRING(@nif, 9, 1) THEN 1 ELSE 0 END
    END
    VALIDAR NISS

    Código:
    CREATE FUNCTION [dbo].[ValidarNISS]
    (
        @niss varchar(20)
    )
    RETURNS bit
    AS
    BEGIN
        -- Limpar NISS
        SET @niss=REPLACE(LTRIM(RTRIM(@niss)), ' ', '');
    
        -- Tem onze caracteres?
        IF LEN(@niss) <> 11 RETURN 0
        -- É númerico?
        IF ISNUMERIC(@niss)=0 RETURN 0
        -- O primeiro digíto tem de ser 1 (pessoa singular) ou 2 (pessoa coletiva)
        IF SUBSTRING(@niss, 1, 1) NOT IN (1, 2) RETURN 0
    
        -- Calcular digíto de controlo
        DECLARE @digitoControlo int=(
            SUBSTRING(@niss, 1, 1) * 29 +
            SUBSTRING(@niss, 2, 1) * 23 +
            SUBSTRING(@niss, 3, 1) * 19 +
            SUBSTRING(@niss, 4, 1) * 17 +
            SUBSTRING(@niss, 5, 1) * 13 +
            SUBSTRING(@niss, 6, 1) * 11 +
            SUBSTRING(@niss, 7, 1) * 7 +
            SUBSTRING(@niss, 8, 1) * 5 +
            SUBSTRING(@niss, 9, 1) * 3 +
            SUBSTRING(@niss, 10, 1) * 2
        ) % 10;
    
        SET @digitoControlo = 9 - @digitoControlo
    
        RETURN CASE WHEN @digitoControlo = SUBSTRING(@niss, 11, 1) THEN 1 ELSE 0 END
    END
     
  15. Microsoft SQL

    VALIDAR CARTÃO DE CIDADÃO
    Código:
    CREATE FUNCTION [dbo].[ValidarCartaoCidadao]
    (
        @cc varchar(20)
    )
    RETURNS bit
    AS
    BEGIN
        -- Limpar CC
        SET @cc = REPLACE(LTRIM(RTRIM(UPPER(@cc))), ' ', '');
    
        -- Tem doze caracteres?
        IF LEN(@cc) <> 12 RETURN 0
     
        -- Soma
        DECLARE @soma int = 0;
     
        -- Valor do caracter calculado no loop
        DECLARE @val int = 0;
    
        -- Index do loop
        DECLARE @idx int = LEN(@cc);
    
        WHILE @idx > 0
            BEGIN
                SET @val =
                    CASE SUBSTRING(@cc, @idx, 1)
                        WHEN '0' THEN 00
                        WHEN '1' THEN 01
                        WHEN '2' THEN 02
                        WHEN '3' THEN 03
                        WHEN '4' THEN 04
                        WHEN '5' THEN 05
                        WHEN '6' THEN 06
                        WHEN '7' THEN 07
                        WHEN '8' THEN 08
                        WHEN '9' THEN 09
                        WHEN 'A' THEN 10
                        WHEN 'B' THEN 11
                        WHEN 'C' THEN 12
                        WHEN 'D' THEN 13
                        WHEN 'E' THEN 14
                        WHEN 'F' THEN 15
                        WHEN 'G' THEN 16
                        WHEN 'H' THEN 17
                        WHEN 'I' THEN 18
                        WHEN 'J' THEN 19
                        WHEN 'K' THEN 20
                        WHEN 'L' THEN 21
                        WHEN 'M' THEN 22
                        WHEN 'N' THEN 23
                        WHEN 'O' THEN 24
                        WHEN 'P' THEN 25
                        WHEN 'Q' THEN 26
                        WHEN 'R' THEN 27
                        WHEN 'S' THEN 28
                        WHEN 'T' THEN 29
                        WHEN 'U' THEN 30
                        WHEN 'V' THEN 31
                        WHEN 'W' THEN 32
                        WHEN 'X' THEN 33
                        WHEN 'Y' THEN 34
                        WHEN 'Z' THEN 35
                    END
             
                -- A cada index ímpar
                IF @idx % 2 <> 0
                    BEGIN
                        -- Multiplica-se o valor obtido por 2
                        SET @val = @val * 2;
    
                        -- Caso seja superior a 9, subtrai 9 ao valor
                        IF @val > 9
                            SET @val = @val - 9;
                    END
    
                -- Soma o valor obtido à soma total
                SET @soma = @soma + @val;
    
                -- Index
                SET @idx = @idx - 1;
            END
    
        RETURN CASE WHEN @soma % 10 = 0 THEN 1 ELSE 0 END
    END
     
    Última edição: 5 de Dezembro de 2017 às 13:16

Partilhar esta Página