Decisões com condicionais

// Frete da loja por faixa de valor da compra.
function frete(compra: number): number {
  // As faixas vão da maior para a menor: a primeira que passar vence.
  if (compra >= 200) {
    return 0;
  } else if (compra >= 100) {
    return 10;
  } else {
    return 20;
  }
}

function resumo(compra: number): void {
  const valorFrete = frete(compra);
  // Ternário escolhe o texto do frete.
  const textoFrete = valorFrete === 0 ? 'frete grátis' : `frete R$ ${valorFrete.toFixed(2)}`;
  const total = compra + valorFrete;
  console.log(`Compra de R$ ${compra.toFixed(2)}: ${textoFrete}, total R$ ${total.toFixed(2)}`);
}

resumo(250);
resumo(120);
resumo(45.5);
resumo(200);

Passo a passo

1. frete recebe o valor da compra e devolve o frete como number. A anotação ): number faz o tsc reclamar se algum caminho ficar sem return.
2. O primeiro teste é compra >= 200, a faixa mais alta. Se ele falhar, o else if testa compra >= 100, e o else cobre o resto.
3. Em resumo, o frete é calculado uma vez e guardado em valorFrete, para não chamar a função duas vezes.
4. O ternário valorFrete === 0 ? 'frete grátis' : ... escolhe o texto: com ===, a comparação é exata entre dois números.
5. total soma a compra e o frete, e toFixed(2) formata os três valores em reais só na hora de imprimir.
6. A compra de 200 mostra o limite: >= inclui o próprio 200 na faixa grátis.

Por que funciona

Numa cadeia if / else if / else, só o primeiro bloco verdadeiro roda. Ordenar as faixas da maior para a menor garante que cada compra caia na faixa certa sem precisar escrever intervalos completos como compra >= 100 && compra < 200: se o programa chegou ao else if, já se sabe que a compra é menor que 200.

Erros comuns

• Inverter a ordem: com if (compra >= 100) primeiro, a compra de 250 paga R$ 10,00 de frete, porque o teste de 200 nunca é alcançado. Teste a faixa mais alta antes.
• Usar > no lugar de >=: compra > 200 cobra frete da compra de exatamente 200, e a última linha sai errada.
• Imprimir o valor sem formatar: R$ ${compra} mostra R$ 45.5 e R$ 250, diferente da saída esperada. Use toFixed(2) em todos os valores em reais.

Outra forma de resolver

Como cada ramo só devolve um valor, dá para usar if com return antecipado e dispensar os else: if (compra >= 200) return 0; if (compra >= 100) return 10; return 20;. O resultado é o mesmo e fica mais curto; a cadeia com else deixa explícito que os casos são exclusivos.

Saída esperada

Compra de R$ 250.00: frete grátis, total R$ 250.00
Compra de R$ 120.00: frete R$ 10.00, total R$ 130.00
Compra de R$ 45.50: frete R$ 20.00, total R$ 65.50
Compra de R$ 200.00: frete grátis, total R$ 200.00

// Horário da biblioteca: switch com cases agrupados e um tipo união.
type Dia = 'segunda' | 'terça' | 'quarta' | 'quinta' | 'sexta' | 'sábado' | 'domingo';

function estaAberta(dia: Dia, hora: number): boolean {
  switch (dia) {
    // Dias úteis compartilham o mesmo horário: cases empilhados.
    case 'segunda':
    case 'terça':
    case 'quarta':
    case 'quinta':
    case 'sexta':
      return hora >= 8 && hora < 20;
    case 'sábado':
      return hora >= 9 && hora < 13;
    case 'domingo':
      return false;
  }
}

function consultar(dia: Dia, hora: number): void {
  const situacao = estaAberta(dia, hora) ? 'aberta' : 'fechada';
  console.log(`${dia} às ${hora}h: ${situacao}`);
}

consultar('segunda', 19);
consultar('quarta', 7);
consultar('sexta', 20);
consultar('sábado', 12);
consultar('sábado', 15);
consultar('domingo', 10);

Passo a passo

1. type Dia lista os sete textos aceitos. Com ele, consultar('sabado', 12) (sem acento) é erro no tsc, e não um dia que cai silenciosamente no caso errado.
2. Os cinco dias úteis são case empilhados sem código entre eles: qualquer um dos cinco chega ao mesmo return.
3. hora >= 8 && hora < 20 exige as duas condições. O < (e não <=) faz a hora de fechar já contar como fechada.
4. O sábado tem a própria regra, e o domingo devolve false direto.
5. Não há default: os sete valores do tipo estão cobertos, e o tsc sabe que a função sempre devolve um boolean.
6. Em consultar, o ternário converte o boolean em 'aberta' ou 'fechada' antes de imprimir.

Por que funciona

O switch compara o mesmo valor (dia) com várias opções fixas, situação em que ele é mais legível que uma cadeia de if com ||. O tipo união fecha a lista de opções: o compilador confere tanto as chamadas (nenhum dia inventado) quanto o switch (nenhum dia esquecido, senão a função poderia terminar sem return).

Erros comuns

• Esquecer um dia no switch, por exemplo o 'domingo': o tsc acusa TS2366 ("Function lacks ending return statement and return type does not include 'undefined'"). Cubra todos os valores ou acrescente um default.
• Usar hora <= 20: a consulta de sexta às 20h sai "aberta", diferente da saída esperada.
• Trocar && por ||: hora >= 8 || hora < 20 é verdadeiro para qualquer hora, e a biblioteca nunca fecha nos dias úteis.

Outra forma de resolver

Uma cadeia de if resolve o mesmo: if (dia === 'domingo') return false; if (dia === 'sábado') return hora >= 9 && hora < 13; return hora >= 8 && hora < 20;. É mais curta aqui, mas o switch fica mais claro quando cada grupo de dias tem uma regra diferente e a lista de casos cresce.

Saída esperada

segunda às 19h: aberta
quarta às 7h: fechada
sexta às 20h: fechada
sábado às 12h: aberta
sábado às 15h: fechada
domingo às 10h: fechada

// Boletim: narrowing com typeof, if/else if e switch exaustivo com never.
type Situacao = 'aprovado' | 'recuperacao' | 'reprovado' | 'reprovado-por-falta';

// A prova final pode ter nota ou a marca 'ausente'.
function notaDaFinal(final: number | 'ausente'): number {
  // Depois do typeof, o TypeScript sabe que final é number.
  if (typeof final === 'number') {
    return final;
  }
  return 0; // ausência conta como zero
}

function situacao(media: number, frequencia: number): Situacao {
  // A falta vem primeiro: reprova mesmo com média alta.
  if (frequencia < 75) {
    return 'reprovado-por-falta';
  } else if (media >= 7) {
    return 'aprovado';
  } else if (media >= 5) {
    return 'recuperacao';
  } else {
    return 'reprovado';
  }
}

function descrever(s: Situacao): string {
  switch (s) {
    case 'aprovado':
      return 'Aprovado';
    case 'recuperacao':
      return 'Recuperação';
    case 'reprovado':
      return 'Reprovado';
    case 'reprovado-por-falta':
      return 'Reprovado por falta';
    default: {
      // Um caso novo em Situacao sem case aqui vira erro no tsc.
      const impossivel: never = s;
      return impossivel;
    }
  }
}

function boletim(
  aluno: string,
  nota1: number,
  nota2: number,
  final: number | 'ausente',
  frequencia: number,
): void {
  const media = (nota1 + nota2 + notaDaFinal(final)) / 3;
  const texto = descrever(situacao(media, frequencia));
  console.log(
    `${aluno}: notas ${nota1}, ${nota2}, ${final} | média ${media.toFixed(1)} | freq. ${frequencia}% -> ${texto}`,
  );
}

console.log('Boletim do 1º bimestre');
boletim('Ana', 8, 7.5, 9, 90);
boletim('Bruno', 6, 5, 4.5, 85);
boletim('Caio', 9, 8, 'ausente', 95);
boletim('Duda', 9, 9.5, 10, 60);
boletim('Eva', 3, 4, 'ausente', 80);

Passo a passo

1. Situacao é uma união de quatro literais. Ela documenta todos os resultados possíveis e permite que o tsc confira o switch mais adiante.
2. notaDaFinal recebe number | 'ausente'. Dentro do if (typeof final === 'number'), o TypeScript sabe que final é number e deixa devolvê-lo; fora dele, só resta 'ausente', que vale zero.
3. situacao testa a frequência antes da média, porque a falta reprova independentemente da nota. Depois, as faixas de média vão da maior para a menor.
4. descrever usa switch para transformar cada situação no texto exibido. Os valores do tipo usam hífen e não têm acento; o texto para o usuário fica num só lugar.
5. No default, const impossivel: never = s; só compila porque todos os casos foram tratados antes e nada sobra para s.
6. boletim calcula a média com parênteses em volta da soma e chama as duas funções, encadeando descrever(situacao(...)).
7. O template literal mostra final como está: 9 ou ausente. A média aparece com uma casa decimal por toFixed(1), mas a comparação usa o valor exato.

Por que funciona

Cada função faz uma escolha: notaDaFinal separa os dois tipos possíveis da prova, situacao decide com uma cadeia em que só o primeiro teste verdadeiro vale, e descrever mapeia valores fixos com switch. O narrowing evita conversões manuais: o compilador acompanha o typeof e só deixa usar final como número no trecho em que isso é garantido.

O never transforma o switch num contrato. Se a escola criar a situação 'aprovado-com-louvor' e alguém esquecer o case, o tsc acusa "Type '"aprovado-com-louvor"' is not assignable to type 'never'" na linha do default, antes de o boletim sair com um texto faltando.

Erros comuns

• Testar a média antes da frequência: a Duda (média 9.5, frequência 60%) sai "Aprovado". Coloque frequencia < 75 no primeiro if.
• Somar final direto: (nota1 + nota2 + final) / 3 dá erro no tsc (TS2365: o operador + não se aplica a number e a uma união que inclui texto). Passe antes por notaDaFinal.
• Comparar com o texto do usuário: case 'Recuperação': em descrever é erro TS2678, porque esse literal não faz parte de Situacao. Use os valores do tipo.
• Esquecer um case e manter o default com never: é exatamente o erro que ele existe para mostrar. Acrescente o case que falta, não remova a checagem.

Outra forma de resolver

notaDaFinal cabe numa linha com o ternário: return final === 'ausente' ? 0 : final;. A comparação com o literal também estreita o tipo, então final é number no segundo ramo. Para descrever, um objeto Record<Situacao, string> com os quatro textos substituiria o switch; ele é preferível quando cada caso só devolve um valor fixo, enquanto o switch acomoda lógica diferente em cada ramo.

Saída esperada

Boletim do 1º bimestre
Ana: notas 8, 7.5, 9 | média 8.2 | freq. 90% -> Aprovado
Bruno: notas 6, 5, 4.5 | média 5.2 | freq. 85% -> Recuperação
Caio: notas 9, 8, ausente | média 5.7 | freq. 95% -> Recuperação
Duda: notas 9, 9.5, 10 | média 9.5 | freq. 60% -> Reprovado por falta
Eva: notas 3, 4, ausente | média 2.3 | freq. 80% -> Reprovado