Estruturas de controle e funções

Aqui você aprende a dar lóg­i­ca ao seu códi­go: tomar decisões, repe­tir tare­fas e orga­ni­zar tudo em funções reuti­lizáveis. É o capí­tu­lo que trans­for­ma scripts sim­ples em pro­gra­mas de ver­dade.

---

Condicional if / elseif / else

A estru­tu­ra mais fun­da­men­tal de qual­quer lin­guagem:

php

<?php
$temperatura = 32;

if ($temperatura >= 35) {
    echo "Calor extremo — beba água!";
} elseif ($temperatura >= 25) {
    echo "Dia quente — use protetor solar.";
} elseif ($temperatura >= 15) {
    echo "Temperatura agradável.";
} else {
    echo "Frio — pegue um casaco.";
}
// Dia quente — use protetor solar.

Quan­do o blo­co tem ape­nas uma lin­ha, as chaves são opcionais — mas é boa práti­ca sem­pre usá-las:

php

<?php
$logado = true;

// Sem chaves (evite em blocos maiores)
if ($logado) echo "Bem-vindo!";

// Com chaves (sempre prefira)
if ($logado) {
    echo "Bem-vindo!";
}

---

switch — múltiplas condições no mesmo valor

Quan­do você com­para a mes­ma var­iáv­el con­tra vários val­ores, switch é mais limpo que vários elseif:

php

<?php
$diaSemana = date('N'); // 1=segunda ... 7=domingo

switch ($diaSemana) {
    case 1:
        echo "Segunda-feira";
        break;
    case 2:
        echo "Terça-feira";
        break;
    case 6:
    case 7:
        // Dois cases no mesmo bloco = compartilham a lógica
        echo "Fim de semana!";
        break;
    default:
        echo "Dia útil";
        break;
}

Atenção: sem o break, o PHP con­tin­ua exe­cu­tan­do os cas­es seguintes (com­por­ta­men­to chama­do de fall-through). Isso causa bugs difí­ceis de encon­trar.

---

match — o switch moderno (PHP 8+)

O match é mais seguro e con­ciso que o switch. Ele usa com­para­ção estri­ta (===) e sem­pre retor­na um val­or:

php

<?php
$status = 2;

$mensagem = match($status) {
    1       => "Pendente",
    2       => "Aprovado",
    3, 4    => "Rejeitado ou cancelado",  // múltiplos valores
    default => "Status desconhecido",
};

echo $mensagem; // Aprovado

// match lança erro se nenhum caso bater e não houver default
// switch apenas ignora — match é mais seguro

Com­para­n­do dire­ta­mente:

php

<?php
$val = "1";

// switch usa == (fraco): "1" == 1 é true
switch ($val) {
    case 1: echo "switch: entrou aqui!"; break; // ENTROU
}

// match usa === (estrito): "1" !== 1
$r = match($val) {
    1       => "inteiro um",
    "1"     => "string um",   // ENTROU aqui
    default => "outro",
};
echo $r; // string um

---

Laço while

Repete enquan­to a condição for ver­dadeira. A condição é ver­i­fi­ca­da antes de cada iter­ação:

php

<?php
$contador = 1;

while ($contador <= 5) {
    echo "Iteração $contador\n";
    $contador++;
}
// Iteração 1
// Iteração 2
// Iteração 3
// Iteração 4
// Iteração 5

---

Laço do...while

Igual ao while, mas a condição é ver­i­fi­ca­da depois — o blo­co exe­cu­ta pelo menos uma vez:

php

<?php
$tentativas = 0;

do {
    echo "Tentativa " . ($tentativas + 1) . "\n";
    $tentativas++;
} while ($tentativas < 3);
// Tentativa 1
// Tentativa 2
// Tentativa 3

// Útil quando você precisa que o bloco rode ao menos uma vez
// antes de checar a condição (ex: menus, validações interativas)

---

Laço for

Quan­do você sabe exata­mente quan­tas vezes quer repe­tir:

php

<?php
// for (inicialização; condição; incremento)
for ($i = 0; $i < 5; $i++) {
    echo "Item $i\n";
}

// Contagem regressiva
for ($i = 10; $i >= 0; $i--) {
    echo "$i ";
}
echo "\n"; // 10 9 8 7 6 5 4 3 2 1 0

// Incremento diferente de 1
for ($i = 0; $i <= 100; $i += 25) {
    echo "$i% ";
}
// 0% 25% 50% 75% 100%

// Tabuada do 7
for ($i = 1; $i <= 10; $i++) {
    echo "7 x $i = " . (7 * $i) . "\n";
}

---

Laço foreach

Feito espe­cial­mente para per­cor­rer arrays. É o mais usa­do no dia a dia:

php

<?php
// Array indexado
$frutas = ["maçã", "banana", "uva", "laranja"];

foreach ($frutas as $fruta) {
    echo "- $fruta\n";
}
// - maçã
// - banana
// - uva
// - laranja

