Algoritmos

Estrutura condicional (if e else): como o programa decide

Capa do artigo Estrutura condicional (if e else): como o programa decide
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. O que é uma estrutura condicional?
  2. Como funcionam o if e o else?
  3. Como testar várias condições em sequência?
  4. Como usar if e else em Python, PHP e C?
  5. O que é um if dentro de outro?
  6. Aí você pergunta: qual é a diferença entre = e == ?
  7. Quais são os erros mais comuns com if e else?
  8. Aí você pergunta: dá para exagerar no if?
  9. Por que uma fila de elif deixa o programa mais lento?
  10. O processador também tenta adivinhar o seu if
  11. Cada if a mais é um caminho a mais para testar
  12. Quais armadilhas do if aparecem só em produção?
  13. A chave que faltou: o goto fail
  14. Zero não é vazio
  15. Dois textos diferentes, e o == diz que são iguais
  16. 0,1 + 0,2 não é 0,3
  17. O caso que ninguém previu
  18. Checar e depois agir
  19. O if que ninguém lembrava que existia
  20. Agora é com você!

Estrutura condicional é o comando que faz o programa escolher um caminho: ele testa uma condição e executa um bloco de instruções somente se ela for verdadeira. Nas linguagens deste blog, esse comando se chama if, e o caminho alternativo se chama else.

Até aqui, um algoritmo era uma lista de passos executados um depois do outro, do primeiro ao último. Com o if, o programa passa a tomar decisões. As condições quase sempre comparam o valor de uma variável, então vale ter lido variáveis e constantes. E, como os exemplos usam funções, vale passar por lá também.

Você toma decisões assim o dia inteiro. Se está chovendo, leva o guarda-chuva. Senão, sai sem ele. Repare na forma da frase: uma pergunta que só admite sim ou não, uma ação para o sim e outra para o não. O computador decide exatamente desse jeito. A diferença é que a pergunta precisa ser escrita de um modo que ele consiga responder com verdadeiro ou falso.

História em quadrinhos em três quadros: uma pessoa se pergunta se está chovendo; no caso sim, sai com o guarda-chuva na chuva; no caso não, sai sem ele em um dia de sol
A decisão do guarda-chuva: uma pergunta, uma ação para o sim e outra para o não.

O que é uma estrutura condicional?

É um comando com três partes: a palavra if, uma condição e um bloco de instruções. A condição é uma expressão avaliada pelo seu valor lógico. Se o resultado for verdadeiro, o bloco é executado. Se for falso, o bloco é ignorado e o programa segue adiante.

As condições mais comuns são comparações: maior (>), menor (<), maior ou igual (>=), menor ou igual (<=), igual (==) e diferente (!=). Cada uma delas produz verdadeiro ou falso.

Como funcionam o if e o else?

O if sozinho resolve o caso “só faça isto se…”. No programa mais abaixo, a compra ganha desconto apenas se chegar a 100. Se não chegar, nada acontece.

O else acrescenta o “senão”. Com ele, sempre um dos dois blocos é executado, e nunca os dois.

Fluxograma do if e else: a condição numero % 2 == 0 leva ao bloco que mostra é par quando verdadeira e ao bloco que mostra é ímpar quando falsa
A condição separa dois caminhos. Depois do bloco escolhido, os caminhos se juntam e o programa continua.

Como testar várias condições em sequência?

Quando há mais de dois caminhos, as condições são encadeadas. Em Python, a palavra é elif, abreviação de else if. Em PHP, é elseif. Em C, escreve-se else if. Um mesmo if pode ter vários deles, e o else no final é opcional.

A regra que você precisa gravar: as condições são testadas em ordem, de cima para baixo, e só o bloco da primeira condição verdadeira é executado. As outras são ignoradas, mesmo que também sejam verdadeiras.

Sequência de testes para a nota 6,5: nota maior ou igual a 7 é falso, nota maior ou igual a 5 é verdadeiro e o resultado é recuperação, sem consultar o else
Com a nota 6,5, a primeira pergunta falha e a segunda acerta. O programa executa esse bloco e sai da estrutura.
Ver a animação com as notas 6,5, 9 e 3
Animação do if, elif e else avaliando as notas 6,5, 9 e 3, uma condição de cada vez
A mesma estrutura leva a três resultados diferentes, conforme a primeira condição verdadeira.

Como usar if e else em Python, PHP e C?

O programa mostra os quatro formatos: if simples, if com else, condições encadeadas e um if dentro de outro. No fim, repete a classificação das notas com as condições na ordem errada.

Python:

# Estrutura condicional: if, else e elif

def situacao(nota):
    if nota >= 7:
        return "aprovado"
    elif nota >= 5:
        return "recuperação"
    else:
        return "reprovado"

def situacao_errada(nota):
    # condições na ordem errada: a primeira que for verdadeira vence
    if nota >= 5:
        return "recuperação"
    elif nota >= 7:
        return "aprovado"
    else:
        return "reprovado"

compra = 120.0
if compra >= 100:                   # if simples: só age se a condição for verdadeira
    compra = compra - 10
print("valor a pagar: %.2f" % compra)

numero = 7
if numero % 2 == 0:                 # if e else: dois caminhos, só um é executado
    print(numero, "é par")
else:
    print(numero, "é ímpar")

print("nota 9.0:", situacao(9.0))   # if, elif e else: vários caminhos
print("nota 7.0:", situacao(7.0))
print("nota 6.5:", situacao(6.5))
print("nota 5.0:", situacao(5.0))
print("nota 3.0:", situacao(3.0))

idade = 20
tem_habilitacao = False
if idade >= 18:                     # if dentro de if: a segunda pergunta depende da primeira
    if tem_habilitacao:
        print("pode dirigir")
    else:
        print("tem idade, mas falta a habilitação")
else:
    print("ainda não tem idade")

print("ordem errada, nota 9.0:", situacao_errada(9.0))

PHP:

<?php
// Estrutura condicional: if, else e elseif

function situacao(float $nota): string {
    if ($nota >= 7) {
        return "aprovado";
    } elseif ($nota >= 5) {
        return "recuperação";
    } else {
        return "reprovado";
    }
}

function situacao_errada(float $nota): string {
    // condições na ordem errada: a primeira que for verdadeira vence
    if ($nota >= 5) {
        return "recuperação";
    } elseif ($nota >= 7) {
        return "aprovado";
    } else {
        return "reprovado";
    }
}

$compra = 120.0;
if ($compra >= 100) {               // if simples: só age se a condição for verdadeira
    $compra = $compra - 10;
}
printf("valor a pagar: %.2f\n", $compra);

$numero = 7;
if ($numero % 2 == 0) {             // if e else: dois caminhos, só um é executado
    echo "$numero é par\n";
} else {
    echo "$numero é ímpar\n";
}

echo "nota 9.0: " . situacao(9.0) . "\n";   // if, elseif e else: vários caminhos
echo "nota 7.0: " . situacao(7.0) . "\n";
echo "nota 6.5: " . situacao(6.5) . "\n";
echo "nota 5.0: " . situacao(5.0) . "\n";
echo "nota 3.0: " . situacao(3.0) . "\n";

