<h2>Estruturas de Controle: Dominando o Fluxo do Seu Código</h2>
<p>Estruturas de controle são o coração de qualquer programa. Elas permitem que seu código tome decisões, execute blocos específicos sob certas condições e evite repetição desnecessária de lógica. Nesta aula, exploraremos as quatro principais: <code>if</code>, <code>else</code>, <code>switch</code> e <code>match</code>. Começaremos com as mais tradicionais e evoluiremos para a mais moderna.</p>
<h2>if e else: A Base da Tomada de Decisão</h2>
<h3>Conceito Fundamental</h3>
<p>O <code>if</code> executa um bloco de código <strong>somente se</strong> uma condição for verdadeira. O <code>else</code> oferece uma alternativa quando a condição é falsa. Essa é a estrutura mais fundamental da programação.</p>
<pre><code class="language-python">idade = 18
if idade >= 18:
print("Você é maior de idade")
else:
print("Você é menor de idade")</code></pre>
<pre><code class="language-javascript">let temperatura = 35;
if (temperatura > 30) {
console.log("Está quente");
} else if (temperatura > 20) {
console.log("Está agradável");
} else {
console.log("Está frio");
}</code></pre>
<h3>Boas Práticas</h3>
<p>Sempre mantenha suas condições simples e legíveis. Use <code>else if</code> para múltiplas condições, mas quando tiver muitas branches, considere usar <code>switch</code>. Evite condições muito complexas — se necessário, extraia a lógica em funções separadas para melhorar a legibilidade.</p>
<pre><code class="language-java">int nota = 85;
if (nota >= 90) {
System.out.println("A");
} else if (nota >= 80) {
System.out.println("B");
} else if (nota >= 70) {
System.out.println("C");
} else {
System.out.println("F");
}</code></pre>
<h2>switch: Alternativa Elegante para Múltiplas Condições</h2>
<h3>Quando Usar switch</h3>
<p>O <code>switch</code> é ideal quando você precisa comparar uma única variável contra múltiplos valores específicos. É mais legível que vários <code>else if</code> e geralmente mais eficiente. A grande diferença: <code>switch</code> usa igualdade exata, não condições lógicas complexas.</p>
<pre><code class="language-python">dia = 3
match dia:
case 1:
print("Segunda-feira")
case 2:
print("Terça-feira")
case 3:
print("Quarta-feira")
case _:
print("Outro dia")</code></pre>
<pre><code class="language-javascript">let fruta = "maçã";
switch (fruta) {
case "maçã":
console.log("R$ 3,00");
break;
case "banana":
console.log("R$ 2,00");
break;
case "laranja":
console.log("R$ 2,50");
break;
default:
console.log("Fruta não encontrada");
}</code></pre>
<h3>Detalhe Crítico: break</h3>
<p>Em linguagens como C, Java e JavaScript, <strong>sempre use <code>break</code></strong> após cada caso. Sem ele, a execução "cai" para o próximo caso (fall-through). Isso é um erro comum que pode levar a bugs difíceis de encontrar. Python 3.10+ e Rust não têm esse problema.</p>
<pre><code class="language-java">int opcao = 2;
switch (opcao) {
case 1:
System.out.println("Opção 1");
break;
case 2:
System.out.println("Opção 2");
break;
default:
System.out.println("Opção inválida");
}</code></pre>
<h2>match: A Evolução Moderna</h2>
<h3>A Nova Geração</h3>
<p><code>match</code> é a versão moderna e mais segura de <code>switch</code>. Disponível em Python 3.10+, Rust, Scala e outras linguagens, <code>match</code> força você a lidar com todos os casos possíveis (exhaustividade), elimina o risco de fall-through e permite padrões muito mais complexos.</p>
<pre><code class="language-python"># Python 3.10+
status = "processando"
match status:
case "ativo":
print("Sistema rodando normalmente")
case "inativo":
print("Sistema desligado")
case "processando":
print("Aguarde...")
case _:
print("Status desconhecido")</code></pre>
<h3>Padrões Avançados</h3>
<p><code>match</code> vai além de igualdade simples. Você pode usar destructuring, guards (condições adicionais), e até padrões estruturais. Isso o torna muito mais poderoso que <code>switch</code> tradicional.</p>
<pre><code class="language-python"># Python com padrões avançados
ponto = (0, 5)
match ponto:
case (0, 0):
print("Origem")
case (0, y):
print(f"Eixo Y: {y}")
case (x, 0):
print(f"Eixo X: {x}")
case (x, y):
print(f"Ponto: ({x}, {y})")</code></pre>
<pre><code class="language-rust">// Rust - match com guards
let numero = 15;
match numero {
n if n < 0 => println!("Negativo"),
n if n == 0 => println!("Zero"),
n if n < 10 => println!("Dígito"),
_ => println!("Número maior"),
}</code></pre>
<h2>Escolhendo a Estrutura Correta</h2>
<p>A escolha entre <code>if</code>, <code>switch</code> e <code>match</code> depende do seu caso:</p>
<ul>
<li><strong><code>if/else</code></strong>: Use para lógica condicional complexa com múltiplas condições diferentes. Exemplo: <code>if (idade > 18 && ativo)</code>.</li>
<li><strong><code>switch</code></strong>: Use quando comparar uma variável contra vários valores específicos. Rápido de ler, mas limitado a igualdade.</li>
<li><strong><code>match</code></strong>: Use quando disponível. É type-safe, obriga tratar todos os casos e permite padrões sofisticados.</li>
</ul>
<pre><code class="language-python"># Exemplo prático: classificar usuário
class Usuario:
def __init__(self, nome, tipo, ativo):
self.nome = nome
self.tipo = tipo
self.ativo = ativo
usuario = Usuario("João", "admin", True)
if/else para lógica complexa
if usuario.ativo and usuario.tipo == "admin":
print("Acesso total concedido")
elif usuario.ativo and usuario.tipo == "user":
print("Acesso limitado")
else:
print("Acesso negado")</code></pre>
<h2>Conclusão</h2>
<p>Dominar estruturas de controle é essencial para programar bem. <strong>Primeiro ponto</strong>: <code>if</code> e <code>else</code> são universais e fundamentais — domine-os perfeitamente. <strong>Segundo ponto</strong>: <code>switch</code> é uma alternativa elegante para comparações múltiplas contra um único valor. <strong>Terceiro ponto</strong>: <code>match</code> (quando disponível) é a evolução natural, oferecendo segurança de tipo e padrões poderosos. Na prática, você usará <code>if</code> na maioria das vezes, recorrerá a <code>switch</code> ocasionalmente, e apreciará <code>match</code> quando trabalhar em linguagens modernas. O importante é entender quando cada uma brilha e escolher com propósito.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://docs.python.org/3/tutorial/controlflow.html" target="_blank" rel="noopener noreferrer">Python Official Docs - if statements</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch" target="_blank" rel="noopener noreferrer">MDN Web Docs - Switch Statement (JavaScript)</a></li>
<li><a href="https://doc.rust-lang.org/book/ch06-02-match.html" target="_blank" rel="noopener noreferrer">Rust Book - Match Expressions</a></li>
<li><a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/if.html" target="_blank" rel="noopener noreferrer">Oracle Java Docs - if-then-else Statements</a></li>
<li><a href="https://www.python.org/dev/peps/pep-0634/" target="_blank" rel="noopener noreferrer">PEP 634 - Structural Pattern Matching</a></li>
</ul>