Como fazer uma verificação de nome no Back-end?

Olá, Luidi! Como vai?

É possível sim fazer verificações no back-end para garantir que os nomes estejam no formato desejado. Embora muitas dessas validações também possam ser feitas no front-end, é importante garantir a integridade dos dados no back-end, já que ele é o responsável final pelo processamento e armazenamento das informações.

Aqui estão algumas sugestões para implementar uma verificação de nome completo no back-end usando JavaScript:

1. Remover espaços extras: Você pode usar o método trim() para remover espaços no início e no final de uma string. Para remover espaços extras entre palavras, você pode usar uma expressão regular.

2. Quantidade mínima de letras: Para verificar a quantidade mínima de letras em cada palavra, você poderia dividir o nome em palavras e verificar o comprimento de cada uma. No entanto, como você mencionou, existem nomes curtos como "Li", então talvez seja melhor não impor um limite mínimo muito rigoroso.

3. Aceitar sinais específicos: Você pode usar expressões regulares para permitir apenas certos caracteres. Por exemplo, você pode permitir letras, espaços, apóstrofos e hífens.

Aqui está um exemplo de como você poderia implementar essa verificação:

function validarNomeCompleto(nome) {
  // Remove espaços extras no início, no final e entre as palavras
  nome = nome.trim().replace(/\s+/g, ' ');

  // Expressão regular para validar o nome
  // Aceita letras, espaços, apóstrofos e hífens
  const regex = /^[a-zA-ZÀ-ÿ' -]+$/;

  if (!regex.test(nome)) {
    return false; // Nome inválido
  }

  // Verifica se cada palavra tem pelo menos 1 letra
  const palavras = nome.split(' ');
  for (const palavra of palavras) {
    if (palavra.length < 1) {
      return false; // Palavra muito curta
    }
  }

  return true; // Nome válido
}

// Exemplo de uso
const nome = "Maria D'ávila";
console.log(validarNomeCompleto(nome)); // true

Esse código faz uma verificação básica, mas você pode ajustá-lo conforme suas necessidades específicas, como adicionar mais caracteres permitidos ou ajustar o comprimento mínimo das palavras.

Espero ter ajudado e bons estudos!

Eu devo aceitar o hifen para o nome? Ou é melhor só aceitar letras e o apóstrofo como "Maria d'Ávila"? Se aceitar o hifen a pessoa vai poder colocar em qualquer lugar como "Lu-iz" como resolver isso? E se aceitar hifen, devemos aceitar só 1 ou mais de 1? O mesmo raciocinio vale para o apóstrofo. Além disso a pessoa pode colocar "Maria Z'ávlia" q não existe pq o "Z" nao pode antes do apóstrofo, como resolver isso? Devemos permitir determinadas letras antes do apóstrofo ou aceitar todas? Não tem uma biblioteca q faça todas essas validações do nome?

Olá, Luidi!

O problema aqui é definir regras claras para o uso de hífen, apóstrofo e ordem dos caracteres no nome. Resolva fazendo o seguinte: estabeleça regras fixas e valide cada uma no back-end, sem depender apenas de regex única. Isso evita aceitar coisas como "Lu-iz" ou "Z'ávlia".

Veja este exemplo de validação robusta aplicada passo a passo:

// regras permitidas:
// - apenas letras (incluindo acentos)
// - 1 apóstrofo OU 1 hífen por palavra (opcional)
// - apóstrofo ou hífen nunca podem iniciar ou terminar a palavra
// - nenhuma combinação inválida como "Z'ávlia" será aceita

function validarNomeCompleto(nome) {
  const nomeLimpo = nome
    .trim()
    .replace(/\s+/g, ' ');

  const palavras = nomeLimpo.split(' ');

  for (const palavra of palavras) {

    // impede palavras vazias
    if (palavra.length < 1) return false;

    // impede começar ou terminar com sinal
    if (/^['-]|['-]$/.test(palavra)) return false;

    // permitir apenas letras + um apóstrofo ou hífen
    if (!/^[A-Za-zÀ-ÿ'-]+$/.test(palavra)) return false;

    // impedir mais de 1 apóstrofo ou hífen
    const qtdApostrofo = (palavra.match(/'/g) || []).length;
    const qtdHifen     = (palavra.match(/-/g) || []).length;

    if (qtdApostrofo > 1 || qtdHifen > 1) return false;

    // impedir colocação no meio sem letras válidas ao redor
    if (palavra.includes("'")) {
      const [antes, depois] = palavra.split("'");
      if (antes.length === 0 || depois.length === 0) return false;
    }

    if (palavra.includes("-")) {
      const [antes, depois] = palavra.split("-");
      if (antes.length === 0 || depois.length === 0) return false;
    }
  }

  return true;
}

// Exemplos
console.log(validarNomeCompleto("Maria D'Ávila")); // true
console.log(validarNomeCompleto("João-Pedro"));   // true
console.log(validarNomeCompleto("Lu-iz"));        // false
console.log(validarNomeCompleto("Z'ávlia"));      // false

Pontos importantes:

• Aceitar hífen é comum, pois muitos nomes utilizam (João-Pedro, Ana-Clara).
• Aceitar apóstrofo também, mas apenas 1 por palavra e nunca isolado.
• Não restrinja letras específicas antes ou depois do apóstrofo, apenas garanta que haja letra válida nos dois lados.
• Não existe biblioteca amplamente utilizada que trate nomes completos com todas essas regras culturais — por isso validações manuais são o caminho mais seguro.

Fico à disposição!