$idade = 20;
$tem_habilitacao = false;
if ($idade >= 18) {                 // if dentro de if: a segunda pergunta depende da primeira
    if ($tem_habilitacao) {
        echo "pode dirigir\n";
    } else {
        echo "tem idade, mas falta a habilitação\n";
    }
} else {
    echo "ainda não tem idade\n";
}

echo "ordem errada, nota 9.0: " . situacao_errada(9.0) . "\n";

C:

/* Estrutura condicional: if, else e else if */
#include <stdio.h>

const char *situacao(double nota) {
    if (nota >= 7) {
        return "aprovado";
    } else if (nota >= 5) {
        return "recuperação";
    } else {
        return "reprovado";
    }
}

/* condições na ordem errada: a primeira que for verdadeira vence */
const char *situacao_errada(double nota) {
    if (nota >= 5) {
        return "recuperação";
    } else if (nota >= 7) {
        return "aprovado";
    } else {
        return "reprovado";
    }
}

int main(void) {
    double compra = 120.0;
    if (compra >= 100) {            /* if simples: só age se a condição for verdadeira */
        compra = compra - 10;
    }
    printf("valor a pagar: %.2f\n", compra);

    int numero = 7;
    if (numero % 2 == 0) {          /* if e else: dois caminhos, só um é executado */
        printf("%d é par\n", numero);
    } else {
        printf("%d é ímpar\n", numero);
    }

    printf("nota 9.0: %s\n", situacao(9.0));   /* if, else if e else: vários caminhos */
    printf("nota 7.0: %s\n", situacao(7.0));
    printf("nota 6.5: %s\n", situacao(6.5));
    printf("nota 5.0: %s\n", situacao(5.0));
    printf("nota 3.0: %s\n", situacao(3.0));

    int idade = 20;
    int tem_habilitacao = 0;
    if (idade >= 18) {              /* if dentro de if: a segunda pergunta depende da primeira */
        if (tem_habilitacao) {
            printf("pode dirigir\n");
        } else {
            printf("tem idade, mas falta a habilitação\n");
        }
    } else {
        printf("ainda não tem idade\n");
    }

    printf("ordem errada, nota 9.0: %s\n", situacao_errada(9.0));
    return 0;
}

Saída:

valor a pagar: 110.00
7 é ímpar
nota 9.0: aprovado
nota 7.0: aprovado
nota 6.5: recuperação
nota 5.0: recuperação
nota 3.0: reprovado
tem idade, mas falta a habilitação
ordem errada, nota 9.0: recuperação

A lógica é idêntica nas três linguagens. A escrita muda em dois pontos:

  • Como o bloco é delimitado. Em PHP e em C, a condição vai entre parênteses e o bloco fica entre chaves. Em Python, a linha do if termina com dois-pontos e o bloco é o trecho recuado, com espaços à esquerda.
  • O nome do “senão, se”. elif em Python, elseif em PHP e else if em C.

Foque no conceito, e não na linguagem! Pergunta, caminho do sim, caminho do não.

Agora olhe a última linha da saída. A nota 9 foi classificada como recuperação. O erro está na função situacao_errada: ela pergunta primeiro se a nota é maior ou igual a 5. Para a nota 9, isso é verdade, o bloco é executado e a pergunta sobre o 7 nunca chega a ser feita. ATENÇÃO: em condições encadeadas, comece pela mais restritiva.

O que é um if dentro de outro?

É o if aninhado: a segunda pergunta só é feita se a primeira for verdadeira. No exemplo, só faz sentido perguntar pela habilitação de quem já tem 18 anos. Um if pode ficar dentro de outro quantas vezes for necessário.

Em C, quando há vários if aninhados e um else, o else fica sempre ligado ao if mais próximo que ainda não tem else. Usar chaves em todos os blocos, como no programa acima, elimina a dúvida.

Existem ainda comandos para escolher entre muitos valores de uma mesma variável: o switch, em C e em PHP, e o match, em PHP e em Python. Eles não trazem ideia nova. Em Python, a própria documentação apresenta a sequência de if e elif como substituta do switch de outras linguagens.

Aí você pergunta: qual é a diferença entre = e == ?

Um sinal de igual é a atribuição: guarda um valor na variável. Dois sinais de igual são a comparação: perguntam se dois valores são iguais. Trocar um pelo outro dentro da condição é um erro que o computador nem sempre aponta. Testei o que cada linguagem faz com a variável x valendo 3 e a condição escrita com um sinal só, x = 5.

Em Python, o programa não roda:

SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

Em C e em PHP, o programa roda, e roda errado. As duas linguagens guardam 5 em x, tratam o 5 como verdadeiro e entram no bloco. A saída foi a mesma nas duas:

x vale cinco
x = 5

O x valia 3 e a condição “passou” mesmo assim. Em C, o compilador com os avisos ligados dá a pista:

warning: suggest parentheses around assignment used as truth value [-Wparentheses]

Sacou? Na dúvida, leia a condição em voz alta. “Se x recebe 5” não é uma pergunta.

Quais são os erros mais comuns com if e else?

  • Usar = no lugar de ==. Em C e em PHP, o programa aceita e muda o valor da variável.
  • Errar a ordem das condições encadeadas. A primeira verdadeira vence. A mais restritiva vem antes.
  • Esquecer o recuo em Python. Sem o bloco recuado, o programa para com IndentationError: expected an indented block after ‘if’ statement.
  • Colocar ponto e vírgula depois da condição em C. Em if (nota >= 7); o if termina ali, e o bloco seguinte é executado sempre. No meu teste, com nota 3, o programa imprimiu “aprovado”.
  • Esquecer as chaves em C e em PHP. Sem chaves, só a primeira instrução pertence ao if.
  • Escrever dois if quando o certo é if e else. Com dois if separados, as duas condições são testadas, e os dois blocos podem ser executados.
  • Esquecer um caso. Sem else, se nenhuma condição for verdadeira, nada acontece, e o programa não avisa.

Aí você pergunta: dá para exagerar no if?

Dá, e muito! Um if sozinho custa quase nada. O problema aparece quando eles se multiplicam: o programa continua funcionando, mas fica mais lento, mais difícil de testar e mais fácil de quebrar. Os três custos aparecem a seguir, com programas que rodei de verdade.

Por que uma fila de elif deixa o programa mais lento?

Pense em um atendente que procura a sua ficha olhando uma por uma, da primeira à última. Se a sua for a última, ele olha todas antes de chegar nela. Agora pense em um fichário com uma divisória para cada nome: ele abre direto na sua ficha.

A fila de if e elif é o primeiro atendente, porque as condições são testadas em ordem. Com três condições, tanto faz. Com dezenas, vira uma busca linear escrita à mão! Para medir, escrevi a função nome_do_estado, com uma condição para cada uma das 27 siglas, em ordem alfabética, e fiz a mesma tarefa com uma tabela: um dicionário em Python e um array associativo em PHP.

Em Python, de forma resumida:

def nome_do_estado(sigla):
    if sigla == "AC":
        return "Acre"
    elif sigla == "AL":
        return "Alagoas"
    # ... mais 24 elif, um para cada sigla, em ordem alfabética ...
    elif sigla == "TO":
        return "Tocantins"
    else:
        return "sigla desconhecida"

ESTADOS = {
    "AC": "Acre", "AL": "Alagoas",
    # ... as outras 24 siglas ...
    "TO": "Tocantins",
}

def nome_do_estado_tabela(sigla):
    return ESTADOS.get(sigla, "sigla desconhecida")
Ver os programas completos em Python e em PHP, com as saídas

Python:

# Uma fila de if e elif contra um dicionário: quem acha a resposta mais rápido?
import timeit

def nome_do_estado(sigla):
    if sigla == "AC":
        return "Acre"
    elif sigla == "AL":
        return "Alagoas"
    elif sigla == "AM":
        return "Amazonas"
    elif sigla == "AP":
        return "Amapá"
    elif sigla == "BA":
        return "Bahia"
    elif sigla == "CE":
        return "Ceará"
    elif sigla == "DF":
        return "Distrito Federal"
    elif sigla == "ES":
        return "Espírito Santo"
    elif sigla == "GO":
        return "Goiás"
    elif sigla == "MA":
        return "Maranhão"
    elif sigla == "MG":
        return "Minas Gerais"
    elif sigla == "MS":
        return "Mato Grosso do Sul"
    elif sigla == "MT":
        return "Mato Grosso"
    elif sigla == "PA":
        return "Pará"
    elif sigla == "PB":
        return "Paraíba"
    elif sigla == "PE":
        return "Pernambuco"
    elif sigla == "PI":
        return "Piauí"
    elif sigla == "PR":
        return "Paraná"
    elif sigla == "RJ":
        return "Rio de Janeiro"
    elif sigla == "RN":
        return "Rio Grande do Norte"
    elif sigla == "RO":
        return "Rondônia"
    elif sigla == "RR":
        return "Roraima"
    elif sigla == "RS":
        return "Rio Grande do Sul"
    elif sigla == "SC":
        return "Santa Catarina"
    elif sigla == "SE":
        return "Sergipe"
    elif sigla == "SP":
        return "São Paulo"
    elif sigla == "TO":
        return "Tocantins"
    else:
        return "sigla desconhecida"

ESTADOS = {
    "AC": "Acre", "AL": "Alagoas", "AM": "Amazonas", "AP": "Amapá",
    "BA": "Bahia", "CE": "Ceará", "DF": "Distrito Federal",
    "ES": "Espírito Santo", "GO": "Goiás", "MA": "Maranhão",
    "MG": "Minas Gerais", "MS": "Mato Grosso do Sul", "MT": "Mato Grosso",
    "PA": "Pará", "PB": "Paraíba", "PE": "Pernambuco", "PI": "Piauí",
    "PR": "Paraná", "RJ": "Rio de Janeiro", "RN": "Rio Grande do Norte",
    "RO": "Rondônia", "RR": "Roraima", "RS": "Rio Grande do Sul",
    "SC": "Santa Catarina", "SE": "Sergipe", "SP": "São Paulo",
    "TO": "Tocantins",
}

def nome_do_estado_tabela(sigla):
    return ESTADOS.get(sigla, "sigla desconhecida")

# as duas funções precisam dar a mesma resposta para todas as siglas
for sigla in list(ESTADOS) + ["XX"]:
    assert nome_do_estado(sigla) == nome_do_estado_tabela(sigla)

def medir(funcao, sigla):
    # 1 milhão de consultas, repetidas 5 vezes; fica a mais rápida
    tempos = timeit.repeat(lambda: funcao(sigla), number=1_000_000, repeat=5)
    return min(tempos)

print("tempo de 1 milhão de consultas:")
print("fila de if, AC (1ª pergunta):  %.2f s" % medir(nome_do_estado, "AC"))
print("fila de if, MG (11ª pergunta): %.2f s" % medir(nome_do_estado, "MG"))
print("fila de if, TO (27ª pergunta): %.2f s" % medir(nome_do_estado, "TO"))
print("dicionário, AC:                %.2f s" % medir(nome_do_estado_tabela, "AC"))
print("dicionário, TO:                %.2f s" % medir(nome_do_estado_tabela, "TO"))

PHP:

<?php
// Uma fila de if e elseif contra um array associativo: quem acha a resposta mais rápido?

function nome_do_estado(string $sigla): string {
    if ($sigla === "AC") {
        return "Acre";
    } elseif ($sigla === "AL") {
        return "Alagoas";
    } elseif ($sigla === "AM") {
        return "Amazonas";
    } elseif ($sigla === "AP") {
        return "Amapá";
    } elseif ($sigla === "BA") {
        return "Bahia";
    } elseif ($sigla === "CE") {
        return "Ceará";
    } elseif ($sigla === "DF") {
        return "Distrito Federal";
    } elseif ($sigla === "ES") {
        return "Espírito Santo";
    } elseif ($sigla === "GO") {
        return "Goiás";
    } elseif ($sigla === "MA") {
        return "Maranhão";
    } elseif ($sigla === "MG") {
        return "Minas Gerais";
    } elseif ($sigla === "MS") {
        return "Mato Grosso do Sul";
    } elseif ($sigla === "MT") {
        return "Mato Grosso";
    } elseif ($sigla === "PA") {
        return "Pará";
    } elseif ($sigla === "PB") {
        return "Paraíba";
    } elseif ($sigla === "PE") {
        return "Pernambuco";
    } elseif ($sigla === "PI") {
        return "Piauí";
    } elseif ($sigla === "PR") {
        return "Paraná";
    } elseif ($sigla === "RJ") {
        return "Rio de Janeiro";
    } elseif ($sigla === "RN") {
        return "Rio Grande do Norte";
    } elseif ($sigla === "RO") {
        return "Rondônia";
    } elseif ($sigla === "RR") {
        return "Roraima";
    } elseif ($sigla === "RS") {
        return "Rio Grande do Sul";
    } elseif ($sigla === "SC") {
        return "Santa Catarina";
    } elseif ($sigla === "SE") {
        return "Sergipe";
    } elseif ($sigla === "SP") {
        return "São Paulo";
    } elseif ($sigla === "TO") {
        return "Tocantins";
    } else {
        return "sigla desconhecida";
    }
}

const ESTADOS = [
    "AC" => "Acre", "AL" => "Alagoas", "AM" => "Amazonas", "AP" => "Amapá",
    "BA" => "Bahia", "CE" => "Ceará", "DF" => "Distrito Federal",
    "ES" => "Espírito Santo", "GO" => "Goiás", "MA" => "Maranhão",
    "MG" => "Minas Gerais", "MS" => "Mato Grosso do Sul", "MT" => "Mato Grosso",
    "PA" => "Pará", "PB" => "Paraíba", "PE" => "Pernambuco", "PI" => "Piauí",
    "PR" => "Paraná", "RJ" => "Rio de Janeiro", "RN" => "Rio Grande do Norte",
    "RO" => "Rondônia", "RR" => "Roraima", "RS" => "Rio Grande do Sul",
    "SC" => "Santa Catarina", "SE" => "Sergipe", "SP" => "São Paulo",
    "TO" => "Tocantins",
];

function nome_do_estado_tabela(string $sigla): string {
    return ESTADOS[$sigla] ?? "sigla desconhecida";
}

