Funções em PHP

Função é um trecho de código que pode ser invocado a partir de qualquer parte do projeto. Executa uma determinada tarefa e retorna um determinado valor. Neste post veja funções em PHP.

  <?php
  
  //declaração da função
  function ola () {
     return "Tudo bem?"; //retorno da função
  }
  
  //invocação da função
  echo ola();
 ?>

É possível armazenar o retorno de uma função em uma variável ou manipular o retorno diretamente:

  function salario () {
     return 2.360,00; 
  }
  
  function nome () {
     return "Benedito";
  }
  
  $nome = nome(); //armazenado o retorno na variável
  $total = salario() * 2; //armazenamos o retorno, multiplicado por 2, em uma variável  
  
  $tamanhoString = strlen($retorno); //atribuimos o valor de retorno a outra função

As funções também podem receber informações para que possam realizar determinadas tarefas.

Essas informações são denominadas parâmetros ou argumentos, que podem ser mais de um (separados por vírgula):

 function soma($valor1, $valor2) { //função que recebe dois parâmetros
  return $valor1 + $valor2;//retorna a soma com base nos valores passados como parâmetros
 }
 echo soma(1,1) //chama a função passando dois parâmetros, separados por vírgula

Também é possível definir um valor padrão para um determinado parâmetro:

 //função com dois parâmetros mas somente o segundo é obrigatório, pois foi definido o valor 3 para o primeiro
 function soma($valor1 = 3, $valor2) { 
  return $valor1 + $valor2;
 } 

Por padrão, argumentos de função são passados por valor (de forma que se você mudar o valor do parâmetro dentro da função, ele não é alterado fora da função).

Para permitir que uma função modifique os seus argumentos, eles devem ser passados por referência.

Passagem de parâmetros por valor:

 $x = 5;
 
 function alteraValor($y) {
   $x += 10; //a variável x é alterada apenas dentro da função
   return $x;
 }
 
 echo alteraValor($x); //mostra o valor 15 → 5 + 10
 echo $x;  //mostra o valor 5, pois a variável fora da função não foi alterada

Passagem de parâmetros por referência:

 $x = 5;
 
 //a variável x é alterada levando em conta o seu endereço em memória (referência)
 function alteraValor(&$y) { //acrescenta-se & antes da variável
   $x += 10; 
   return $x;
 }
 
 echo alteraValor($x); //mostra o valor 15 → 5 + 10
 echo $x;  //mostra o valor 15 → 5 + 10, pois foi alterada dentro da função

Também é possível usar o conceito de parâmetros por referência dentro de uma estrutura FOREACH:

 $pessoas = array(
   'nome' => 'Maria',
   'idade' => 65
  );
  
  foreach($pessoas as &$value) {
   //se o tipo do valor for igual a inteiro...
   if(gettype($value) === 'integer') $value +=5;//acrescenta-se +5 ao mesmo
    echo $value. '<br>';
  }
  
  print_r($pessoas); 
  Será mostrado:  Array ( [nome] => Maria [idade] => 70 )

Também podemos declarar os tipos de dados que uma função receberá, tais como “int”, “string”, “float” e “bool”.

Não há limites para a quantidade de argumentos. Para esse recurso damos o nome de declaração de tipos escalares:

 //definimos o tipo, três pontos (...) e a variável que receberá os valores
 function soma(int ...$valores) {
  return array_sum($valores); //array_sum soma os valores dos argumentos
 }
 
 echo soma(1,2,5); //mostrará o valor 8 → 1 + 2 + 5

Se for passado um valor de argumento do tipo “float”, por exemplo, somente a parte decimal será somada.

Além de podermos definir o tipo dos argumentos de entrada, podemos também definir o tipo de retorno:

 //recebe argumentos do tipo float e faz um cast (conversão) para o tipo string
 function soma(float ...$valores):string {
  return array_sum($valores);
 }
 
 echo soma(1,2.5,1.1); //mostra "4,6" → somou 1 + 2.5 + 1.1 e converteu para string

Uma função recursiva é aquela que invoca a si mesma. Por exemplo, uma função que calcula o fatorial de um número:

  $numero = 10;
  echo "O fatorial de $numero é : ".fat($numero);
  
  function fat($numero){
   if($numero==0)
    return 1;
   else
    return $numero * fat($numero-1);
  }

Acima, a função “fat” calcula o fatorial de 10 (10!), ou seja, 10*9*8*7*6*5*4*3*2 = 3628800.

Funções anônimas, também conhecidas como closures, permitem a criação de funções que não tem o nome especificado.

Elas são mais úteis como o valor de parâmetros callback, mas podem tem vários outros usos:

  function teste($callback) { 	 
    //processamento
    $callback();
  }
 
  teste(function() {
    echo "O processo terminou!";
  });

Também podemos atribuir uma função a uma variável:

 $var = function($x) {
   var_dump($x); //var_dump() exibe o tamanho e tipo da variável
 };

 $var("Criandobits"); //Mostra: string(11) "Criandobits"

Para mais detalhes sobre funções, acesse https://www.php.net/manual/pt_BR/language.functions.php

Como integrar o noCAPTCHA em seu site em PHP

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits