🚀 Módulo 3: Funções e Programação Estruturada - Aula 1: Definindo e Chamando Funções

Olá, futuros desenvolvedores PHP! 👋 Sejam bem-vindos à primeira aula do Módulo 3, onde mergulharemos no fascinante mundo das funções. As funções são blocos fundamentais para organizar, reutilizar e manter seu código PHP.

Nesta aula, vamos entender:

O que são funções e por que as usamos.
Como definir suas próprias funções.
Como chamar (executar) funções.
A importância dos parâmetros para tornar suas funções flexíveis.
Como as funções podem retornar valores.
A utilização de declarações de tipo para parâmetros e retornos no PHP moderno.

1. Introdução: O Poder das Funções 💡

Imagine que você está construindo uma casa e precisa realizar a mesma tarefa repetidamente, como "colocar um tijolo". Em vez de escrever as instruções para "colocar um tijolo" toda vez, você criaria um "manual de como colocar um tijolo" e simplesmente diria "coloque um tijolo" quando necessário.

Em programação, uma função é exatamente isso: um bloco de código nomeado que executa uma tarefa específica. Uma vez definida, você pode "chamar" ou "invocar" essa função quantas vezes precisar, sem ter que reescrever o código.

Por que usar funções?

Reutilização de Código: Evita a repetição (princípio DRY - Don't Repeat Yourself).
Organização: Divide seu programa em partes menores e mais gerenciáveis.
Legibilidade: Torna o código mais fácil de ler e entender.
Manutenção: Alterações em uma tarefa específica precisam ser feitas em apenas um lugar (na função).

2. Definindo e Chamando Funções

2.1. Definindo uma Função Simples

Para definir uma função em PHP, usamos a palavra-chave function, seguida pelo nome da função e um par de parênteses (). O código que a função executará é colocado entre chaves {}.

<?php
// Definição da função
function exibirMensagemBoasVindas() {
    echo "Bem-vindo(a) ao curso de Fundamentos do PHP! 🎉\n";
}
?>

Regras para nomes de funções:

Devem começar com uma letra ou um underscore _.
Podem conter letras, números e underscores.
São case-insensitive (mas por convenção, sempre use a mesma capitalização).
Não podem ser palavras reservadas do PHP.

2.2. Chamando (Executando) uma Função

Depois de definir uma função, ela não faz nada até ser chamada. Para chamá-la, basta usar o nome da função seguido por parênteses e um ponto e vírgula.

<?php
function exibirMensagemBoasVindas() {
    echo "Bem-vindo(a) ao curso de Fundamentos do PHP! 🎉\n";
}
 
// Chamando a função
exibirMensagemBoasVindas(); // Saída: Bem-vindo(a) ao curso de Fundamentos do PHP! 🎉
exibirMensagemBoasVindas(); // Você pode chamá-la quantas vezes quiser!
?>

3. Parâmetros: Tornando Funções Flexíveis ⚙️

As funções se tornam realmente poderosas quando podemos passar informações para elas processarem. Essas informações são chamadas de parâmetros (ou argumentos, quando passados na chamada da função).

Parâmetros são variáveis listadas dentro dos parênteses na definição da função.

3.1. Funções com Parâmetros

<?php
function saudarPessoa($nome) {
    echo "Olá, " . $nome . "! Como você está hoje? 😊\n";
}
 
// Chamando a função com diferentes argumentos
saudarPessoa("Alice"); // Saída: Olá, Alice! Como você está hoje? 😊
saudarPessoa("Bob");   // Saída: Olá, Bob! Como você está hoje? 😊
?>

Você pode ter múltiplos parâmetros, separados por vírgulas:

<?php
function calcularSoma($numero1, $numero2) {
    $soma = $numero1 + $numero2;
    echo "A soma de " . $numero1 . " e " . $numero2 . " é: " . $soma . "\n";
}
 
calcularSoma(10, 5); // Saída: A soma de 10 e 5 é: 15
calcularSoma(100, 200); // Saída: A soma de 100 e 200 é: 300
?>

3.2. Valores Padrão para Parâmetros

Às vezes, você quer que um parâmetro tenha um valor padrão caso nenhum valor seja fornecido ao chamar a função. Isso é feito atribuindo um valor ao parâmetro na definição da função.

<?php
function saudarComPadrao($nome = "Visitante") {
    echo "Olá, " . $nome . "! Seja bem-vindo(a)! 👋\n";
}
 
saudarComPadrao("Carlos"); // Saída: Olá, Carlos! Seja bem-vindo(a)! 👋
saudarComPadrao();         // Saída: Olá, Visitante! Seja bem-vindo(a)! 👋 (usa o valor padrão)
?>

Importante: Parâmetros com valores padrão devem ser declarados depois dos parâmetros sem valores padrão.

<?php
// Correto: Parâmetro sem padrão, depois com padrão
function exibirInfoUsuario($nome, $idade = 30) {
    echo "Nome: $nome, Idade: $idade anos.\n";
}
 
exibirInfoUsuario("Maria");     // Saída: Nome: Maria, Idade: 30 anos.
exibirInfoUsuario("João", 25);  // Saída: Nome: João, Idade: 25 anos.
 
// Incorreto (causaria um erro de sintaxe):
// function exibirInfoInvalida($idade = 30, $nome) { /* ... */ }
?>

4. Retornando Valores de Funções ↩️

Até agora, nossas funções apenas imprimiram algo na tela. Mas muitas vezes, queremos que uma função calcule algo e nos devolva esse resultado para que possamos usá-lo em outras partes do nosso código. Para isso, usamos a palavra-chave return.

Quando o PHP encontra a instrução return, a função é imediatamente encerrada e o valor especificado é enviado de volta para onde a função foi chamada.

<?php
function somarNumeros($a, $b) {
    $resultado = $a + $b;
    return $resultado; // Retorna o valor da soma
}
 
// Chamando a função e armazenando o valor retornado em uma variável
$total1 = somarNumeros(10, 20);
echo "O total da primeira soma é: " . $total1 . "\n"; // Saída: O total da primeira soma é: 30
 
$total2 = somarNumeros(5, 7) * 2;
echo "O total da segunda soma multiplicado por 2 é: " . $total2 . "\n"; // Saída: O total da segunda soma multiplicado por 2 é: 24
 
// Você pode retornar qualquer tipo de dado: strings, arrays, objetos, etc.
function obterSaudacao($nome) {
    return "Olá, " . $nome . "!";
}
 
$saudacaoCompleta = obterSaudacao("Fernanda");
echo $saudacaoCompleta . "\n"; // Saída: Olá, Fernanda!
?>

Diferença entre echo e return:

echo imprime algo diretamente na tela (ou na saída HTTP).
return devolve um valor para o código que chamou a função, permitindo que esse valor seja usado ou armazenado.

5. Declarações de Tipo (Type Declarations) - PHP 7+ ✨

Desde o PHP 7, é possível adicionar declarações de tipo para parâmetros e para o valor de retorno das funções. Isso é uma prática excelente para tornar seu código mais robusto, legível e fácil de depurar, pois o PHP verificará se os tipos estão corretos.

5.1. Declarações de Tipo para Parâmetros

Você pode especificar o tipo de dados esperado para cada parâmetro. Se um valor de um tipo diferente for passado, o PHP lançará um erro TypeError.

<?php
// Declaração de tipo para parâmetro (int, float, string, bool, array, object, interfaces, classes)
function somarComTipos(int $num1, int $num2) {
    return $num1 + $num2;
}
 
echo "Soma com tipos: " . somarComTipos(5, 10) . "\n"; // Saída: Soma com tipos: 15
 
// Isso causaria um erro fatal (TypeError) se o modo estrito de tipos estiver habilitado
// ou um aviso/conversão se não estiver (coercive mode, padrão do PHP)
// echo somarComTipos("abc", 10);
?>

5.2. Declarações de Tipo para Retorno

Você também pode especificar o tipo de dados que a função deve retornar.

<?php
// Declaração de tipo para o retorno (int, float, string, bool, array, object, void, etc.)
function multiplicar(float $a, float $b): float {
    return $a * $b;
}
 
$resultadoMultiplicacao = multiplicar(3.5, 2.0);
echo "Multiplicação com tipos: " . $resultadoMultiplicacao . "\n"; // Saída: Multiplicação com tipos: 7
 
// Função que não retorna nada (apenas imprime) usa o tipo 'void'
function exibirMensagem(string $msg): void {
    echo $msg . "\n";
}
 
exibirMensagem("Esta função não retorna valor!");
?>

5.3. Tipos Nulos (Nullable Types) - PHP 7.1+

Se um parâmetro ou retorno pode ser de um tipo específico OU null, você pode usar o prefixo ? antes do tipo.

<?php
function saudarOpcional(?string $nome): ?string {
    if ($nome === null) {
        return null;
    }
    return "Olá, " . $nome . "!";
}
 
echo saudarOpcional("Pedro") . "\n"; // Saída: Olá, Pedro!
var_dump(saudarOpcional(null)); // Saída: NULL (a função retorna null e var_dump mostra isso)
?>

Recomendação: Sempre utilize declarações de tipo em seu código PHP moderno. Isso melhora a clareza, a detecção de erros e a compatibilidade com ferramentas de análise estática de código.

6. Exemplos Oficiais (Adaptados da Documentação PHP)

Os exemplos acima já seguem as boas práticas e o estilo da documentação oficial do PHP. Para mais detalhes e casos avançados, você sempre pode consultar:

7. Exercícios de Fixação (Teóricos e Práticos Rápidos) 🧠

Para solidificar seu aprendizado, tente responder às perguntas e criar as funções abaixo:

Qual a principal vantagem de usar funções em seu código?
Qual a diferença fundamental entre echo e return?
Crie uma função chamada calcularMedia que aceite três números como parâmetros ($n1, $n2, $n3) e retorne a média aritmética deles.
- Adicione declarações de tipo float para os parâmetros e para o retorno.
Modifique a função calcularMedia para que o terceiro número ($n3) seja opcional e tenha um valor padrão de 0.
- Como ficaria a chamada da função se você quisesse calcular a média de apenas dois números?
Crie uma função chamada verificarPar que receba um número inteiro (int) e retorne true se o número for par, e false caso contrário.
- Adicione a declaração de tipo bool para o retorno.

8. Resumo e Próximos Passos 🚀

Nesta aula, cobrimos os fundamentos essenciais das funções em PHP:

Definição: Usamos function nomeDaFuncao() { ... }.
Chamada: nomeDaFuncao();.
Parâmetros: Permitem passar dados para a função (function func($param1, $param2)).
Valores Padrão: Tornam parâmetros opcionais (function func($param = 'default')).
Retorno de Valores: A palavra-chave return envia um valor de volta da função.
Declarações de Tipo (PHP 7+): Melhoram a robustez do código especificando tipos para parâmetros e retornos (ex: function func(int $p): string).

Dominar funções é um passo crucial para escrever código PHP limpo, eficiente e escalável.

Próximos Passos: Na próxima aula, exploraremos o conceito de escopo de variáveis dentro e fora das funções, um tópico importante para entender como suas variáveis interagem no seu programa.

Até lá, pratique bastante com as funções! 💪

Fundamentos do PHP

Definindo e chamando funções: parâmetros e retorno