// as duas funções precisam dar a mesma resposta para todas as siglas
foreach (array_merge(array_keys(ESTADOS), ["XX"]) as $sigla) {
    if (nome_do_estado($sigla) !== nome_do_estado_tabela($sigla)) {
        exit("respostas diferentes para $sigla\n");
    }
}

function medir(callable $funcao, string $sigla): float {
    // 1 milhão de consultas, repetidas 5 vezes; fica a mais rápida
    $melhor = INF;
    for ($r = 0; $r < 5; $r++) {
        $inicio = hrtime(true);
        for ($i = 0; $i < 1000000; $i++) {
            $funcao($sigla);
        }
        $melhor = min($melhor, (hrtime(true) - $inicio) / 1e9);
    }
    return $melhor;
}

echo "tempo de 1 milhão de consultas:\n";
printf("fila de if, AC (1ª pergunta):  %.2f s\n", medir('nome_do_estado', "AC"));
printf("fila de if, MG (11ª pergunta): %.2f s\n", medir('nome_do_estado', "MG"));
printf("fila de if, TO (27ª pergunta): %.2f s\n", medir('nome_do_estado', "TO"));
printf("array, AC:                     %.2f s\n", medir('nome_do_estado_tabela', "AC"));
printf("array, TO:                     %.2f s\n", medir('nome_do_estado_tabela', "TO"));

Saída do Python:

tempo de 1 milhão de consultas:
fila de if, AC (1ª pergunta):  0.04 s
fila de if, MG (11ª pergunta): 0.23 s
fila de if, TO (27ª pergunta): 0.58 s
dicionário, AC:                0.05 s
dicionário, TO:                0.05 s

Saída do PHP:

tempo de 1 milhão de consultas:
fila de if, AC (1ª pergunta):  0.04 s
fila de if, MG (11ª pergunta): 0.11 s
fila de if, TO (27ª pergunta): 0.22 s
array, AC:                     0.05 s
array, TO:                     0.05 s
Gráfico de barras com o tempo de 1 milhão de consultas: na fila de if, 0,04 s para AC, 0,23 s para MG e 0,58 s para TO em Python, e 0,04 s, 0,11 s e 0,22 s em PHP; na tabela, 0,05 s nas duas linguagens
Tempo de 1 milhão de consultas em Python 3.13 e PHP 8.3, na mesma máquina, no melhor de 5 medições.

Na fila, o tempo cresce com a posição da sigla: em Python, AC, a 1ª, levou 0,04 s, e TO, a 27ª, levou 0,58 s. Na tabela, qualquer sigla levou 0,05 s, porque ela não pergunta uma por uma. O dicionário do Python e o array do PHP são tabelas hash, e a documentação do Python cita o desempenho nas buscas como motivo dessa escolha. Como uma tabela hash funciona por dentro será assunto de um dos próximos artigos.

ATENÇÃO: isso não manda trocar todo if por dicionário. Com a sigla na 1ª posição, a fila empatou com a tabela, e com três ou quatro opções o if costuma ser mais claro. O custo aparece quando a fila é longa e a função é chamada milhões de vezes.

O processador também tenta adivinhar o seu if

Pense em um motorista de aplicativo que já entra na rua de sempre antes de você confirmar o destino. Quase sempre ele acerta e ganha tempo. Quando erra, precisa voltar, e perde mais tempo do que se tivesse esperado.

O processador faz isso com cada if: em vez de esperar o resultado da condição, aposta em um caminho e já começa a executar as instruções seguintes. Se errar, descarta esse trabalho e recomeça pelo caminho certo. Nos slides de arquitetura de computadores de Princeton, os processadores usados como exemplo perdem de 7 a 17 ciclos de relógio a cada erro, e cerca de 1 em cada 4 ou 5 instruções de um programa de uso geral é um desvio.

Dá para ver isso acontecer! O programa abaixo soma só os números a partir de 128, em um vetor com 1 milhão de números de 0 a 255: primeiro embaralhados, depois os mesmos números em ordem. O if fica dentro de um laço for.

C:

/* O processador tenta adivinhar o if: mesmos números, em outra ordem */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define TAMANHO 1000000
#define REPETICOES 10
#define MEDICOES 5

static int numeros[TAMANHO];

/* soma só os números a partir de 128: um if dentro do laço */
static long long somar_grandes(void) {
    long long soma = 0;
    for (int i = 0; i < TAMANHO; i++) {
        if (numeros[i] >= 128) {
            soma = soma + numeros[i];
        }
    }
    return soma;
}

static int comparar(const void *a, const void *b) {
    return *(const int *)a - *(const int *)b;
}

/* soma tudo 10 vezes por medição; das 5 medições, fica a mais rápida (em ms) */
static double medir(long long *soma) {
    double melhor = 1e9;
    for (int m = 0; m < MEDICOES; m++) {
        clock_t inicio = clock();
        *soma = 0;
        for (int r = 0; r < REPETICOES; r++) {
            *soma = *soma + somar_grandes();
        }
        double tempo = (double)(clock() - inicio) * 1000 / CLOCKS_PER_SEC;
        if (tempo < melhor) {
            melhor = tempo;
        }
    }
    return melhor;
}

int main(void) {
    srand(42);
    for (int i = 0; i < TAMANHO; i++) {
        numeros[i] = rand() % 256; /* de 0 a 255, fora de ordem */
    }
    long long soma_embaralhados, soma_ordenados;
    double tempo_embaralhados = medir(&soma_embaralhados);

    qsort(numeros, TAMANHO, sizeof(int), comparar); /* os mesmos números, em ordem */
    double tempo_ordenados = medir(&soma_ordenados);

    printf("embaralhados: %4.0f ms (soma %lld)\n", tempo_embaralhados, soma_embaralhados);
    printf("ordenados:    %4.0f ms (soma %lld)\n", tempo_ordenados, soma_ordenados);
    return 0;
}

Compilei sem otimização (gcc -O0), para o if continuar no programa como um salto. Saída:

embaralhados:   58 ms (soma 956554510)
ordenados:      17 ms (soma 956554510)

A conta é a mesma, e os embaralhados levaram mais que o triplo do tempo. Em ordem, o resultado do if é previsível: falso, falso, falso… e depois verdadeiro, verdadeiro, verdadeiro. Embaralhado, vira cara ou coroa, e o processador erra a aposta muito mais vezes.

Repeti o teste em C com otimização (gcc -O2), em PHP e em Python:

Gráfico de barras com quantas vezes o teste ficou mais lento com os números embaralhados: 3,4 vezes em C com gcc -O0, 2,1 vezes em PHP, 1,4 vez em Python e 1,0 vez em C com gcc -O2
Melhor de 5 medições, cada uma somando o vetor inteiro 10 vezes.
Ver os programas em PHP e em Python, com as saídas

PHP:

<?php
// O processador tenta adivinhar o if: o mesmo teste em PHP
mt_srand(42);
$numeros = [];
for ($i = 0; $i < 1000000; $i++) {
    $numeros[] = mt_rand(0, 255);
}

function somar_grandes(array $lista): int {
    $soma = 0;
    foreach ($lista as $n) {
        if ($n >= 128) {
            $soma = $soma + $n;
        }
    }
    return $soma;
}