// Array associativo: acessa chave E valor
$pessoa = [
    "nome"  => "Carlos",
    "idade" => 30,
    "cidade"=> "São Paulo",
];

foreach ($pessoa as $chave => $valor) {
    echo "$chave: $valor\n";
}
// nome: Carlos
// idade: 30
// cidade: São Paulo

// Array multidimensional
$alunos = [
    ["nome" => "Ana",   "nota" => 9.5],
    ["nome" => "Bruno", "nota" => 7.2],
    ["nome" => "Carla", "nota" => 8.8],
];

foreach ($alunos as $aluno) {
    echo "{$aluno['nome']}: {$aluno['nota']}\n";
}

---

break e continue

Con­tro­lam o fluxo den­tro de laços:

php

<?php
// break: para o laço completamente
for ($i = 1; $i <= 10; $i++) {
    if ($i === 5) {
        echo "Parou no $i!\n";
        break;
    }
    echo "$i ";
}
// 1 2 3 4 Parou no 5!

// continue: pula para a próxima iteração
for ($i = 1; $i <= 10; $i++) {
    if ($i % 2 === 0) continue; // pula os pares
    echo "$i ";
}
// 1 3 5 7 9

// break com nível: sai de laços aninhados
for ($i = 0; $i < 3; $i++) {
    for ($j = 0; $j < 3; $j++) {
        if ($j === 1) break 2; // sai dos 2 laços
        echo "$i,$j ";
    }
}
// 0,0

---

Funções — declaração e chamada

Funções agru­pam códi­go reuti­lizáv­el com um nome:

php

<?php
// Declaração
function saudar(string $nome): string {
    return "Olá, $nome!";
}

// Chamada
echo saudar("Maria");  // Olá, Maria!
echo saudar("João");   // Olá, João!

// Em PHP, funções podem ser chamadas ANTES de serem declaradas
// (ao contrário de variáveis e closures)
echo dobrar(5);        // 10

function dobrar(int $n): int {
    return $n * 2;
}

---

Parâmetros e valores padrão

php

<?php
// Parâmetros com valor padrão ficam sempre no final
function criarUsuario(
    string $nome,
    int    $idade,
    string $perfil = "visitante",  // padrão
    bool   $ativo  = true          // padrão
): string {
    $status = $ativo ? "ativo" : "inativo";
    return "$nome ($idade anos) — $perfil — $status";
}

echo criarUsuario("Ana", 25);
// Ana (25 anos) — visitante — ativo

echo criarUsuario("Bob", 30, "admin");
// Bob (30 anos) — admin — ativo

echo criarUsuario("Eva", 22, "editor", false);
// Eva (22 anos) — editor — inativo

Passagem por referência

Por padrão, PHP pas­sa var­iáveis por val­or (cópia). Com & você pas­sa a var­iáv­el orig­i­nal:

php

<?php
function incrementar(int &$numero): void {
    $numero++;  // modifica o original
}

$x = 10;
incrementar($x);
echo $x; // 11 — a variável original foi alterada

// Sem &
function incrementarCopia(int $numero): void {
    $numero++;  // modifica só a cópia local
}

$y = 10;
incrementarCopia($y);
echo $y; // 10 — o original não mudou

---

Escopo de variáveis

PHP tem escopo rígi­do: var­iáveis fora de funções não entram auto­mati­ca­mente:

php

<?php
$mensagem = "Olá do escopo global";

function testarEscopo(): void {
    // $mensagem não existe aqui!
    echo $mensagem ?? "variável não encontrada";
    // variável não encontrada
}

testarEscopo();

// Para acessar variável global dentro de função, use global
function comGlobal(): void {
    global $mensagem;
    echo $mensagem; // Olá do escopo global
}

comGlobal();

// Variáveis estáticas: mantêm valor entre chamadas
function contar(): void {
    static $total = 0;  // inicializa apenas na primeira chamada
    $total++;
    echo "Chamada número: $total\n";
}

contar(); // Chamada número: 1
contar(); // Chamada número: 2
contar(); // Chamada número: 3

---

Funções anônimas (closures)

Funções sem nome que podem ser armazenadas em var­iáveis:

php

<?php
// Closure básica
$saudar = function(string $nome): string {
    return "Olá, $nome!";
};

echo $saudar("Pedro"); // Olá, Pedro!

// Closures com use: capturam variáveis do escopo externo
$prefixo = "Dr.";

$saudarDoutor = function(string $nome) use ($prefixo): string {
    return "Olá, $prefixo $nome!";
};

echo $saudarDoutor("Silva"); // Olá, Dr. Silva!

// Muito usadas como callbacks
$numeros = [3, 1, 4, 1, 5, 9, 2, 6];

usort($numeros, function($a, $b) {
    return $a - $b;
});

print_r($numeros); // [1, 1, 2, 3, 4, 5, 6, 9]

---

Arrow functions — fn => (PHP 7.4+)

Ver­são com­pacta de clo­sures para expressões sim­ples. Cap­turam o escopo exter­no auto­mati­ca­mente (sem use):

