Curso extremamente confuso.

Estou revendo o módulo de Formatação de CPF pela terceira vez em dois dias para tentar entender a didática do professor. Além da péssima didática, ele acaba passando códigos para acompanhar o projeto que contém erro , assim, acabam por não validar os campos como o código demonstrado por ele na aula.

Opa, boa tarde Lucas, beleza?

Essa multiplicação de caracteres que ele fala existe um nome, é uma expressão regular (https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions).. É um termo um pouco confuso mesmo, aqui na Alura se eu não me engano tem um módulo só focado nisso, tenta dar uma olhada depois. O professor pode não ter explicado pra não prolongar muito entrando em expressões.

Sobre o exercício tenta dar uma olhadinha com calma (sei que provavelmente você já deve ter feito isso, mas é sempre bom revisar quando se trata de programar).

Então vitor, no caso, eu tenho certo conhecimento em RegEx, mas essa expressão especificamente me causou extrema confusão. Não consegui entender até agora o porquê dela validar o CPF.

Ele escreveu algo do tipo :

let soma = (11 * 1) + (10 * 2) + (9 * 3) ... (2 * 0)

 let digitoVerificador = 11 - (soma % 11)

Desculpa a demora em responder, ando meio corrido com as aulas.

Dá uma olhada nesse link aqui, ele explica melhor como funciona o algoritmo de CPF: https://www.macoratti.net/alg_cpf.htm#:~:text=O%20algoritmo%20de%20valida%C3%A7%C3%A3o%20do,%3A%20111.444.777%2D05.

Oi Lucas, tudo bem?

Exatamente, foi extremamente confuso, não consegui entender nada e o código ainda está dando erro... Por acaso você sabe como arrumar o erro do CPF? Realmente não sei o que fazer :(

Beatriz, no caso, acabei por encontrar essa resolução

//Usei essa função para validar o CPF, com base no retorno das funções checaCPFRepetido e checaEstruturaCPF
function validaCPF(input) {
    const cpfFormatado = input.value.replace(/\D/g, '')
    let mensagem = ''

    if(!checaCPFRepetido(cpfFormatado) || !checaEstruturaCPF(cpfFormatado)) {
        mensagem = 'O CPF digitado não é válido.'
    }

    input.setCustomValidity(mensagem)
}



//Essa função é a que verifica se o CPF contém caracteres repetidos
    function checaCPFRepetido(cpf) {
        const valoresRepetidos = [
            '00000000000',
            '11111111111',
            '22222222222',
            '33333333333',
            '44444444444',
            '55555555555',
            '66666666666',
            '77777777777',
            '88888888888',
            '99999999999'
        ]
        let cpfValido = true

        valoresRepetidos.forEach(valor => {
            if(valor == cpf) {
               cpfValido = false
            }
        })

        return cpfValido
    }


    //Essa é a função que checa a estrutura do CPF, com base na função do digito verificador
    function checaEstruturaCPF(cpf) {
        const multiplicador = 10
        return checaDigitoVerificador(cpf, multiplicador)
    }


//Essa é a função que checa o digito verificador no CPF
    function checaDigitoVerificador(cpf, multiplicador) {
        if(multiplicador >= 12) {
            return true
    }

    let multiplicadorInicial = multiplicador
    let soma = 0
    const cpfSemDigitos = cpf.substr(0, multiplicador - 1).split('')
    const digitoVerificador = cpf.charAt(multiplicador - 1)
    for(let contador = 0; multiplicadorInicial > 1 ; multiplicadorInicial--) {
        soma = soma + cpfSemDigitos[contador] * multiplicadorInicial
        contador++
    }

    if(digitoVerificador == confirmaDigito(soma)) {
        return checaDigitoVerificador(cpf, multiplicador + 1)
    }

    return false    
    }

A validação dos dígitos no CPF, nada mais é do que checar se :

"529.982.247-25

Sendo 25 = dígitos verificadores, serão duas etapas para verificar a validez de um CPF:

*Primeira checagem: * Para checar o primeiro dígito, no caso, (2), você multiplica todos os outros dígitos, pela sua posição no Array, porém, do menor ao maior No caso, você multiplica os dígitos, sem contar os verificadores

(5 * 10)+ (2 * 9) + (9 * 8) + (9 * 7) + (8 * 6) + (2 * 5) + (2 * 4) + (4 * 3) + (7 * 2) = 295

Você pega o resultado dessa fórmula, multiplica por 10, que é a posição do primeiro digito, e divide por 11, que é a posição do segundo digito. (29510) / 11 = 268,18181818182 =~ 268.*2**

O resultado que nos interessa na verdade é o RESTO da divisão. Se ele for igual ao primeiro dígito verificador (primeiro dígito depois do '-'), a primeira parte da validação está correta.

Segunda checagem: * Para checar o segundo dígito, no caso, (5). (5 * 11)+ (2 * 10) + (9 *9) + (9 * 8) + (8 * 7) + (2 * 6) + (2 *5) + (4 * 4) + (7 * 3) + (22) = 347

Você pega o resultado dessa fórmula, multiplica por 10, que é a posição do primeiro digito, e divide por 11, que é a posição do segundo digito. (34710) / 11 = 315.4545454545 =~ 315.*5**

Se ele for igual ao segundo dígito verificador (segundo dígito depois do '-'), a segunda parte da validação está correta.

Show gostei da tua explicaç