Variável e tipo de dado: o que o programa guarda

Variável é um nome que aponta para um valor durante a execução; tipo de dado descreve quais operações fazem sentido para esse valor. Nome, valor e tipo formam o estado que seu algoritmo transforma.

O domínio será o saldo de uma conta de cursos. A entrada informa créditos e compras, o processamento atualiza o saldo e a saída mostra o estado. Se essa divisão ainda estiver nova, revise entrada, processamento e saída.

A etiqueta e o conteúdo

Pense numa etiqueta colada num compartimento: saldo é a etiqueta e 1500 é o conteúdo encontrado por esse nome. A analogia termina aí. O JavaScript não promete uma caixinha física por variável, e objetos podem compartilhar referências ao mesmo valor.

let saldo = 1500;
console.log('nome: saldo');
console.log('valor:', saldo);
console.log('tipo:', typeof saldo);

typeof permite observar o tipo em tempo de execução. Ele é útil para diagnóstico, mas não substitui um contrato de entrada: descobrir tarde que um preço virou texto ainda deixa o erro acontecer.

Dar nome é decidir o papel do dado

x obriga quem lê a reconstruir o contexto. saldoEmCentavos declara conteúdo e unidade. Compare o efeito no mesmo cálculo:

const saldoEmCentavos = 150000;
const compraEmCentavos = 2490;
const saldoFinalEmCentavos = saldoEmCentavos - compraEmCentavos;

console.log(saldoFinalEmCentavos);

O nome não muda o resultado do Node, mas reduz decisões escondidas. Se parte do sistema usa reais e outra usa centavos, o nome impede uma soma tecnicamente válida e comercialmente errada.

Atribuição não é igualdade

Em matemática, = afirma igualdade. Em programação, a atribuição lê o valor da direita e o associa ao nome da esquerda. A nova atribuição substitui a anterior:

let saldo = 100;
saldo = saldo + 40;
saldo = saldo - 15;

console.log(saldo);

Na linha saldo = saldo + 40, o lado direito usa o valor antigo, calcula 140 e só então atualiza o nome. Ler da direita para a esquerda elimina a aparente contradição “saldo é igual a saldo mais quarenta”.

Número, texto e booleano resolvem o começo

Número representa quantidades; string representa texto; booleano representa uma condição com dois estados. As aspas fazem parte da decisão de tipo:

const preco = 29.9;
const curso = 'Lógica';
const pagamentoConfirmado = false;

console.log(typeof preco, preco);
console.log(typeof curso, curso);
console.log(typeof pagamentoConfirmado, pagamentoConfirmado);

Um CEP parece número, mas você não soma CEPs e precisa preservar zero inicial; portanto ele é texto. O tipo nasce do uso, não da aparência.

O tipo decide o que o operador faz

O operador + soma números e concatena strings. Uma mudança invisível de tipo muda o algoritmo:

console.log(2 + 2);
console.log('2' + '2');
console.log('2' + 2);

Esse é o erro clássico de formulário: campos chegam como texto. Somar sem converter produz um resultado que parece número, mas é junção de caracteres.

Rastreando saldo ao longo de sete atribuições

A tabela foi preenchida acompanhando o estado depois de cada operação e confirmada pelo Node:

let saldo = 1000;
const operacoes = [
  ['depósito', 500],
  ['compra', -200],
  ['bônus', 50],
  ['mensalidade', -100],
  ['estorno', 200],
  ['taxa', -20],
];

console.log('inicial', typeof saldo, saldo);
for (const [nome, valor] of operacoes) {
  saldo = saldo + valor;
  console.log(nome, typeof saldo, saldo);
}

O teste de mesa formaliza essa leitura. Uma linha por mudança permite localizar o primeiro ponto em que o estado diverge do esperado.

A linha em que o saldo vira texto

Agora uma entrada chega como '200'. O operador troca de soma para concatenação:

let saldo = 1500;
const depositoDigitado = '200';

saldo = saldo + depositoDigitado;
console.log(typeof saldo, saldo);
saldo = saldo - 100;
console.log(typeof saldo, saldo);

O segundo passo volta a número porque - não concatena e força conversão. Isso não corrige o saldo: agora existe um número absurdo. O primeiro estado errado foi 1500200, então é ali que a investigação começa.

Converta e valide na entrada:

const saldo = 1500;
const depositoDigitado = '200';
const deposito = Number(depositoDigitado);

if (!Number.isFinite(deposito)) throw new TypeError('Depósito inválido');
console.log(saldo + deposito);

Const protege a associação, não congela tudo

Reatribuir uma constante produz um erro real. Capturamos a mensagem para manter o exemplo legível:

const limite = 3;

try {
  limite = 4;
} catch (erro) {
  console.log(`${erro.name}: ${erro.message}`);
}

Use const por padrão porque ele reduz as linhas capazes de trocar a associação. Use let para contador, acumulador e estado que realmente evolui. Não use var no código novo de iniciante; seu escopo e içamento adicionam regras sem benefício aqui.

Missão: modelar um boletim escolar

Liste nome do aluno, três notas, quantidade de faltas e situação de aprovação. Para cada variável, anote nome, exemplo de valor, tipo e motivo. Depois execute uma amostra:

const aluno = 'Rafaela';
const notas = [8, 7.5, 9];
const faltas = 3;
const media = notas.reduce((soma, nota) => soma + nota, 0) / notas.length;
const aprovado = media >= 7 && faltas <= 10;

console.log({ aluno, media, faltas, aprovado });

Revise o modelo procurando três cheiros. Primeiro, nomes sem unidade, como tempo, quando segundos e minutos podem se misturar. Segundo, sentinelas mágicas, como usar -1 para significar ausente sem documentar o contrato. Terceiro, booleanos com negação no nome, que produzem leituras como “não não está bloqueado”. Corrija o vocabulário antes de adicionar mais condições.

Também distinga estado derivado de estado fonte. media pode ser calculada a partir de notas; se você guarda os dois e altera apenas um, eles divergem. Calcule valores derivados no ponto de uso ou atualize-os por uma única função. Menos estados independentes significam menos combinações inválidas para rastrear.

No boletim, registre ainda o contrato de ausência. Nota não lançada não é zero, porque zero é uma nota possível. Use uma representação que obrigue o processamento a decidir antes de calcular. Essa escolha evita uma média tecnicamente válida construída com dado que ainda não existe.

O critério de sucesso é justificar o tipo pelo uso, não pelo conteúdo aparente. Em seguida, estude operadores e expressões para prever como esses valores se combinam, consulte o mapa do guia de lógica e continue pela trilha de Lógica.