php

<?php
// Closure tradicional
$dobrar = function(int $n): int { return $n * 2; };

// Arrow function equivalente — muito mais concisa
$dobrar = fn(int $n): int => $n * 2;

echo $dobrar(5); // 10

// Captura automática do escopo externo
$fator = 3;
$multiplicar = fn($n) => $n * $fator; // $fator capturado automaticamente
echo $multiplicar(7); // 21

// Perfeitas com array_map, array_filter, usort
$precos  = [10.0, 25.5, 5.0, 99.9, 15.0];
$caros   = array_filter($precos, fn($p) => $p > 20);
$dobrados = array_map(fn($p) => $p * 2, $precos);

print_r($caros);    // [25.5, 99.9]
print_r($dobrados); // [20.0, 51.0, 10.0, 199.8, 30.0]

---

Funções nativas essenciais

PHP tem cen­te­nas de funções prontas. As mais usadas:

php

<?php
// Strings
echo strlen("Olá, mundo");          // 10
echo strtoupper("olá");             // OLÁ
echo strtolower("OLÁ");             // olá
echo str_replace("mundo", "PHP", "Olá, mundo!"); // Olá, PHP!
echo str_pad("5", 3, "0", STR_PAD_LEFT);         // 005
echo trim("  espaços  ");           // "espaços"
echo substr("abcdef", 2, 3);        // cde
echo strpos("Olá, mundo", "mundo"); // 5

// Números
echo abs(-42);          // 42
echo ceil(4.1);         // 5  (arredonda para cima)
echo floor(4.9);        // 4  (arredonda para baixo)
echo round(4.567, 2);   // 4.57
echo max(3, 7, 1, 9);   // 9
echo min(3, 7, 1, 9);   // 1
echo rand(1, 100);       // número aleatório entre 1 e 100
echo number_format(1234567.891, 2, ',', '.'); // 1.234.567,89

// Arrays
$arr = [3, 1, 4, 1, 5];
echo count($arr);        // 5
sort($arr);
echo implode(", ", $arr); // 1, 1, 3, 4, 5
echo in_array(4, $arr) ? "tem 4" : "não tem 4"; // tem 4

---

Exemplo prático completo — sistema de notas

php

<?php
function calcularMedia(array $notas): float {
    if (empty($notas)) return 0.0;
    return array_sum($notas) / count($notas);
}

function classificarAluno(float $media): string {
    return match(true) {
        $media >= 9.0 => "Excelente",
        $media >= 7.0 => "Aprovado",
        $media >= 5.0 => "Recuperação",
        default       => "Reprovado",
    };
}

function gerarRelatorio(array $turma): void {
    echo str_pad("RELATÓRIO DA TURMA", 40, "=", STR_PAD_BOTH) . "\n\n";

    foreach ($turma as $aluno) {
        $media  = calcularMedia($aluno['notas']);
        $status = classificarAluno($media);
        $media  = number_format($media, 1, ',', '.');

        echo str_pad($aluno['nome'], 15);
        echo "Média: $media  ";
        echo "→ $status\n";
    }
}

// Dados
$turma = [
    ["nome" => "Ana Lima",    "notas" => [9.5, 8.0, 10.0, 9.0]],
    ["nome" => "Bruno Costa", "notas" => [6.0, 7.5, 6.5, 8.0]],
    ["nome" => "Carla Dias",  "notas" => [4.0, 5.0, 4.5, 6.0]],
    ["nome" => "Diego Melo",  "notas" => [3.0, 2.5, 4.0, 3.5]],
];

gerarRelatorio($turma);

Saí­da:

==========RELATÓRIO DA TURMA==========

Ana Lima       Média: 9,1  → Excelente
Bruno Costa    Média: 7,0  → Aprovado
Carla Dias     Média: 4,9  → Recuperação
Diego Melo     Média: 3,3  → Reprovado

---

Resumo do capítulo

Con­ceito	Detal­he
if/elseif/else	Decisões com condições encadeadas
switch	Com­para uma var­iáv­el con­tra múlti­p­los val­ores (usa ==)
match	Ver­são mod­er­na e estri­ta do switch, retor­na val­or (PHP 8+)
while	Repete enquan­to condição for true (ver­i­fi­ca antes)
do...while	Exe­cu­ta ao menos uma vez (ver­i­fi­ca depois)
for	Ide­al quan­do o número de iter­ações é con­heci­do
foreach	Feito para per­cor­rer arrays (index­a­dos e asso­cia­tivos)
break/continue	Con­tro­lam o fluxo den­tro de laços
Funções	Agru­pam códi­go reuti­lizáv­el com parâmet­ros e retorno
Escopo	Var­iáveis globais não entram em funções sem global
Clo­sures	Funções anôn­i­mas armazenadas em var­iáveis
Arrow func­tions	fn() => — sin­taxe com­pacta, cap­tura escopo auto­mati­ca­mente