Nenhum produto encontrado nessa seleção.
Uma função é um trecho de código encapsulado com objetivo específico que pode (ou não) receber parâmetros, utilizar qualquer parte do PHP (incluindo outras funções) para manipular os dados e retornar um valor de qualquer tipo.
O código dentro de uma função é encapsulado do código externo (e vice-versa), ou seja, a não ser que você queira, nada que estiver entre as chaves { e } (ações da função) é acessível ao código fora delas.
Criando uma função em php
Para declarar uma função em PHP, utilizamos o operador "function" seguido do nome que desejamos, os argumentos (parâmetros) que a função poderá receber, e, por fim, as ações vêm entre chaves { e }.
// Função com dois parâmetros
function nome_da_funcao ( $parametro1, $parametro2 ) {
// Cria uma variável local $retorno
$retorno = $parametro1 + $parametro2;
// Retorna a soma do parâmetro 1 e 2
return $retorno;
}Perceba que a palavra "return" (retorno) serve para retornar o valor que desejamos depois de executar as ações dentro da função. O interpretador do PHP para de ler o restante da função assim que encontrar a palavra "return", por este motivo, na grande maioria dos casos utilizamos essa palavra ao final da função para retornar o valor que desejamos.
No próximo exemplo, vamos criar uma função que calcula o quadrado de qualquer valor enviado.
// Função para calcular o quadrado
function calcula_quadrado ( $numero ) {
// Garante que o parâmetro é do tipo numérico
$numero = (int)$numero;
// Retorna o número ao quadrado
return $numero * $numero;
}
// Executa a função e exibe 15625 na tela
echo calcula_quadrado(125);Veja acima, que a função não executa nenhuma ação se ela não for chamada.
Para chamar uma função, utilizamos apenas seu nome, e os parâmetros entre parênteses e separados por vírgula.
Você também pode criar funções sem parâmetro, ou sem a palavra "return". Veja:
// Função sem parâmetros e sem retorno
function exibe_frase () {
echo 'Eu sou uma função que executa a ação.';
}
// Chama a função
exibe_frase();
Variáveis
A seguir vamos ver a ligação entre as funções e as variáveis.
Variáveis Globais e Variáveis Locais
As variáveis criadas dentro das função têm escopo local, isso significa que o código externo à função não sabe da existência de qualquer variável dentro do mesma.
Veja um exemplo de código que irá retornar um erro:
// Uma variável fora da função
$variavel_externa = 'Valor';
// Uma função
function erro () {
// Variável local
$variavel_local = 'Valor';
// Tenta acessar a variável externa
echo $variavel_externa;
}
// Chama a função e obtém um erro:
// Undefined variable: variavel_externa
erro();
// Tenta acessar a variável local da função erro()
// Gera outro erro: Undefined variable: variavel_local
echo $variavel_local;Para definir que uma variável terá escopo global, ou seja, acessível em qualquer parte do código, devemos utilizar a palavra chave "global". Por exemplo:
<?php
// Uma variável fora da função
$variavel_externa = 'Valor externo';
// Uma função
function certo () {
// A variável abaixo estará acessível dentro e fora da função
global $variavel_global;
// A variável externa também estará acessível na função
global $variavel_externa;
// Define o valor da variável global
$variavel_global = 'Valor local';
// Exibe a variável externa
echo $variavel_externa;
}
// Chama a função e exibe a variável externa
certo();
// Acessa a variável criada dentro da função
echo $variavel_global; Variáveis estáticas
Variáveis estáticas são variáveis que mantém o valor da última execução da função, ou seja, se você executar a função duas vezes somando o valor da variável estática (apenas como exemplo), ele sempre irá aumentar de onde parou na última execução.
Veja um exemplo:
<?php
function andar ( $distancia ) {
// Define que a variável é estática
static $soma;
// Soma a distancia
$soma += $distancia;
// Retorna a distancia
return $soma;
}
// O valor da soma será sempre aumentado
echo andar(1); // 1
echo andar(10); // 11
echo andar(21); // 32
echo andar(220); // 252
echo andar(1); // 253
Passando parâmetros para a função
Como descrevi no início do artigo, podemos (ou não) passar parâmetros para a função. Os parâmetros são simplesmente valores que podemos manipular nas ações da função para retornar um valor qualquer.
Por exemplo:
<?php
// Uma função que remove espaços das frases
function remove_espacos( $frase ) {
return preg_replace('/s/is', '', $frase);
}
// Uma frase qualquer;
$texto_qualquer = 'Eu adoro trabalhar com PHP';
// Exibe: EuadorotrabalharcomPHP
echo remove_espacos($texto_qualquer);
No exemplo acima, o parâmetro é a variável $frase.
Sempre que chamarmos a função, qualquer coisa que colocarmos entre parênteses:
echo remove_espacos('Qualquer coisa');Será o valor do parâmetro $frase.
Se quisermos criar mais de um parâmetro, devemos separá-los por vírgula:
<?php
// Uma função que soma os parâmetros
function soma_parametros ( $num1, $num2, $num3 ) {
// Retorna a soma
return $num1 + $num2 + $num3;
}
// Chama a função
echo soma_parametros(10, 50, 101); // 161Quando chamamos a função, devemos enviar os valores na mesma ordem em que os parâmetros foram criados, como você pôde perceber no trecho de código acima.
Você também pode definir valores padrão para os parâmetros, assim, se o desenvolvedor esquecer de enviar os parâmetros, o valor definido é assumido.
Veja o mesmo exemplo anterior, agora com alguns parâmetros definidos:
<?php
// Uma função que soma os parâmetros
function soma_parametros ( $num1 = 10, $num2, $num3 = 1 ) {
// Retorna a soma
return $num1 + $num2 + $num3;
}
// Chama a função
echo soma_parametros(false, 50); // 51No trecho acima, estou definindo valores para os parâmetros 1 e 3. Se eu chamar a função com um valor falso no local onde apareceria o parâmetro 1, o valor 0 será assumido pela função. Como o parâmetro 2 não tem valor definido, é obrigatório enviá-lo à função, portanto, 50 é definido para ele. O parâmetro 3 tem valor definido, portanto, ele não é obrigatório, a função irá assumir o valor "1" para ele.
Por isso, o trecho de código abaixo:
echo soma_parametros(false, 50); // 51
Seria o mesmo que eu somar 0 + 50 + 1 = 51.
Pode parecer confuso, mas na verdade é bastante simples.
Passando parâmetros por referência
Até agora, estamos passando valores para a função de maneira comum, ou seja, alterações feitas no valor da variável, não afetaram seu valor fora da função. Se você precisa alterar o valor da variável dentro da função e obter esse mesmo valor fora dela, é possível passar o parâmetro por referência.
Para isso, basta adicionar um & antes do parâmetro.
<?php
// Cria uma função que soma o valor um com o valor
function soma ( &$valor1, $valor2 ) {
// Faz a soma
$valor1 += $valor2;
}
// Cria uma variável chamada $qlq_coisa
$qlq_coisa = 50;
// Executa a função
soma($qlq_coisa, 10);
// Mostra 60 na tela
echo $qlq_coisa;Perceba que, pelo simples fato de ter um & antes do primeiro parâmetro, qualquer coisa que eu enviar para a função no primeiro parâmetro, será passado por referência e as alterações feitas em seu valor dentro da função, afetam seu valor fora dela.
Parâmetros dinâmicos
Caso seja necessário criar funções que tenham vários parâmetros criados dinamicamente, basta criar uma função sem parâmetros e enviar vários argumentos (valores) quando for chamar a mesma.
O PHP tem várias funções para extrair valores enviados para a função, como func_get_args, que retorna um array contendo os argumentos enviados na chamada da função.
Veja um exemplo:
<?php
// Cria uma função que soma o valor um com o valor
function exibe_parametros () {
// Array com os parâmetros da função
$paramentros = func_get_args();
// Laço para exibir os parâmetros
foreach ( $paramentros as $posicao => $valor ) {
// Exibe todos os parâmetros
echo 'Parâmetro ' . $posicao . ': ' . $valor . '<br>';
}
}
// Chama a função com quantos parâmetros quiser
exibe_parametros('Valor 1', 'Valor 2', 'Valor 3');No trecho acima, minha função não tem parâmetros:
function exibe_parametros () {
}Mas na chamada, envio vários argumentos (valores dos parâmetros):
exibe_parametros('Valor 1', 'Valor 2', 'Valor 3');Com isso, posso obter esses valores dinamicamente dentro da função.
Recursividade: função que chama ela mesma
O PHP permite recursividade, ou seja, uma função que chama ela mesma dentro de suas ações. Veja um exemplo:
<?php
// Conta de 1 até um limite
function conta_10 ( $limite = 10 ) {
// Especifica que o valor será estático
static $valor;
// Verifica se o valor é menor ou igual ao limite
if ( $valor < $limite ) {
// Soma mais um no valor
$valor++;
// Mostra o valor
echo $valor . '<br>';
// Chama a função novamente e começa tudo de novo
conta_10();
}
}
// Chama a função apenas uma vez
// A recursividade fará o resto das chamadas
conta_10();Na função acima, ela é chamada novamente em suas ações até que o $valor (variável estática) atinja o limite (parâmetro).
Como resultado, teremos:
1<br> 2<br> 3<br> 4<br> 5<br> 6<br> 7<br> 8<br> 9<br> 10<br>
Não é algo muito útil, mas detalha bem como funciona a recursividade.
Concluindo
As funções são excelentes para reutilização, o que poupa tempo para os desenvolvedores. Você pode criar uma função faz algo simples e utilizá-la em várias partes do seu código.
Além disso, fica bem mais simples para dar manutenção, melhorar, ou alterar seu código, já que tudo fica em um único local.
As funções também farão parte da sua vida quando iniciarmos as partes sobre orientação a objetos, portanto, aprenda bem todos os trechos detalhados nesse artigo.
Em caso de dúvidas, basta perguntar nos comentários abaixo.
Não deixe de seguir o restante das aulas do nosso curso gratuito de PHP.
