Variáveis e tipos básicos

// Placar de um jogador: const para o nome, let para o que muda.
const jogador: string = 'Duda';
let vidas: number = 3;
let pontos: number = 0;

console.log(`Jogador: ${jogador}`);
console.log(`Início: ${vidas} vidas, ${pontos} pontos`);

// Fase 1: só ganha pontos.
pontos += 50;
console.log(`Fase 1: ${vidas} vidas, ${pontos} pontos`);

// Fase 2: ganha 30 pontos, mas perde uma vida.
pontos += 30;
vidas -= 1;
console.log(`Fase 2: ${vidas} vidas, ${pontos} pontos`);

// Bônus: os pontos dobram.
pontos *= 2;
console.log(`Bônus: ${vidas} vidas, ${pontos} pontos`);

// Vida extra no fim da partida.
vidas++;
console.log(`Final: ${vidas} vidas, ${pontos} pontos`);

Passo a passo

1. jogador é const porque o nome não muda durante a partida; vidas e pontos são let porque recebem valores novos a cada evento.
2. As anotações : string e : number deixam explícito o tipo de cada variável. Mesmo com let, o tipo fica fixo: só o valor muda.
3. pontos += 50 é o mesmo que pontos = pontos + 50, só que mais curto. Na fase 2, += e -= atualizam as duas variáveis.
4. pontos *= 2 multiplica e guarda de volta, transformando 80 em 160.
5. vidas++ soma 1 à variável; é a forma usual de contar "mais um".
6. Cada console.log repete o mesmo molde de texto, então a saída mostra a evolução do placar passo a passo.

Por que funciona

O programa roda de cima para baixo e cada operação parte do valor atual da variável. Por isso os resultados (50, 80, 160) são calculados pelo código, e não digitados: se a pontuação de uma fase mudar, as linhas seguintes se ajustam sozinhas. A escolha entre const e let documenta a intenção: quem lê sabe na hora o que pode mudar.

Erros comuns

• Declarar const pontos: number = 0; e depois fazer pontos += 50: o tsc acusa TS2588 ("Cannot assign to 'pontos' because it is a constant") e o Node lança TypeError: Assignment to constant variable. Use let.
• Escrever pontos = 160; no bônus: a saída fica igual, mas o requisito pede o cálculo com *= e o valor deixa de acompanhar as fases anteriores.
• Atribuir texto a uma variável number, como vidas = 'duas';: erro TS2322 no tsc. O let permite trocar o valor, não o tipo.

Outra forma de resolver

Como os valores iniciais deixam o tipo óbvio, dá para escrever let vidas = 3; e deixar o TypeScript inferir number. Também é possível guardar o molde da linha numa função placar(): string para não repetir o template literal; vale a pena quando o formato da linha começa a crescer.

Saída esperada

Jogador: Duda
Início: 3 vidas, 0 pontos
Fase 1: 3 vidas, 50 pontos
Fase 2: 2 vidas, 80 pontos
Bônus: 2 vidas, 160 pontos
Final: 3 vidas, 160 pontos

// Pedido da loja: os campos chegam do formulário como texto.
const quantidadeTexto: string = '3';
const precoTexto: string = '19.90';
const cupomTexto: string = '10';
const campoInvalido: string = 'dois';

// Number() converte o texto em número antes de qualquer conta.
const quantidade: number = Number(quantidadeTexto);
const preco: number = Number(precoTexto);
const cupom: number = Number(cupomTexto);

console.log(`quantidade: '${quantidadeTexto}' (${typeof quantidadeTexto}) -> ${quantidade} (${typeof quantidade})`);
console.log(`preco: '${precoTexto}' (${typeof precoTexto}) -> ${preco} (${typeof preco})`);

const subtotal: number = quantidade * preco;
const desconto: number = (subtotal * cupom) / 100;
const total: number = subtotal - desconto;

// toFixed(2) só na hora de exibir: as contas usam o valor exato.
console.log(`Subtotal: R$ ${subtotal.toFixed(2)}`);
console.log(`Desconto (${cupom}%): R$ ${desconto.toFixed(2)}`);
console.log(`Total: R$ ${total.toFixed(2)}`);

// Texto que não representa número vira NaN.
const valida: boolean = !Number.isNaN(Number(campoInvalido));
console.log(`Campo '${campoInvalido}' válido? ${valida}`);

Passo a passo

1. Os quatro campos são string, como chegariam de um formulário ou de um arquivo de texto.
2. Number(quantidadeTexto) converte '3' em 3, e Number(precoTexto) converte '19.90' em 19.9. As constantes recebem a anotação number, que é o tipo devolvido por Number().
3. As duas primeiras linhas usam typeof antes e depois da conversão, mostrando que o valor passou de string para number.
4. O subtotal é 3 * 19.9, o desconto é 10% do subtotal e o total é a diferença. Os parênteses em (subtotal * cupom) / 100 deixam a ordem da conta clara.
5. toFixed(2) aparece só na exibição. Ele arredonda para duas casas e devolve texto, por isso não é usado nas contas.
6. Number('dois') dá NaN; Number.isNaN devolve true, e o ! inverte o resultado para responder "é válido?".

Por que funciona

Operações aritméticas só fazem sentido com number, e o tsc impede que um string entre direto numa multiplicação. A conversão explícita torna esse passo visível no código. O resultado exato de 3 * 19.9 é 59.699999999999996, por causa da forma como o computador guarda decimais; arredondar só na exibição evita acumular esses pequenos erros nas contas seguintes.

Erros comuns

• Somar sem converter: quantidadeTexto + precoTexto não dá erro no tsc (+ também junta textos), mas resulta em '319.90'. Converta antes.
• Testar NaN com igualdade: Number('dois') === NaN é sempre false, porque NaN não é igual nem a si mesmo. Use Number.isNaN.
• Anotar const subtotal: number = (quantidade * preco).toFixed(2);: erro TS2322, pois toFixed devolve string.

Outra forma de resolver

parseFloat(precoTexto) também converte texto em número e ignora o que vier depois dos dígitos (parseFloat('19.90 reais') dá 19.9). Ele é útil para textos "sujos", mas pode esconder erros de digitação; para campos que deveriam conter só o número, Number() é mais rigoroso.

Saída esperada

quantidade: '3' (string) -> 3 (number)
preco: '19.90' (string) -> 19.9 (number)
Subtotal: R$ 59.70
Desconto (10%): R$ 5.97
Total: R$ 53.73
Campo 'dois' válido? false

// Multas da biblioteca: null para o que falta, ?? para exibir um padrão.
const MULTA_POR_DIA: number = 1.5;

function multa(diasAtraso: number): number {
  return diasAtraso * MULTA_POR_DIA;
}

// Monta a linha de um empréstimo, com a multa em reais.
function linha(livro: string, diasAtraso: number): string {
  return `${livro}: ${diasAtraso} dia(s) de atraso, multa R$ ${multa(diasAtraso).toFixed(2)}`;
}

const leitora: string = 'Marina';
// A leitora não informou telefone: o valor é null, não uma string vazia.
const telefone: string | null = null;
// O aviso só existe se as multas passarem do limite.
let aviso: string | null = null;
let total: number = 0;

console.log(`Leitora: ${leitora}`);
console.log(`Telefone: ${telefone ?? 'não informado'}`);

console.log(linha('Dom Casmurro', 0));
total += multa(0);
console.log(linha('Iracema', 4));
total += multa(4);
console.log(linha('O Guarani', 2));
total += multa(2);

if (total > 5) {
  aviso = 'Pagar antes do próximo empréstimo';
}

console.log(`Total de multas: R$ ${total.toFixed(2)}`);
console.log(`Aviso: ${aviso ?? 'nenhum'}`);

Passo a passo

1. MULTA_POR_DIA guarda o valor da multa num só lugar; o nome em maiúsculas é uma convenção comum para constantes de configuração.
2. multa recebe os dias de atraso e devolve o valor em reais. A anotação ): number garante que ela sempre devolva um número.
3. linha monta o texto de um empréstimo e reaproveita multa, formatando o valor com toFixed(2).
4. telefone é const com o tipo string | null: o valor ausente é representado por null, e não por uma string vazia que poderia ser confundida com um dado digitado.
5. aviso também é string | null, mas é let, porque pode receber um texto mais adiante. total é let e começa em 0 para acumular as multas.
6. Cada empréstimo imprime a sua linha e soma a multa com total += multa(...).
7. O if só atribui o aviso quando o total passa de 5. Como o total é 9, o aviso recebe o texto.
8. As linhas de telefone e aviso usam ??: se o valor for null, aparece o texto padrão.

Por que funciona

O tipo string | null diz ao tsc que o valor pode faltar, e o operador ?? trata exatamente esse caso na hora de exibir. Com strict, escrever let aviso: string = null; seria erro: o compilador obriga a declarar a ausência no tipo, e quem usar a variável fica sabendo que precisa lidar com ela.

O total nasce em 0 e cresce a cada +=, então mudar os dias de atraso muda o total e, por consequência, a decisão sobre o aviso, sem tocar no resto do código. As multas (0, 6 e 3) são múltiplos exatos de 1,5, então a soma dá exatamente 9.

Erros comuns

• Declarar let aviso: string = null;: no modo strict o tsc acusa TS2322 ("Type 'null' is not assignable to type 'string'"). Inclua null no tipo: string | null.
• Usar aviso || 'nenhum' no lugar de ??: aqui a saída seria igual, mas || também troca uma string vazia '', o que pode esconder um valor real. ?? reage só a null e undefined.
• Declarar const total: number = 0; e depois usar total += ...: erro TS2588, porque uma const não pode ser reatribuída. Acumuladores são let.
• Testar if (total > 5) { let aviso = '...'; }: isso cria outra variável que só existe dentro do bloco, e a de fora continua null. Atribua sem let.

Outra forma de resolver

O aviso pode ser calculado numa única expressão com o ternário, o que permite const: const aviso: string | null = total > 5 ? 'Pagar antes do próximo empréstimo' : null;. É preferível quando a decisão é simples e acontece num só ponto; o if com let fica mais claro quando o aviso pode ser definido em vários lugares do programa.

Saída esperada

Leitora: Marina
Telefone: não informado
Dom Casmurro: 0 dia(s) de atraso, multa R$ 0.00
Iracema: 4 dia(s) de atraso, multa R$ 6.00
O Guarani: 2 dia(s) de atraso, multa R$ 3.00
Total de multas: R$ 9.00
Aviso: Pagar antes do próximo empréstimo