function medir(array $lista): array {
    // soma tudo 10 vezes por medição; das 5 medições, fica a mais rápida (em ms)
    $melhor = INF;
    for ($m = 0; $m < 5; $m++) {
        $inicio = hrtime(true);
        $soma = 0;
        for ($r = 0; $r < 10; $r++) {
            $soma = $soma + somar_grandes($lista);
        }
        $melhor = min($melhor, (hrtime(true) - $inicio) / 1e6);
    }
    return [$melhor, $soma];
}

[$tempo_embaralhados, $soma1] = medir($numeros);
sort($numeros); // os mesmos números, em ordem
[$tempo_ordenados, $soma2] = medir($numeros);
printf("embaralhados: %4.0f ms (soma %d)\n", $tempo_embaralhados, $soma1);
printf("ordenados:    %4.0f ms (soma %d)\n", $tempo_ordenados, $soma2);

Saída:

embaralhados:  132 ms (soma 958726070)
ordenados:      62 ms (soma 958726070)

Python:

# O processador tenta adivinhar o if: o mesmo teste em Python
import random, time

random.seed(42)
numeros = [random.randrange(256) for _ in range(1_000_000)]

def somar_grandes(lista):
    soma = 0
    for n in lista:
        if n >= 128:
            soma = soma + n
    return soma

def medir(lista):
    # soma tudo 10 vezes por medição; das 5 medições, fica a mais rápida (em ms)
    melhor = float("inf")
    for _ in range(5):
        inicio = time.perf_counter()
        soma = 0
        for _ in range(10):
            soma = soma + somar_grandes(lista)
        melhor = min(melhor, (time.perf_counter() - inicio) * 1000)
    return melhor, soma

tempo_embaralhados, soma1 = medir(numeros)
numeros.sort()  # os mesmos números, em ordem
tempo_ordenados, soma2 = medir(numeros)
print("embaralhados: %4.0f ms (soma %d)" % (tempo_embaralhados, soma1))
print("ordenados:    %4.0f ms (soma %d)" % (tempo_ordenados, soma2))

Saída:

embaralhados:  308 ms (soma 957885870)
ordenados:     223 ms (soma 957885870)

Saída do programa em C compilado com gcc -O2:

embaralhados:    3 ms (soma 956554510)
ordenados:       3 ms (soma 956554510)

Com -O2, a diferença sumiu: no código gerado, o GCC trocou o salto por instruções sem desvio, otimizações descritas no manual dele. No PHP e no Python, ela continuou lá. Foque no conceito, e não na linguagem! Um if de resultado imprevisível, dentro de um laço que roda milhões de vezes, custa mais do que a comparação em si. E, antes de mexer no código por causa disso, meça.

Cada if a mais é um caminho a mais para testar

Em um documento publicado pelo NIST, o instituto de padrões dos Estados Unidos, Arthur Watson e Thomas McCabe descrevem a complexidade ciclomática, uma medida da lógica de decisão de uma função. Com decisões de sim ou não, a conta é o número de decisões mais 1, e o resultado é também a quantidade de testes que a metodologia deles exige. O documento diz que o limite de 10, proposto por McCabe, tem bastante evidência a favor e que, mantidos os outros fatores, quanto mais complexa a função, maior a chance de ela ter erros.

E as combinações crescem ainda mais rápido. Pense em uma loja com três regras independentes: desconto, frete grátis e brinde. São 3 if, e a conta de McCabe dá 4. Mas cada regra pode valer ou não, então as combinações são 8. Cada if independente dobra esse número: com 10, são 1.024.

Árvore de decisão com três perguntas, desconto, frete grátis e brinde, cada uma com sim e não, terminando em 8 combinações; ao lado, a tabela: 1 if, 2 combinações; 2 if, 4; 3 if, 8; 10 if, 1.024; 20 if, 1.048.576
Três regras independentes, oito combinações.

Se um defeito só aparece quando desconto e frete grátis valem ao mesmo tempo, ele pode escapar dos quatro testes.

O excesso também pesa na leitura. Veja uma validação de pedido com quatro perguntas, uma dentro da outra, e a mesma regra reescrita logo abaixo.

Python:

# A pirâmide de if e a mesma regra com cláusulas de guarda

def validar_aninhado(pedido):
    if pedido["cliente_ativo"]:
        if pedido["quantidade"] > 0:
            if pedido["quantidade"] <= pedido["estoque"]:
                if pedido["pagamento_aprovado"]:
                    return "pedido aceito"
                else:
                    return "pagamento recusado"
            else:
                return "estoque insuficiente"
        else:
            return "quantidade inválida"
    else:
        return "cliente inativo"

def validar_com_guardas(pedido):
    if not pedido["cliente_ativo"]:
        return "cliente inativo"
    if pedido["quantidade"] <= 0:
        return "quantidade inválida"
    if pedido["quantidade"] > pedido["estoque"]:
        return "estoque insuficiente"
    if not pedido["pagamento_aprovado"]:
        return "pagamento recusado"
    return "pedido aceito"

# um pedido para cada caminho possível
pedidos = [
    {"cliente_ativo": False, "quantidade": 1, "estoque": 5, "pagamento_aprovado": True},
    {"cliente_ativo": True, "quantidade": 0, "estoque": 5, "pagamento_aprovado": True},
    {"cliente_ativo": True, "quantidade": 9, "estoque": 5, "pagamento_aprovado": True},
    {"cliente_ativo": True, "quantidade": 2, "estoque": 5, "pagamento_aprovado": False},
    {"cliente_ativo": True, "quantidade": 2, "estoque": 5, "pagamento_aprovado": True},
]

for numero, pedido in enumerate(pedidos, start=1):
    a = validar_aninhado(pedido)
    b = validar_com_guardas(pedido)
    print("pedido %d: %s | %s | %s" % (numero, a, b, "iguais" if a == b else "DIFERENTES"))

Saída:

pedido 1: cliente inativo | cliente inativo | iguais
pedido 2: quantidade inválida | quantidade inválida | iguais
pedido 3: estoque insuficiente | estoque insuficiente | iguais
pedido 4: pagamento recusado | pagamento recusado | iguais
pedido 5: pedido aceito | pedido aceito | iguais

Na primeira função, cada else fica longe da pergunta que ele responde. A segunda usa cláusulas de guarda, uma refatoração descrita por Martin Fowler no livro Refactoring: cada caso especial é testado no começo e devolve a resposta na hora, e o caminho normal fica no fim, sem recuo. As respostas são iguais, e as decisões continuam sendo 4. A conta de McCabe não mudou. O que melhorou foi a leitura.

Ver a mesma reescrita em PHP e em C

PHP:

<?php
// A pirâmide de if e a mesma regra com cláusulas de guarda

function validar_aninhado(array $pedido): string {
    if ($pedido["cliente_ativo"]) {
        if ($pedido["quantidade"] > 0) {
            if ($pedido["quantidade"] <= $pedido["estoque"]) {
                if ($pedido["pagamento_aprovado"]) {
                    return "pedido aceito";
                } else {
                    return "pagamento recusado";
                }
            } else {
                return "estoque insuficiente";
            }
        } else {
            return "quantidade inválida";
        }
    } else {
        return "cliente inativo";
    }
}

