Funções — Noções básicas

As funções são os blocos básicos da programação. Ao agrupar código reutilizável em funções, você passa do nível de “escrever scripts” para o de “construir com blocos” — cada função se torna uma peça reutilizável.

1. Definição e chamada de funções

<?php
// Define a function
function greet() {
    echo "Hello, World!";
}

// Call the function
greet();  // Output: Hello, World!
greet();  // You can call it repeatedly
?>

Os nomes das funções não diferenciam maiúsculas de minúsculas (mas a convenção é usar letras minúsculas com sublinhados — snake_case):

GREET();  // This also works, but don't do it

2. Parâmetros e valores de retorno

As funções podem receber parâmetros (entrada) e retornar dados (saída):

<?php
// A function with a parameter
function greet($name) {
    return "Hello, {$name}!";
}

$msg = greet("John");
echo $msg;  // Hello, John!
?>

(1) Vários parâmetros

<?php
function calculateTotal($price, $quantity, $tax = 1.0) {
    return $price * $quantity * $tax;
}

echo calculateTotal(10, 3);        // 30 (tax uses the default of 1.0)
echo calculateTotal(10, 3, 1.13);  // 33.9 (custom tax passed in)
?>

3. Declarações de tipos (PHP 7+)

O PHP 7+ oferece suporte a declarações de tipo para parâmetros de função e valores de retorno, tornando seu código mais seguro:

<?php
// Parameter type declarations + return type declaration
function add(int $a, int $b): int {
    return $a + $b;
}

echo add(3, 5);      // 8
echo add("3", "5");  // 8 (PHP auto-converts)
// echo add("hello", 5); // TypeError!

// Other type declarations
function displayUser(string $name, int $age): void {
    echo "{$name}, {$age} years old";
}

function getPrice(float $price): string {
    return "$" . number_format($price, 2);
}
?>

▶ Exemplo: Função prática com declarações de tipo

<?php
// Combined type declarations: union type + void + default value
function formatPrice(int|float $price, string $currency = "$"): string {
    return $currency . number_format((float)$price, 2);
}

function logAction(string $user, string $action): void {
    echo "[" . date("H:i:s") . "] {$user} performed {$action}<br>";
}

echo formatPrice(39.9);         // $39.90
echo formatPrice(100);           // $100.00
logAction("admin", "logged in"); // [14:30:45] admin performed logged in
?>

4. Tipagem estrita (strict_types)

Por padrão, as declarações de tipo do PHP permitem a coerção automática de tipos ("3" pode ser passado para um parâmetro int). Ao ativar o modo estrito, os tipos devem corresponder exatamente:

▶ Exemplo: Modo Padrão x Modo Estrito

<?php
// Default mode: automatic type coercion
function double(int $n): int {
    return $n * 2;
}
echo double("5");  // 10 ("5" is auto-converted to int 5)

// Strict mode: by the book
declare(strict_types=1);

function doubleStrict(int $n): int {
    return $n * 2;
}
echo doubleStrict("5");  // TypeError! Must pass an int
echo doubleStrict(5);    // 10 ✅

function greetStrict(string $name): string {
    return "Hello, {$name}";
}
// echo greetStrict(123);  // TypeError! A number is not a string
echo greetStrict("John");  // ✅
?>

5. A instrução return

<?php
function getUser($id) {
    // Query the database... let's pretend we found a user
    if ($id <= 0) {
        return null;  // Invalid ID — bail out early
    }
    return [
        "id" => $id,
        "name" => "User{$id}"
    ];
}

$user = getUser(1);
if ($user !== null) {
    echo $user["name"];  // User1
}

// void function: returns nothing
function logError(string $message): void {
    // Write to the error log
    error_log($message);
    // Do not write return $something;
}
?>

Após return, a função é encerrada imediatamente. Isso é especialmente útil para cláusulas de guarda — para tratar casos excepcionais em primeiro lugar e retornar antecipadamente.

6. Comentários PHPDoc

Boas funções precisam de documentação. O PHPDoc é o padrão de comentários do PHP:

<?php
/**
 * Calculate the total price
 *
 * @param float $price    Unit price
 * @param int   $quantity Quantity purchased
 * @param float $tax      Tax rate (default 1.0 for tax-inclusive)
 * @return float Final total price
 *
 * Examples:
 *   calculateTotal(10, 3)       → 30.0
 *   calculateTotal(10, 3, 1.13) → 33.9
 */
function calculateTotal(float $price, int $quantity, float $tax = 1.0): float {
    return $price * $quantity * $tax;
}
?>

7. Convenções de nomenclatura de funções

Os nomes das funções PHP seguem o padrão comunitário snake_case:

// ✅ Good function names
function get_user_by_id($id) {}
function calculate_total_price($items) {}
function send_verification_email($email) {}

// ❌ Inconsistent naming
function GetUserById($id) {}    // Don't use PascalCase
function getUserById($id) {}    // Don't use camelCase (methods use this, not functions)
function getuserbyid($id) {}    // Don't use all-lowercase-no-separators

❓ Perguntas Frequentes

P: Quando devo usar o tipo de retorno void? R: Quando uma função realiza uma ação sem retornar dados — por exemplo, exibir uma página, gravar em um log, enviar um e-mail ou modificar o estado global. void indica aos chamadores: “Esta função faz algo — não espere um valor de retorno.”

P: Qual é a diferença entre declarações de tipo e conversão de tipo? R: As declarações de tipo na assinatura da função indicam “Espero esse tipo”. O PHP realiza automaticamente a conversão de tipos no momento da chamada. Ative strict_types para desativar a conversão automática — passar o tipo errado causará então um erro, o que é mais seguro.

P: Posso escrever código depois de return? R: Você pode, mas ele não será executado. return encerra a função imediatamente. Normalmente, seu IDE exibirá um aviso sobre “código inacessível”.

📖 Resumo

• function name($param): type { return ... } define uma função
• Os parâmetros podem ter valores padrão (devem vir depois dos parâmetros obrigatórios)
• As declarações de tipo (int, string, ?string, int|float) tornam o código mais seguro
• declare(strict_types=1) ativa o modo estrito — sem conversão automática de tipos
• void significa que não há valor de retorno; return encerra imediatamente a função
• Os nomes das funções seguem o formato snake_case — verbo + substantivo, como get_user_by_id
• Os comentários do PHPDoc são destinados tanto a pessoas quanto ao seu IDE

📝 Exercícios

1. Escreva uma função calculateBMI($weight, $height) que receba como parâmetros o peso (kg) e a altura (m), retorne o IMC (peso ÷ altura²) e acrescente uma avaliação como “Abaixo do peso / Normal / Acima do peso / Obeso”.
2. Ative o modo estrito e crie uma função formatCurrency(float $amount, string $symbol = "$"): string que formate um valor monetário. Use o modo estrito para garantir que o valor seja sempre um float.
3. Escreva uma função getPageUrl(string $base, int $page): string que crie uma URL de paginação. Se a página for 1, retorne apenas a base; caso contrário, acrescente ?page=N. Escreva comentários PHPDoc para ela.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós