Funciones
Al no declararse los tipos de datos, los parámetros de las funciones no tienen tipo ni se indica el tipo de dato que devuelven. El paso de parámetros se realiza por valor, es decir, se realiza una copia de la variable.
<?php
function nombreFuncion($par1, $par2, ...) {
// código
return $valor;
}
$resultado = nombreFuncion($arg1, $arg2, …);
?>
Por ejemplo:
<?php
function diaSemana() {
$semana = [ "lunes", "martes", "miércoles",
"jueves", "viernes", "sábado", "domingo" ];
$dia = $semana[rand(0, 6)];
return $dia;
}
$diaCine = diaSemana();
echo "El próximo $diaCine voy al cine.";
?>
Parámetros por referencia
Si queremos pasar un parámetro por referencia, en la declaración de la función, indicaremos los parámetros mediante el operador & para indicar la dirección de memoria de la variable.
<?php
function duplicarPorValor($argumento) {
$argumento = $argumento * 2;
echo "Dentro de la función: $argumento.<br>";
}
function duplicarPorReferencia(&$argumento) {
$argumento = $argumento * 2;
echo "Dentro de la función: $argumento.<br>";
}
$numero1 = 5;
echo "Antes de llamar: $numero1.<br>";
duplicarPorValor($numero1);
echo "Después de llamar: $numero1.<br>";
echo "<br>";
$numero2 = 7;
echo "Antes de llamar: $numero2.<br>";
duplicarPorReferencia($numero2);
echo "Después de llamar: $numero2.<br>";
?>
Parámetros por defecto / opcionales
Permiten asignar valores en la declaración, y posteriormente, dejar el argumento en blanco.
<?php
function obtenerCapital($pais = "todos") {
$capitales = array("Italia" => "Roma",
"Francia" => "Paris",
"Portugal" => "Lisboa");
if ($pais == "todos") {
return array_values($capitales);
} else {
return $capitales[$pais];
}
}
print_r(obtenerCapital());
echo "<br/>";
echo obtenerCapital("Francia");
En el caso de convivir con otro tipo de parámetros, los parámetros que tienen el valor asignado por defecto siempre se colocan al final.
<?php
function saluda($nombre, $prefijo = "Sr") {
echo "Hola ".$prefijo." ".$nombre;
}
saluda("Aitor", "Mr");
saluda("Aitor");
saluda("Marina", "Srta");
Parámetros variables
Podemos tener funciones donde en la declaración no indiquemos la cantidad de datos de entrada.
$arrayArgs = func_get_args();→ Obtiene un array con los parámetros$cantidad = func_num_args();→ Obtiene la cantidad de parámetros recibidos$valor = func_get_arg(numArgumento);→ Obtiene el parámetro que ocupa la posiciónnumArgumento.
Estas funciones no se pueden pasar como parámetro a otra función (como funciones variable, que veremos más adelante). Para ello, debemos guardar previamente la función en una variable.
<?php
function sumaParametros() {
if (func_num_args() == 0) {
return false;
} else {
$suma = 0;
for ($i = 0; $i < func_num_args(); $i++) {
$suma += func_get_arg($i);
}
return $suma;
}
}
echo sumaParametros(1, 5, 9); // 15
?>
Desde PHP 5.6, se puede utilizar el operador ... (variadics) el cual "disfraza" los parámetros como un array:
<?php
function sumaParametrosMejor(...$numeros) {
if (count($numeros) == 0) {
return false;
} else {
$suma = 0;
foreach ($numeros as $num) {
$suma += $num;
}
return $suma;
}
}
echo sumaParametrosMejor(1, 5, 9); // 15
?>
...También se puede utilizar para dividir un array en variables separadas para proporcionar argumentos
<?php
function suma($a, $b) {
return $a + $b;
}
echo suma(...[1, 5])."<br />";
$a = [1, 5];
echo suma(...$a);
?>
Argumentos con nombre
Desde PHP 8.0 podemos pasar los argumentos con el nombre (además de por posición, como hemos hecho hasta ahora). Los argumentos con nombre se pasan poniendo el nombre como prefijo del parámetros separado por dos puntos: $resultado = funcion( arg1 : valor1, arg2 : valor2);
Esta característica complementa los parametros opcionales permitiendonos saltar su valor:
<?php
function funcionArgumentosNombre($a, $b = 2, $c = 4) {
echo "$a $b $c";
}
funcionArgumentosNombre(c: 3, a: 1); // "1 2 3"
Tanto los parámetros opcionales como los obligatorios pueden tener nombre, pero lo argumentos con nombre se tienen que poner después de los que no lo tienen.
<?php
funcionArgumentosNombre(1, c: 3); // "1 2 3"
Funciones tipadas
Desde PHP7 en las funciones, tanto los parámetro como su devolución, permiten la definición de tipos. Esto se conoce como strict_types (tipado estricto) y hay que definirlo en la primera línea de cada archivo .php para que el propio interprete PHP compruebe los tipos y lance errores si los tipos son incorrectos, mediante la sentencia
<?php
declare(strict_types=1);
Así pues, vamos a definir los tipos de los parámetros y de los valores devueltos mediante los tipos:
int, float, string, bool, object y array.
Si una función no devuelve nada se indica mediante el tipo void.
<?php
declare(strict_types=1);
function suma(int $a, int $b) : int {
return $a + $b;
}
$num = 33;
echo suma(10, 30);
echo suma(10, $num);
echo suma("10", 30); // error por tipificación estricta, sino daría 40
?>
Alcance
Las variables definidas fuera de las funciones tienen alcance global: accesibles desde cualquier función. Los parámetros de una función y las variables declaradas dentro de una función (se conocen como variables locales) sólo son accesibles desde dentro de la misma función → alcance de función.
En caso de conflicto, tienen prioridad las variables locales. Para evitar el conflicto, dentro de la función, podemos declarar la variable como global.
<?php
function miCiudad() {
$ciudad = "Elche";
echo "Dentro de la función: $ciudad.<br>";
}
$ciudad = "Alicante";
echo "Antes de la función: $ciudad.<br>";
miCiudad();
echo "Después de la función: $ciudad.<br>"
?>
<?php
function miCiudad() {
global $ciudad;
$ciudad = "Elche";
echo "Dentro de la función: $ciudad.<br>";
}
$ciudad = "Alicante";
echo "Antes de llamar: $ciudad.<br>";
miCiudad();
echo "Después de llamar: $ciudad.<br>"
?>
Se debe evitar el uso de variables globales dentro de las funciones. En el caso de necesitarlas, es mejor pasarlas como parámetro a las funciones.
Funciones variable
- Permite asignar una función a una variable.
- Nombre de la función entre comillas.
- Si una variable va seguida de paréntesis, PHP buscará una función con su valor.
<?php
$miFuncionSuma = "suma";
echo $miFuncionSuma(3,4); // invoca a la función suma
?>
Funciones anónimas
PHP permite la definición y uso de funciones anónimas, es decir, funciones que no tienen nombre, y se utilizan principalmente para gestionar los callbacks. Este tipo de funciones se utiliza mucho en JavaScript para gestionar los eventos y promesas.
<?php
$anonima = function() {
echo "Hola";
};
$anonima();
$anonimaConParametro = function($nombre) {
echo "Hola ".$nombre;
};
$anonimaConParametro("Aitor");
// Uso de variables externas a la función anónima --> `use`
$mensaje = "Hola";
$miClosure = function() use ($mensaje) {
echo $mensaje;
};
$miClosure();
// Uso de parámetros
$holaPHP = function($arg) use ($mensaje) {
echo $mensaje." ".$arg;
};
$holaPHP("PHP");
?>
Desde PHP 7.4 se han introducido las funciones flecha (arrow functions) para simplificar su definición y uso.
Tienes más información sobre funciones anónimas y flecha en el siguiente artículo (en inglés): Funciones anónimas y flecha en PHP
Biblioteca de funciones
Podemos agrupar un conjunto de funciones en un archivo, para permitir su reutilización. Posteriormente, se incluye con:
include(archivo);/include_once(archivo);require(archivo);/require_once(archivo);
Si no encuentra el archivo, require lanza un error fatal, include lo ignora
Las funciones _once sólo se cargan una vez, si ya ha sido incluida previamente, no lo vuelve a hacer, evitando bucles.
Por ejemplo, colocamos las funciones en el archivo biblioteca.php:
<?php
function suma(int $a, int $b) : int {
return $a + $b;
}
function resta(int $a, int $b) : int {
return $a - $b;
}
?>
Y posteriormente en otro archivo:
<?php
include_once("biblioteca.php");
echo suma(10,20);
echo resta(40,20);
?>
Plantillas mediante include
Mediante el uso de la instrucción include también podemos separar fragmentos de código PHP/HTML que queramos reutilizar en nuestros sitios web y crear un sistema muy sencillo de plantillas. Por ejemplo, vamos a separar una página en tres partes, primero la parte superior en encabezado.php:
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title><?= $titulo ?></title>
</head>
<body>
La parte de abajo, por ejemplo, solo va a contener HTML y la colocamos en pie.html:
<footer>Aitor Medrano</footer>
</body>
</html>
Y luego nos centramos únicamente en el contenido que cambia en pagina.php:
<?php
$titulo = "Página con includes";
include("encabezado.php");
?>
<h1><?= $titulo ?></h1>
<?php
include("pie.html");
?>