Aprendiendo PHP, parte 10:

Funciones

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

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().