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

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.

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.

Ver a animação com as notas 6,5, 9 e 3

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

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:

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.

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:
- Manual do PHP, if, com a avaliação da expressão pelo valor booleano, o agrupamento de instruções com chaves e o if aninhado.
- Manual do PHP, elseif/else if, com a regra de que só a primeira condição verdadeira é executada.
- Manual do PHP, Estruturas de Controle, com a lista das estruturas da linguagem, entre elas if, else, elseif, switch e match.
- Documentação do Python, More Control Flow Tools, com o if, o elif como abreviação de else if, o else opcional e o comando match (em inglês).
- Universidade Federal de Campina Grande, Introdução à Programação, Fluxo de Controle, com o if-else para expressar decisões, a associação do else ao if mais interno e a decisão múltipla com else if (documento de aula).
- Universidade Federal de Pernambuco, Centro de Informática, Linguagem de Programação C, Aula 3, com os formatos simplificado e completo do if e o comando switch (PDF, slides de aula).
- Unicamp, Instituto de Computação, MC202, Desvio e Repetição, com o if simples e o if composto em C (PDF, slides de aula).
- USP, FFCLRP, Estruturas de Controle em PHP, com o comando de seleção if, que testa uma condição e executa uma ou várias linhas de código (PDF).
- Linguagem C: Descomplicada, apostila hospedada no Centro de Informática da UFPE, com os capítulos sobre o comando else e o aninhamento de if (PDF).
- ACM, CS2013, Software Development Fundamentals, com as estruturas de controle condicionais entre os conceitos fundamentais de programação (em inglês).
- Mike Bland, Finding More Than One Worm in the Apple, Communications of the ACM, julho de 2014, com a data da correção, o período em que a falha ficou no código, a linha goto repetida que pulou a etapa final da verificação e a regra de que o compilador de C ignora o recuo (também publicado na ACM Queue; em inglês).
- GCC 6 Release Series, Changes, com o aviso -Wmisleading-indentation, ligado pelo -Wall e ilustrado com o CVE-2014-1266, o goto fail (em inglês).
- Manual do GCC, Options to Request or Suppress Warnings, com os avisos -Wswitch, desligado pela presença do default, e -Wmisleading-indentation (em inglês).
- Manual do GCC, Options That Control Optimization, com o -fif-conversion, que transforma saltos condicionais em equivalentes sem desvio, e a vetorização de laços ligada no -O2 (em inglês).
- Princeton University, COS 375, Dealing with Branches, com a frequência de desvios em programas de uso geral e os ciclos perdidos a cada erro de previsão (PDF, slides de aula, em inglês).
- University of Washington, CSE 378, Lecture 13, com o descarte das instruções já iniciadas quando a previsão do desvio erra (PDF, slides de aula, em inglês).
- NIST, Special Publication 500-235, Structured Testing: A Testing Methodology Using the Cyclomatic Complexity Metric, de Arthur H. Watson e Thomas J. McCabe, com a definição da complexidade ciclomática, o número de testes, o limite de 10 e a relação com erros (em inglês).
- Steve McConnell, Code Complete, 2ª edição, recursos do capítulo 17, com a refatoração Replace Nested Conditional with Guard Clauses, de Martin Fowler, que usa vários return para reduzir o aninhamento de if (em inglês).
- SEI CERT C Coding Standard, MSC01-C. Strive for logical completeness, da Carnegie Mellon University, com o else final para tratar a condição inesperada (em inglês).
- Documentação do Python, Glossary, com os verbetes LBYL e race condition: a condição de corrida entre a pergunta e a ação e o uso de travas (em inglês).
- Documentação do Python, Truth Value Testing, com a lista de valores considerados falsos (em inglês).
- Documentação do Python, Floating-Point Arithmetic: Issues and Limitations, com a representação binária, o módulo decimal e a função math.isclose (em inglês).
- Documentação do Python, Design and History FAQ, com os dicionários implementados como tabelas hash por causa do desempenho nas buscas (em inglês).
- Manual do PHP, Booleanos, com os valores considerados false, entre eles o texto “0”.
- Manual do PHP, Comparison Operators, com a regra de que dois textos numéricos são comparados como números (em inglês).
- Manual do PHP, Floating point numbers, com a falta de representação exata de 0,1 em base 2, a notação com expoente e o aviso para não comparar esses números por igualdade (em inglês).
- Manual do PHP, hash_equals, função de comparação de textos protegida contra ataques de tempo (em inglês).
- Manual do PHP, match, com a comparação estrita e o UnhandledMatchError quando nenhum braço corresponde ao valor (em inglês).
- Manual do PHP, Arrays, com o array como mapa ordenado, que funciona também como tabela hash (em inglês).
- SEC, In the Matter of Knight Capital Americas LLC, Release No. 70694, de outubro de 2013, com a flag reaproveitada, o servidor sem o código novo e os números do incidente de 1º de agosto de 2012 (PDF, em inglês).
- SEC, comunicado 2013-222, com o resumo do caso Knight Capital, a instalação do código novo em julho de 2012 e o prejuízo de mais de 460 milhões de dólares (em inglês).
- Os exemplos foram executados em Python 3.13, PHP 8.3 e GCC 13. As medições de tempo foram feitas em uma máquina virtual com processador Intel Xeon de 2,1 GHz; em outra máquina, os números serão outros.

Continue a conversa