1
resposta

[Projeto] Exercício: Percorrendo listas com for

Nessa versão, Number(input) trataria entradas vazias como 0, então precisei verificar manualmente se a entrada veio vazia.

import { createInterface } from "readline";

const rl = createInterface({
  input: process.stdin,
  output: process.stdout,
});

const perguntar = (pergunta) => {
  return new Promise((resolve) => {
    rl.question(pergunta, resolve);
  });
};

const validarNum = (input) => {
  const num = Number(input);

  if (input.trim() === "" || Number.isNaN(num) || num < 0) return null;
  return num;
};

// O exercício solicita especificamente o uso de for
const somarDespesas = (listaDespesas) => {
  let soma = 0;

  for (let i = 0; i < listaDespesas.length; i++) {
    soma += listaDespesas[i];
  }

  return soma;
};

const main = async () => {
  try {
    console.log("CALCULADORA DE DESPESAS");
    console.log("Insira o valor das despesas. ['fim' para encerrar]");

    const listaDespesas = [];

    while (true) {
      const input = await perguntar("> R$");

      if (input.trim().toLowerCase() === "fim") break;

      const despesa = validarNum(input);

      if (despesa === null) {
        console.log("Use apenas números ou finalize com 'fim'");
        continue;
      }

      listaDespesas.push(despesa);
    }

    console.log(listaDespesas);

    console.log(
      `Total de despesas: R$${somarDespesas(listaDespesas).toFixed(2)}`,
    );
  } catch (error) {
    console.log("Algo deu errado. Reinicie a aplicação");
  } finally {
    rl.close();
  }
};

main();
1 resposta

Olá, Vitor Hugo! Como vai?

Excelente resolução! Você elevou o nível do exercício de arrays para uma aplicação de terminal robusta e muito bem estruturada. O uso de Promises com readline para lidar com entradas assíncronas é uma técnica de nível intermediário/avançado que mostra que você já está confortável com o fluxo de execução do Node.js.

Destaques Técnicos do seu Código

  • Validação Rigorosa: Sua observação sobre o Number(input) converter strings vazias em 0 foi cirúrgica. Ao adicionar o input.trim() === "", você evitou que o usuário "sujasse" a lista de despesas acidentalmente.
  • Controle de Fluxo Assíncrono: O uso de async/await dentro do while(true) criou um loop de interação muito limpo e fácil de ler.
  • Tratamento de Erros: O bloco try/catch/finally garante que o recurso rl.close() seja executado independentemente de erros, o que evita que o processo do Node fique "pendurado" no terminal.

Analisando o Laço for

Como o exercício solicitava especificamente o for clássico, sua implementação na função somarDespesas está perfeita:

for (let i = 0; i < listaDespesas.length; i++) {
    soma += listaDespesas[i];
}

Este laço é a base de tudo. No futuro, você verá que o JavaScript moderno oferece "açúcares sintáticos" como o .reduce(), mas entender o funcionamento do índice (i) e do limite (length) é fundamental para algoritmos mais complexos.

Dica para Evolução: O for...of

Já que você está dominando os laços, vale conhecer o for...of. Ele é uma evolução do for clássico para quando não precisamos do número do índice, apenas do valor de cada item:

const somarDespesas = (listaDespesas) => {
  let soma = 0;
  for (const despesa of listaDespesas) {
    soma += despesa;
  }
  return soma;
};

Isso deixaria sua função ainda mais limpa!

Para fechar, uma dúvida técnica: você já pensou em como faria para exibir não só o total, mas também qual foi a maior despesa inserida usando esse mesmo laço for?

Parabéns pelo capricho no código, Vitor!