Desafio TypeScript

Acesso seguro com noUncheckedIndexedAccess

Enunciado

Implemente uma função somaArray que recebe um array de números e retorna a soma de todos os elementos. O código deve compilar com noUncheckedIndexedAccess ativo, tratando o fato de que o acesso por índice pode retornar undefined.

Requisitos

  • A função deve se chamar somaArray.
  • O parâmetro deve ser number[].
  • O retorno deve ser number.
  • Deve usar um loop ou método que lide com undefined nos acessos por índice.
  • Deve compilar sem erros com noUncheckedIndexedAccess ativo.

Código inicial

// Complete a função para somar os elementos com noUncheckedIndexedAccess ativo.
function somaArray(numeros: number[]): number {
  let soma = 0;
  for (let i = 0; i < numeros.length; i++) {
    soma += numeros[i]; // Erro: numeros[i] pode ser undefined
  }
  return soma;
}

console.log(somaArray([1, 2, 3, 4]));

Saída esperada

10
Ver dica

Você pode verificar se numeros[i] é undefined antes de somar, ou usar for...of que não sofre desse problema.

Mostrar solução 
// Função que soma os elementos de um array, tratando possíveis undefined.
function somaArray(numeros: number[]): number {
  let soma = 0;
  for (let i = 0; i < numeros.length; i++) {
    const valor = numeros[i]; // tipo: number | undefined
    if (valor !== undefined) {
      soma += valor; // só soma se não for undefined
    }
  }
  return soma;
}

console.log(somaArray([1, 2, 3, 4])); // 10

Passo a passo

  1. Declaramos somaArray recebendo numeros: number[] e retornando number.
  2. Inicializamos soma com 0.
  3. Usamos um loop for com índice i de 0 até numeros.length - 1.
  4. Dentro do loop, atribuímos numeros[i] a valor. Com noUncheckedIndexedAccess, o tipo de valor é number | undefined.
  5. Verificamos se valor !== undefined antes de somar.
  6. Se não for undefined, somamos a soma.
  7. Retornamos soma ao final.

Por que funciona

Com noUncheckedIndexedAccess, o TypeScript assume que qualquer acesso por índice pode retornar undefined, mesmo que o array não seja esparso. Isso força você a verificar a existência do elemento. No exemplo, a verificação if (valor !== undefined) faz o type narrowing e permite a soma segura. Isso evita erros como somar undefined a um número, que resultaria em NaN.

Erros comuns

  • Somar diretamente: soma += numeros[i]; gera erro: "Object is possibly 'undefined'".
  • Usar !: soma += numeros[i]!; compila, mas pode causar NaN se o array tiver buracos.
  • Ignorar a opção: Se noUncheckedIndexedAccess não estiver ativo, o código original compila, mas é menos seguro.

Outra forma de resolver

Use for...of para iterar diretamente sobre os valores, evitando o problema de índice:

function somaArray(numeros: number[]): number {
  let soma = 0;
  for (const valor of numeros) {
    soma += valor; // valor é number, sem undefined
  }
  return soma;
}

Essa abordagem é mais limpa e idiomática quando você não precisa do índice.

Saída esperada

10