function validar_com_guardas(array $pedido): string {
    if (!$pedido["cliente_ativo"]) {
        return "cliente inativo";
    }
    if ($pedido["quantidade"] <= 0) {
        return "quantidade inválida";
    }
    if ($pedido["quantidade"] > $pedido["estoque"]) {
        return "estoque insuficiente";
    }
    if (!$pedido["pagamento_aprovado"]) {
        return "pagamento recusado";
    }
    return "pedido aceito";
}

// um pedido para cada caminho possível
$pedidos = [
    ["cliente_ativo" => false, "quantidade" => 1, "estoque" => 5, "pagamento_aprovado" => true],
    ["cliente_ativo" => true, "quantidade" => 0, "estoque" => 5, "pagamento_aprovado" => true],
    ["cliente_ativo" => true, "quantidade" => 9, "estoque" => 5, "pagamento_aprovado" => true],
    ["cliente_ativo" => true, "quantidade" => 2, "estoque" => 5, "pagamento_aprovado" => false],
    ["cliente_ativo" => true, "quantidade" => 2, "estoque" => 5, "pagamento_aprovado" => true],
];

foreach ($pedidos as $i => $pedido) {
    $a = validar_aninhado($pedido);
    $b = validar_com_guardas($pedido);
    printf("pedido %d: %s | %s | %s\n", $i + 1, $a, $b, $a === $b ? "iguais" : "DIFERENTES");
}

C:

/* A pirâmide de if e a mesma regra com cláusulas de guarda */
#include <stdio.h>
#include <string.h>

typedef struct {
    int cliente_ativo;
    int quantidade;
    int estoque;
    int pagamento_aprovado;
} Pedido;

const char *validar_aninhado(Pedido p) {
    if (p.cliente_ativo) {
        if (p.quantidade > 0) {
            if (p.quantidade <= p.estoque) {
                if (p.pagamento_aprovado) {
                    return "pedido aceito";
                } else {
                    return "pagamento recusado";
                }
            } else {
                return "estoque insuficiente";
            }
        } else {
            return "quantidade inválida";
        }
    } else {
        return "cliente inativo";
    }
}

const char *validar_com_guardas(Pedido p) {
    if (!p.cliente_ativo) {
        return "cliente inativo";
    }
    if (p.quantidade <= 0) {
        return "quantidade inválida";
    }
    if (p.quantidade > p.estoque) {
        return "estoque insuficiente";
    }
    if (!p.pagamento_aprovado) {
        return "pagamento recusado";
    }
    return "pedido aceito";
}

int main(void) {
    /* um pedido para cada caminho possível */
    Pedido pedidos[] = {
        {0, 1, 5, 1}, {1, 0, 5, 1}, {1, 9, 5, 1}, {1, 2, 5, 0}, {1, 2, 5, 1},
    };
    for (int i = 0; i < 5; i++) {
        const char *a = validar_aninhado(pedidos[i]);
        const char *b = validar_com_guardas(pedidos[i]);
        printf("pedido %d: %s | %s | %s\n", i + 1, a, b, strcmp(a, b) == 0 ? "iguais" : "DIFERENTES");
    }
    return 0;
}

A saída foi idêntica nas três linguagens.

Quais armadilhas do if aparecem só em produção?

Os erros abaixo passam pelo compilador, podem passar pelos testes e aparecem com os dados reais. Dois deles viraram casos documentados, e caros.

A chave que faltou: o goto fail

Em fevereiro de 2014, a Apple corrigiu uma falha na verificação de conexões seguras (SSL/TLS) do iOS e do OS X. Segundo um artigo publicado pela ACM, ela estava no código desde o iOS 6.0, de setembro de 2012, e expunha os usuários a ataques de quem se coloca no meio da conexão. A causa: uma linha goto fail; repetida logo depois de um if sem chaves.

O programa abaixo reproduz o erro em tamanho pequeno. O goto falha pula direto para a linha falha:, onde a função devolve o código de erro, que é 0 quando está tudo certo. A assinatura é falsa de propósito:

/* A chave que faltou: uma linha repetida desliga a verificação */
#include <stdio.h>

int calcular_resumo(void) { return 0; }      /* 0 = deu certo */
int conferir_assinatura(void) { return 1; }  /* 1 = assinatura falsa */

/* sem chaves: só a primeira linha depois do if pertence a ele */
int verificar_sem_chaves(void) {
    int erro;
    if ((erro = calcular_resumo()) != 0)
        goto falha;
        goto falha;
    if ((erro = conferir_assinatura()) != 0)
        goto falha;
falha:
    return erro;
}

/* com chaves: a linha repetida fica presa dentro do bloco */
int verificar_com_chaves(void) {
    int erro;
    if ((erro = calcular_resumo()) != 0) {
        goto falha;
        goto falha;
    }
    if ((erro = conferir_assinatura()) != 0) {
        goto falha;
    }
falha:
    return erro;
}

int main(void) {
    printf("sem chaves: %s\n", verificar_sem_chaves() == 0 ? "certificado aceito" : "certificado recusado");
    printf("com chaves: %s\n", verificar_com_chaves() == 0 ? "certificado aceito" : "certificado recusado");
    return 0;
}

Saída:

sem chaves: certificado aceito
com chaves: certificado recusado

Sem chaves, a assinatura falsa foi aceita! O segundo goto falha; parece estar dentro do if por causa do recuo, mas o compilador de C ignora os espaços. Ele é executado sempre, com erro ainda valendo 0, e a conferência da assinatura nunca acontece. É o erro das chaves da lista acima, agora com endereço e data.

Desde a versão 6, o GCC avisa sobre esse recuo enganoso quando o -Wall está ligado, e a nota de lançamento usa o próprio goto fail como exemplo. No meu teste:

alg_goto_fail.c: In function 'verificar_sem_chaves':
alg_goto_fail.c:10:5: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
   10 |     if ((erro = calcular_resumo()) != 0)
      |     ^~
alg_goto_fail.c:12:9: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
   12 |         goto falha;
      |         ^~~~

Sem o -Wall, o mesmo programa compilou em silêncio. ATENÇÃO: compile sempre com os avisos ligados.

Zero não é vazio

Em Python e em PHP, o if aceita qualquer valor como condição, e alguns contam como falso. Em Python: None, False, o zero e as sequências vazias. Em PHP: false, o zero, o texto vazio, o texto “0”, o array vazio e null. Parece prático, até o dia em que o zero é um valor de verdade.

A função abaixo usa o desconto padrão de 10% quando o desconto não foi informado. Agora imagine uma campanha cadastrada com desconto 0.

Python:

# Zero não é vazio: o if trata 0, "" e None como falso

def desconto_final(desconto_informado):
    # se o desconto não foi informado, usa o padrão de 10%
    if not desconto_informado:
        return 10
    return desconto_informado

def desconto_final_certo(desconto_informado):
    if desconto_informado is None:  # pergunta exatamente o que quer saber
        return 10
    return desconto_informado

for desconto in [15, 0, None]:
    print("informado:", desconto, "| com if not:", desconto_final(desconto),
          "| com is None:", desconto_final_certo(desconto))

Saída:

informado: 15 | com if not: 15 | com is None: 15
informado: 0 | com if not: 10 | com is None: 0
informado: None | com if not: 10 | com is None: 10

O desconto 0 virou 10%!!! O cliente agradece, o financeiro nem tanto kkkk. A condição if not desconto_informado pergunta “é falso?”, e o zero é falso. A versão certa pergunta exatamente o que quer saber: “não foi informado?”.

Ver o mesmo teste em PHP

Em PHP, o zero guardado como texto também conta como falso:

<?php
// Zero não é vazio: o if trata 0, "0", "" e null como falso

function desconto_final($desconto_informado) {
    // se o desconto não foi informado, usa o padrão de 10%
    if (!$desconto_informado) {
        return 10;
    }
    return $desconto_informado;
}

function desconto_final_certo($desconto_informado) {
    if ($desconto_informado === null) { // pergunta exatamente o que quer saber
        return 10;
    }
    return $desconto_informado;
}

// o mesmo zero, agora guardado como texto: "0"
foreach ([15, 0, "0", null] as $desconto) {
    printf("informado: %s | com !: %s | com === null: %s\n",
        var_export($desconto, true), desconto_final($desconto), desconto_final_certo($desconto));
}

Saída:

informado: 15 | com !: 15 | com === null: 15
informado: 0 | com !: 10 | com === null: 0
informado: '0' | com !: 10 | com === null: 0
informado: NULL | com !: 10 | com === null: 10

Dois textos diferentes, e o == diz que são iguais

No PHP, o == converte antes de comparar: pelo manual, quando os dois lados são textos numéricos, a comparação é feita como número. Veja o que acontece com os resumos (hashes) de dois textos diferentes. O md5 está aqui só para gerar os resumos:

<?php
// Comparação frouxa: o == do PHP converte os textos antes de comparar
$resumo_salvo = md5("240610708");    // resumo (hash) guardado no banco
$resumo_recebido = md5("QNKCDZO");   // resumo de outro texto, bem diferente

echo $resumo_salvo, "\n", $resumo_recebido, "\n";
var_dump($resumo_salvo == $resumo_recebido);           // compara como números
var_dump($resumo_salvo === $resumo_recebido);          // compara tipo e valor
var_dump(hash_equals($resumo_salvo, $resumo_recebido)); // feita para comparar resumos

Saída:

0e462097431906509019562988736854
0e830400451993494058024219903391
bool(true)
bool(false)
bool(false)

O == respondeu que os dois resumos são iguais! Os dois começam com 0e e só têm algarismos depois, então o PHP leu cada um como um número em notação científica: 0 vezes 10 elevado a alguma coisa, ou seja, zero. Para comparar textos, use ===. Para resumos e códigos secretos, o PHP tem a função hash_equals.

0,1 + 0,2 não é 0,3

Outra armadilha clássica: comparar números com vírgula usando ==. Um carrinho com dois itens, de R$ 0,10 e R$ 0,20:

Python:

# 0,1 + 0,2 não é 0,3: comparar números com vírgula usando == engana
total = 0.1 + 0.2   # dois itens: R$ 0,10 e R$ 0,20
print("total calculado:", total)
if total == 0.3:
    print("pagamento de R$ 0,30 confere")
else:
    print("pagamento de R$ 0,30 NÃO confere")

total_em_centavos = 10 + 20   # os mesmos valores, guardados em centavos
if total_em_centavos == 30:
    print("em centavos, confere")

Saída:

total calculado: 0.30000000000000004
pagamento de R$ 0,30 NÃO confere
em centavos, confere

Não é defeito do Python. A documentação explica que esses números são guardados em binário e que o mesmo acontece em todas as linguagens que usam a aritmética de ponto flutuante do processador. O manual do PHP completa: 0,1 não tem representação exata em base 2, e por isso não se deve comparar esses números por igualdade.

Ver o mesmo teste em PHP e em C

PHP:

<?php
// 0,1 + 0,2 não é 0,3: comparar números com vírgula usando == engana
$total = 0.1 + 0.2; // dois itens: R$ 0,10 e R$ 0,20
echo "total com echo: ", $total, "\n";
var_dump($total);
if ($total == 0.3) {
    echo "pagamento de R$ 0,30 confere\n";
} else {
    echo "pagamento de R$ 0,30 NÃO confere\n";
}

$total_em_centavos = 10 + 20; // os mesmos valores, guardados em centavos
if ($total_em_centavos == 30) {
    echo "em centavos, confere\n";
}

Saída:

total com echo: 0.3
float(0.30000000000000004)
pagamento de R$ 0,30 NÃO confere
em centavos, confere

C:

/* 0,1 + 0,2 não é 0,3: comparar números com vírgula usando == engana */
#include <stdio.h>

int main(void) {
    double total = 0.1 + 0.2; /* dois itens: R$ 0,10 e R$ 0,20 */
    printf("total com %%.2f:  %.2f\n", total);
    printf("total com %%.17g: %.17g\n", total);
    if (total == 0.3) {
        printf("pagamento de R$ 0,30 confere\n");
    } else {
        printf("pagamento de R$ 0,30 NÃO confere\n");
    }

    int total_em_centavos = 10 + 20; /* os mesmos valores, guardados em centavos */
    if (total_em_centavos == 30) {
        printf("em centavos, confere\n");
    }
    return 0;
}

Saída:

total com %.2f:  0.30
total com %.17g: 0.30000000000000004
pagamento de R$ 0,30 NÃO confere
em centavos, confere

Em PHP e em C, a comparação também falhou, com um detalhe traiçoeiro: o echo do PHP mostrou 0.3, e o printf do C com duas casas mostrou 0.30. O log diz 0,30, e o if diz que não é! Para dinheiro, a saída mais simples é guardar centavos em números inteiros, como na última linha da saída. A documentação do Python indica também o módulo decimal, para cálculos de contabilidade, e a função math.isclose, para comparar valores aproximados.

O caso que ninguém previu

Um sistema de pedidos decide o que fazer conforme o status do pagamento. Quem escreveu o if conhecia três status e deixou o último para o else. Meses depois, o sistema de pagamento passou a mandar um status novo, “em análise”.

Python:

# O caso que ninguém previu: o else que "adivinha" o que sobrou

def acao_do_pedido(status):
    if status == "pendente":
        return "aguardar o pagamento"
    elif status == "cancelado":
        return "não enviar"
    else:
        return "enviar o produto"  # quem escreveu achou que só sobrava "pago"

def acao_do_pedido_segura(status):
    if status == "pago":
        return "enviar o produto"
    elif status == "pendente":
        return "aguardar o pagamento"
    elif status == "cancelado":
        return "não enviar"
    else:
        raise ValueError("status desconhecido: " + status)

# meses depois, o sistema de pagamento passa a mandar "em análise"
for status in ["pago", "pendente", "cancelado", "em análise"]:
    print(status, "->", acao_do_pedido(status))

try:
    acao_do_pedido_segura("em análise")
except ValueError as erro:
    print("versão segura:", erro)

Saída:

pago -> enviar o produto
pendente -> aguardar o pagamento
cancelado -> não enviar
em análise -> enviar o produto
versão segura: status desconhecido: em análise

Nenhuma condição bateu, o else concluiu que só podia ser “pago”, e o produto seria enviado antes da aprovação do pagamento, sem nenhuma mensagem de erro! Na versão segura, cada status conhecido tem a sua condição, e o else avisa que chegou um valor desconhecido. O padrão de codificação segura SEI CERT, da Universidade Carnegie Mellon, chama isso de completude lógica: uma sequência de if e else if deve terminar com um else que trate a condição inesperada.

O PHP e o C têm ajuda pronta para isso. No PHP 8, o match para com um erro quando nenhum braço corresponde ao valor. No C, com -Wall, o GCC avisa quando um switch deixa de fora um valor do enum, desde que o switch não tenha default.

Ver o match do PHP e o aviso do GCC

PHP:

<?php
// O caso que ninguém previu: o match do PHP não aceita valor sem braço

function acao_do_pedido(string $status): string {
    return match ($status) {
        "pago" => "enviar o produto",
        "pendente" => "aguardar o pagamento",
        "cancelado" => "não enviar",
    };
}

foreach (["pago", "pendente", "cancelado", "em análise"] as $status) {
    try {
        $acao = acao_do_pedido($status);
        echo $status, " -> ", $acao, "\n";
    } catch (\UnhandledMatchError $erro) {
        echo $status, " -> o PHP parou com ", get_class($erro), "\n";
    }
}

Saída:

pago -> enviar o produto
pendente -> aguardar o pagamento
cancelado -> não enviar
em análise -> o PHP parou com UnhandledMatchError

C:

/* O caso que ninguém previu: o compilador confere o switch por você */
#include <stdio.h>

typedef enum { PAGO, PENDENTE, CANCELADO, EM_ANALISE } Status;

const char *acao_do_pedido(Status status) {
    switch (status) {
    case PAGO:
        return "enviar o produto";
    case PENDENTE:
        return "aguardar o pagamento";
    case CANCELADO:
        return "não enviar";
    }
    return "status desconhecido";
}

int main(void) {
    printf("em análise -> %s\n", acao_do_pedido(EM_ANALISE));
    return 0;
}

Aviso do GCC, com -Wall:

alg_caso_esquecido.c: In function 'acao_do_pedido':
alg_caso_esquecido.c:7:5: warning: enumeration value 'EM_ANALISE' not handled in switch [-Wswitch]
    7 |     switch (status) {
      |     ^~~~~~

Saída:

em análise -> status desconhecido

Checar e depois agir

Esta só aparece quando duas coisas acontecem ao mesmo tempo. Pense em uma conta com R$ 100 e dois saques de R$ 100 pedidos no mesmo instante. Cada saque faz o if certinho: tem saldo? Então desconta.

Python:

# Checar e depois agir: dois saques de R$ 100 ao mesmo tempo, com saldo de R$ 100
import threading
import time

saldo = 100
trava = threading.Lock()

def sacar(valor):
    global saldo
    if saldo >= valor:           # checa
        time.sleep(0.1)          # a demora de verdade: banco de dados, rede...
        saldo = saldo - valor    # age
        print("saque de", valor, "liberado")
    else:
        print("saque de", valor, "negado")

def sacar_com_trava(valor):
    global saldo
    with trava:                  # só uma pessoa por vez entre checar e agir
        if saldo >= valor:
            time.sleep(0.1)
            saldo = saldo - valor
            print("saque de", valor, "liberado")
        else:
            print("saque de", valor, "negado")

def dois_saques_juntos(funcao):
    global saldo
    saldo = 100
    pessoas = [threading.Thread(target=funcao, args=(100,)) for _ in range(2)]
    for pessoa in pessoas:
        pessoa.start()
    for pessoa in pessoas:
        pessoa.join()
    print("saldo final:", saldo)

print("sem trava:")
dois_saques_juntos(sacar)
print("com trava:")
dois_saques_juntos(sacar_com_trava)

Saída:

sem trava:
saque de 100 liberado
saque de 100 liberado
saldo final: -100
com trava:
saque de 100 liberado
saque de 100 negado
saldo final: 0

Sem trava, os dois saques foram liberados: os dois perguntaram antes de qualquer um descontar, e os dois ouviram “sim”. A pausa de 0,1 segundo faz o papel da ida ao banco de dados e deixa essa janela aberta de propósito, para o erro aparecer em toda execução. A documentação do Python descreve esse risco no estilo “olhe antes de pular” (LBYL, em inglês) e indica as travas como uma das soluções: com a trava, só um saque por vez passa entre o checar e o agir.

Sacou? O if estava certo. O erro estava no intervalo entre o if e a ação.

O if que ninguém lembrava que existia

Em julho de 2012, a corretora americana Knight Capital instalou um código novo para participar de um programa da Bolsa de Nova York. Segundo a decisão da SEC, a comissão de valores mobiliários dos Estados Unidos, esse código reaproveitou uma flag, uma variável de liga e desliga, que antes ativava uma função antiga chamada Power Peg, sem uso desde 2003. E um técnico não copiou o código novo para um dos oito servidores.

Em 1º de agosto de 2012, nesse servidor, os pedidos marcados com a flag acionaram o Power Peg. Para atender 212 pedidos de clientes, o sistema mandou milhões de ordens ao mercado: 4 milhões de negócios em 154 papéis diferentes, em cerca de 45 minutos!!! O prejuízo passou de 460 milhões de dólares.

O if daquela flag protegia uma função que ninguém usava havia nove anos. Código morto atrás de um if não é inofensivo: se a função não é mais usada, apague a função e a condição que leva até ela. E não reaproveite uma flag antiga para um significado novo.

O if é a ferramenta mais simples da programação, e por isso é tão fácil exagerar. Antes de escrever o próximo, pergunte: essa decisão precisa estar aqui? Ela cobre todos os casos? Ela rodará milhões de vezes?

Agora é com você!

No papel:

  • Diga o que a função situacao devolve para as notas 7, 6.9 e 4.99.
  • Para a nota 6, quais condições da função situacao são testadas, e em que ordem?
  • Na função nome_do_estado, quantas condições são testadas para a sigla SP? E para uma sigla que não existe, como XX?
  • Reescreva em palavras, com “se” e “senão”, a regra: frete grátis para compras a partir de 200; frete de 15 entre 100 e 199,99; frete de 30 abaixo de 100.

No computador:

  • Programe a regra do frete do exercício anterior nas três linguagens e teste com 250, 200, 150 e 99.
  • Escreva um programa que receba três números e mostre o maior deles.
  • Faça um programa que diga se um número é positivo, negativo ou zero, e teste com um valor de cada tipo.
  • Reescreva a regra do frete com cláusulas de guarda e confira que a saída não muda.
  • No programa do saque, tire a trava e a pausa e rode várias vezes. O erro apareceu? Por que isso não prova que o código está certo?

Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!

Até o próximo artigo!

Confiança Sempre!!!

Fontes:

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager. Como esse contêiner também carrega tags de publicidade, as estatísticas só são ativadas junto com Publicidade e marketing.

Exibem anúncios do Google AdSense e medem campanhas e e-mails: pixels da Meta e do TikTok e o Mautic.

Permite que o Google escolha anúncios com base nos seus interesses. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade e marketing.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.