En PHP existen algo llamado funciones, éstas son instrucciones que podemos darle a nuestro código, como si fueran comportamientos almacenados que al ser invocados hacen algo. Existes funciones declaradas por el usuario y funciones propias de PHP, en esta publicación veremos las primeras.

En primer lugar en PHP una función se crea mediante la palabra reservada function + el nombre de la misma + apertura y cierre de paréntesis y finalmente dentro de llaves las líneas de código que se ejecutarán al llamar a la función:

<?php
   function nombreDeLaFuncion(){
      //Lo que hace la función.
   }
?>

Por ejemplo podríamos crear una función:

<?php
   function saludar(){
      echo 'Hola!!!';
   }
?>

Esto no hará nada más que crear en memoria la función que puede ser invocada más adelante. Para invocarla debemos llamarla por su nombre + los paréntesis:

<?php
   function saludar(){
      echo 'Hola!!!';
   }
   saludar();
?>

Al ejecutar saludar() esto devolverá por pantalla:

Hola!!!

 

Parámetros

Los parámetros, también llamados argumentos, son datos que podemos pasar a nuestra función para realizar una operación. Por ejemplo podríamos tener una función saludar() como la anterior a la que habrá que pasar como parámetro un nombre, y saludará a ese nombre:

<?php
   function saludar($nombre){
      echo "Hola $nombre";
   }
   saludar('Fernando');
?>

Esto devolverá por pantalla:

Hola Fernando

Notar que los parámetros, cuando se crea una función, se escriben con el mismo formato que una variable con el signo $ delante. Y además podemos agregar más de un parámetro:

<?php
   function sumar($num1, $num2){
      $resultado = $num1 + $num2;
      echo "El resultado de la suma es $resultado";
   }
   sumar(20, 7);
?>

Esto devolverá por pantalla:

El resultado de la suma es 27

 

Ahora bien, existen dos formas de pasar parámetros, por valor o por referencia. Hasta ahora lo hemos hecho por referencia, esto significa que las funciones no podrán alterar el código externo. Por ejemplo si tuviéramos algo cómo esto:

<?php
   function multiplicarPor2($num){
      $num *= 2;
   }
?>

A simple vista esta función recibe un número como parámetro y lo multiplica por 2, osea que si tuviéramos esto:

<?php
   function multiplicarPor2($num){
      $num *= 2;
   }
   $numero = 10;
   multiplicarPor2($numero);
   echo $numero;
?>

Podríamos deducir que el valor que devuelve por pantalla el script es 20, porque la función multiplica por 2 y 10  * 2 es igual a 20. Sin embargo el resultado de $numero sigue siendo:

10

Esto se debe, a como dije antes, las funciones que reciben datos como parámetros por valor no pueden modificar estos datos, ya que están por fuera de la función.

Sin embargo podríamos realizar esto mediante el pase de parámetros por referencia:

<?php
   function multiplicarPor2(&$num){
      $num *= 2;
   }
   $numero = 10;
   multiplicarPor2($numero);
   echo $numero;
?>

Para indicarle a nuestra función que un parámetro se pasa por referencia debemos usar el signo & delante del parámetro. En este caso, esto devolverá por pantalla:

20

 

Variables de entorno

Las variables que se declaran dentro de una función, nacen y mueren dentro de la misma, por tanto, si hiciéramos algo cómo esto:

<?php
   function setearVariable(){
      $nombre = 'Fernando';
   }
   setearVariable();
   echo $nombre;
?>

Esto nos devolverá un hermoso error:

Notice: Undefined variable: nombre

¿Y esto por qué? Porque cómo dijimos antes las variables que se declaran en una función, sólo existen dentro de la misma, si intentamos llamarla desde afuera el programa nos devolverá un error de tipo Notice (ya veremos los tipos de errores) porque para el programa esa variable no existe más que en la función. Por tanto, esto es muy importante de tener en cuenta de cómo trabaja una función, es como una especie de sub programa.

Los que sí podríamos hacer es crear dentro de la función una variable global, lo cual hará que está este disponible en el resto de la aplicación.

<?php
   function setearVariable(){
      global $nombre;
      $nombre = 'Fernando';
   }
   setearVariable();
   echo $nombre;
?>

En este caso la función $nombre sí funcionará en el resto del script a pesar de que se ha creado dentro de una función.

Variables estáticas

Como dijimos antes una variable declarada dentro de una función tiene utilidad dentro de la misma y al invocarse la función volverán a crearse todas las variables que estén dentro. Sin embargo a través de las variables estáticas PHP puede darnos la posibilidad de crear una función reutilizable en cada llamada:

<?php
   function aumentarNumero(){
      static $numero;
      $numero++;
      echo $numero . '<br />';
   }
   aumentarNumero();
   aumentarNumero();
   aumentarNumero();
?>

Esto nos devolverá por pantalla:

1
2
3

 

Retorno de una función

Dijimos que una función nos da la posibilidad de pasar datos de entradas, parámetros, pero las funciones también son capaces de devolvernos valores mediante la palabra reservada return. Por ejemplo podríamos crear una función llamada sumar() como la que creamos antes y devolver el resultado de la misma:

<?php
   function sumar($num1, $num2){
      $resultado = $num1 + $num2;
      return $resultado;
   }
   $resultado_de_suma = sumar(20, 7);
   echo $resultado_de_suma;
?>

Dentro de la variable $resultado_de_suma guardaremos lo que devuelve la función, así que al imprimir la variable por pantalla nos devolverá:

27

Una cosa que hay que tener en cuenta es que después de return el código que siga no será tenido en cuenta por el intérprete, por ejemplo:

<?php
   function sumar($num1, $num2){
      $resultado = $num1 + $num2;
      return $resultado;
      echo 'Esto no se tiene en cuenta';
   }
   $resultado_de_suma = sumar(20, 7);
   echo $resultado_de_suma;
?>

La línea:

echo 'Esto no se tiene en cuenta';

No se ejecutará debido a que está después de un return, y esto no sólo le indicará el valor que devuelve la función, sino que la misma ahí finaliza.

Además una función no puede devolver más de un valor, pero si en cambio puede devolver cualquier tipo de valor, por ejemplo un array:

<?php
   function sumar_restar($num1, $num2){
      $resultado = array(
         'suma' => $num1 + $num2,
         'resta' => $num1 - $num2
      );
      return $resultado;
   }
   $resultado_de_suma_resta = sumar_restar(20, 7);
   echo 'La suma es: ' . $resultado_de_suma_resta['suma'] . '<br />';
   echo 'La resta es: ' . $resultado_de_suma_resta['resta'] . '<br />';
?>

Los que nos devolverá por pantalla:

La suma es: 27
La resta es: 13

 

Funciones dentro de funciones

Dentro de una función podemos invocar otra sin ningún problema para así ahorrar líneas de código innecesaria. Por ejemplo podríamos tener dos funciones:

<?php
   function dividir($num1, $num2){
      $resultado = $num1 / $num2;
      return $resultado;
   }
   function verificarMultiplo2($num){
      if($num % 2 == 0){
         return true;
      }else{
         return false;
      }
   }
?>

La primer función divide dos números y retorna el resultado mientras que la segunda recibe un número y devuelve true si es múltiplo de 2 y false si no lo es:

<?php
   function dividir($num1, $num2){
      $resultado = $num1 / $num2;
      return $resultado;
   }
   function verificarMultiplo2($num){
      if($num % 2 == 0){
         return true;
      }else{
         return false;
      }
   }
   function dividir_y_verificar_multiplo_2($num1, $num2){
      $resultado = dividir($num1, $num2);
      $multiplo = verificarMultiplo2($resultado);
      return $multiplo;
   }
?>

La función dividir_y_verificar_multiplo_2() recibirá dos números y devolverá si el resultado de la división de ambos es múltiplo de 2, usando en su interior las otras dos funciones: dividir() y verificarMultiplo2().

 

Anterior: Aprendiendo PHP, parte 9: Bucles

Siguiente: Aprendiendo PHP, parte 11: Funciones nativas