PHP Academy · Aula

Parâmetros padrão e variádicos

Use valores padrão e argumentos variádicos em funções PHP.

Parâmetros padrão e variádicos é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Valores de parâmetros padrão

Os valores padrão permitem que quem chama a função omita argumentos. O valor padrão é usado quando o argumento não é fornecido:

<?php
function createUser(string $name, string $role = 'viewer'): string {
    return "$name ($role)";
}

echo createUser('Alice');          // Alice (viewer)
echo createUser('Bob', 'admin');   // Bob (admin)

Regras para valores padrão

Regras importantes para parâmetros padrão:

Parâmetros com valores padrão devem vir depois dos parâmetros obrigatórios
Os valores padrão devem ser expressões constantes — não chamadas de funções nem variáveis
Os argumentos nomeados do PHP 8 flexibilizam o requisito de ordenação

Parâmetros anuláveis

Use ?type para permitir NULL como argumento válido, com NULL como valor padrão:

<?php
function findUser(?int $id = null): string {
    if ($id === null) {
        return 'Searching all users';
    }
    return "User #$id";
}

echo findUser();    // Searching all users
echo findUser(42);  // User #42

Funções variádicas com ...

Use ... antes de um parâmetro para aceitar um número variável de argumentos como um array:

<?php
function sum(int ...$numbers): int {
    return array_sum($numbers);
}

echo sum(1, 2, 3);        // 6
echo sum(10, 20, 30, 40); // 100

Variádicos com parâmetros obrigatórios

Você pode combinar parâmetros obrigatórios com um parâmetro variádico no final:

<?php
function logMessage(string $level, string ...$messages): void {
    foreach ($messages as $msg) {
        echo "[$level] $msg" . PHP_EOL;
    }
}

logMessage('INFO', 'App started', 'Config loaded');

Operador de expansão na chamada

Use ... ao chamar uma função para expandir um array em argumentos individuais:

<?php
function add3(int $a, int $b, int $c): int {
    return $a + $b + $c;
}

$args = [1, 2, 3];
echo add3(...$args);  // 6

$extra = [4, 5];
echo add3(1, ...$extra);  // 10

Argumentos nomeados (PHP 8)

Os argumentos nomeados permitem que você forneça valores pelo nome do parâmetro, ignorando a ordem:

<?php
function createTag(string $tag, string $content, string $class = ''): string {
    $cls = $class ? " class=\"$class\"" : '';
    return "<$tag$cls>$content</$tag>";
}

// Skip $class, pass $content by name
echo createTag(content: 'Hello', tag: 'p');
// <p>Hello</p>

Argumentos nomeados com funções integradas

Os argumentos nomeados também funcionam com as funções integradas do PHP:

<?php
$arr = [3, 1, 4, 1, 5];

// Traditional positional
$result1 = array_slice($arr, 1, 3);

// Named arguments
$result2 = array_slice(array: $arr, offset: 1, length: 3);

print_r($result1); // [1, 4, 1]

func_get_args() legado

Antes da sintaxe variádica do PHP 5.6, func_get_args() era usado para acessar todos os argumentos. Você pode encontrá-lo em código legado:

<?php
function legacySum(): int {
    $args = func_get_args();
    return array_sum($args);
}

echo legacySum(1, 2, 3, 4);  // 10
// Modern: use int ...$numbers instead

Parâmetros variádicos com tipos declarados

Combine declarações de tipo com parâmetros variádicos para obter uma entrada rigorosa:

<?php
declare(strict_types=1);

function joinStrings(string $sep, string ...$parts): string {
    return implode($sep, $parts);
}

echo joinStrings('-', 'a', 'b', 'c');  // a-b-c
// joinStrings('-', 'a', 42); // TypeError in strict mode

Combinando valores padrão e argumentos nomeados

Argumentos nomeados e valores padrão funcionam juntos para oferecer o máximo de flexibilidade:

<?php
function sendEmail(
    string $to,
    string $subject,
    string $body = '',
    bool   $html  = false
): bool {
    // simulate send
    return true;
}

// Skip $body, pass $html by name
sendEmail('a@b.com', 'Hi', html: true);

Verificação rápida

O que o operador ... faz na definição de uma função do PHP?

Recapitulação: parâmetros padrão e variádicos

Resumo:

Valores padrão permitem parâmetros opcionais
Parâmetros com valores padrão vêm depois dos obrigatórios
?type permite NULL com um valor padrão opcional
...$args reúne argumentos variádicos em um array
O operador de expansão ...$arr expande um array no local da chamada
Argumentos nomeados (PHP 8) são passados pelo nome, não pela posição

Perguntas Frequentes

A aula “Parâmetros padrão e variádicos” é grátis?

Sim — o texto completo de “Parâmetros padrão e variádicos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Parâmetros padrão e variádicos”?

Use valores padrão e argumentos variádicos em funções PHP. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Parâmetros padrão e variádicos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy