Funciones en el lenguaje PHP
En la sección anterior revisamos sintaxis útil en PHP, como try{} catch{}, declare(), die(), goto, require/include. Ahora vamos por las funciones.
Los lenguajes de programación modernos necesitan reusar código útil cuando se requiere ejecutar un solo evento para posibles distintos datos. Un evento que deba ser ejecutado varias veces podría ser, por ejemplo, una operación matemática extensa.
Para Tatroe y MacIntyre (2020, p. 133), una función es un bloque de código que debe ejecutar una tarea por bloque. Además, una función es sinónimo de eficiencia pues es compilada una sola vez por cada archivo que la contenga. En informática, compilar significa traducir el código que podemos entender los humanos a un lenguaje de bits que pueda entender el procesador de la computadora. Las funciones son compiladas una sola vez, mientras que otras sintaxis (como variables o bucles, que no estén dentro de una función) serán compilados cada vez que el código entero se ejecute. Con una función bastará una sola compilación y muchas ejecuciones.
Como ejemplo, imaginemos el trabajo de podar el césped. Cada vez que necesitemos rebajar la maleza, deberemos encender la máquina podadora; eso sería ejecutar el código cada vez que necesitemos esa labor. En cambio, una función sería como tener la podadora siempre encendida, lista para la poda cada vez que lo necesitemos.
Así mismo, las funciones son sintaxis fáciles de ubicar en un extenso código, facilitando correciones en un solo lugar y no desde sintaxis dispersa, como en variables globales o bucles fuera de una función.
Por otro lado, las funciones son celosas con sus valores: ningún valor de variable dentro de una función puede ser accedido desde fuera. Y así mismo, las funciones no pueden obtener valores externos desde dentro de ellas. Abajo, ejemplos de sintaxis incorrecta y su versión correcta:
En .PHP
<?php
// ERROR, no es está usando el operador function(){}
// ERROR, esto es PHP. Cada variable necesita su operador $
// TERRIBLE ERROR: La función DEBE finalizar con punto y coma
$calcular = multiplicar(a, b, c){
$resultado = a * b * c;
echo "El resultado es " . $resultado;
}
//Invoco, o llamo, o activo función
$resultado(2, 3, 4);
// SINTAXIS CORRECTA +++++++++++++++
$calcular = function($a, $b, $c){
$resultado = $a * $b * $c;
echo "El resultado es " . $resultado;
};
// Invocando o llamando a función
$calcular(2, 3, 4);
// El resultado es 24
?>
Las funciones pueden ser creadas y nombradas por nosotros, pero PHP (como todo lenguaje de programación) también cuenta con funciones preelaboradas que facilitan el desarrollo. Ojo abajo en cómo debemos concatenar (unir) el tag HTML de <hr>
En .PHP
<?php
// Nombramos nuestra función
function saluditoo ($nombreAmigo){
echo "Hola " . $nombreAmigo . "<hr>";
};
// Invocamos
saluditoo("Omar");
// Hola Jaime
// Invocamos
saluditoo("Sandra");
// Hola Sandra
// ** Cuidado **
/* Es incorrecto haber concatenado
esto desde la invocación de funcion */
// saluditoo("Sandra") . "<hr>";
?>
Declarando funciones cuyo contenido no sea código PHP
Por otro lado (en el ejemplo de abajo) una función PHP también puede contener sintaxis HTML. Esto es útil para insertar elementos visibles en forma de tags HTML dentro de un código HTML. ATENCIÓN: PHP interpreta los nombres de las funciones tanto en mayúsculas como en minúsculas. En todo caso, es convención nombrar las funciones siempre en minúsculas.
En .PHP
<html>
<!-- Estilo para el tag de la funcion -->
<style>.titulote{font-family: Arial;color: blue;}</style>
// Función PHP
<?php function elementoHTML() {
echo '<h3 class="titulote">Hola soy un tag HTML agregado desde PHP</h3>';
}
// Llamada a la función para que se ejecute
elementoHTML();
?>
</html>
Siendo el resutado:
Hola soy un tag HTML agregado desde PHP
Así mismo (en el ejemplo de abajo), es posible insertar variables como argumentos de función en PHP. Los argumentos de una función son valores que esta recibe desde sus paréntesis; y que luego serán usadas para operar o mostrar datos.
En .PHP
<html>
<?php
// Como argumento ingresa una variable
function column($content) {
// Como contenido del tag va la variable
echo "<h3 class='titulote'> $content </h3>";
}
?>
// EN HTML, dentro del tag invoco la variable...
<tr>
// Dentro de la función...
<?php column("Esto es lo que ingreso como dato"); ?>
</tr>
</html>
Siendo el resultado:
Esto es lo que ingreso como dato
Usando la sentencia return desde una función en PHP
return es una sentencia cuyo obligación es alistar un valor de función para ser retomado por una invocación externa de esa función. En este contexto, alistar significa mantener en memoria lo que se va a devolver para que alguna invocación pueda captarlo (por ejemplo, al alojar la función en una variable).
En .PHP
<?php
// Se nombra función con una variable como argumento
function saludar($nombre) {
// retorna expresión junto con variable
return "Hola, " . $nombre;
}
/* RETURN permite guardar
lo que esa función tiene para mi */
// En una variable alojo función y argumento
// lo que en realidad estoy haciendo es alojar lo que return me permite
$mensaje00 = saludar("Juan");
echo $mensaje00 . "<hr>";
// Juan
/* OJO: aquí estoy sobreescribiendo
el argumento de la variable anterior */
$mensaje00 = saludar("Ana");
echo $mensaje00 . "<hr>";
// Ana
// Pero aquí estoy creando una nueva invocación
$mensajeNuevo = saludar("Sandritaaa");
echo $mensajeNuevo . "
";
// Sandritaaa
?>
El resultado del anterior código es lo siguiente:
Hola, Juan
Hola, Ana
Hola, Sandritaaa
Permitiendo que una variable local sea global, mediante global
Una variable en la barriga de una función solo puede ser accedida de forma local. Pero gracias al operador global podemos indicar que solo esa variable será accedida desde fuera de la función.
En .PHP
<?php
// Se DEBE declarar primero afuera
$detenido = "Ramon";
function carcel() {
// Primero la declaro global
global $detenido;
// Luego inicio variable
$detenido = "Juan";
}
// Llamamos a la función
carcel();
// Invocamos variable que era imposible de acceder
// de no ser por el operador GLOBAL
echo $detenido;
// Juan
/* Ahora, el valor de $detenido
puede ser leido desde fuera de la función. */
?>
En cuando al operador global, Tatroe y MacIntyre (2020, p. 140) indican que "Debes incluir global en una función antes de cualquier uso de la variable o variables globales a las que desea acceder. Debido a que se declaran antes del cuerpo de la función, los parámetros de la función nunca pueden ser variables globales."
Pasar variables por referencia o 'Passing Parameters by Reference'
O lo que yo llamo 'actualizar desde origen', o 'actualizar variable desde la función', o 'pasar variables por referencia para que su valor pueda ser actualizado desde la función'. En fin, iniciemos su explicación.
Usamos un paso de variable (solo de variables, nunca de constantes) por referencia cuando necesitamos que la variable original se actualice directamente desde dentro de la función. O, en otras palabras, cuando la actualización del valor de una función se vea reflejado fuera de la función. Para eso, el nombre identificador de la variable debe estar precedido del signo &, en la forma &$valor.
En .PHP
<?php
// Pasamos '$valorReferencia' como referencia
// OJO con el signo & al lado de la variable en argumento
function actualizar(&$valorReferencia) {
// Modifica la referencia
$valorReferencia = $valorReferencia * 2;
}
// Variable original externa
$variableOriginal = 5;
// Pasamos $numero como argumento de 'actualizar'
actualizar($variableOriginal);
/* $numero fue modificado dentro de la función */
// OJO: Imprimo la variable, NO la función
echo $variableOriginal;
// 10
?>
Otra explicación para pasar una variable por referencia es la de aprovechar el evento de una función para alterar el valor de una variable que no está en sus argumentos.
En .PHP
<?php
// Función con argumento de referencia
// ese argumento conectará con un valor externo
function procesarValor(&$valor) {
$valor = pow($valor, 1 / 3); // Calcula la raíz cúbica
$valor = pow($valor, 3); // Eleva al cubo de nuevo
// Ojo, esto no retorna nada
}
// Un valor cualquiera
$numero = 27;
// Vinculo a referencia
// Conecta la variable externa con el argumento de la función
procesarValor($numero);
// Retorno la variable, NO la función
echo $numero;
// 27
?>
En otras palabras, si la función es una fiesta, el argumento &$invitacion seria una invitación para cualquier variable externa que ingrese a la invocación de fiesta(). Si un invitado (que no forma parte de los argumentos iniciales de la función fiesta) ingresa mediante &$invitacion , lo que haya en la función fiesta alterará al invitado. Un ejemplo de eso en el código de abajo:
En .PHP
<?php
// OJO con el caracter & en argumento
function fiesta(&$invitacion) {
// Alteramos al invitado
// funcion strtoupper() eleva caracteres
$invitacion = strtoupper($invitacion);
echo "Ahora es $invitacion";
}
// Valor nuevo
$invitado = "juan";
// Conecta con &$invitacion
fiesta($invitado);
// Ahora es JUAN
?>
En resumen, pasar por referencia quiere decir que pasamos una variable externa (que no forma parte de los argumentos de una función) vinculando esa variable externa a un argumento de una función cuyo contenido alterará el valor de esa variable externa. Similar a que esa variable externa se comporte como una variable local de función.
Argumentos predeterminados o Default Parameters de función
Un argumento predeterminado en PHP indica que uno de sus argumentos ya cuenta con un valor de antemano. Si al invocar la función no se proporciona un valor de argumento, entonces la función usará el valor predeterminado (o incorporado de antemano) como el valor de uno de sus argumentos.
En .PHP
<?php
// Argumento predeterminado $tengoHambre
// con un valor 'si'
function estado($tengoHambre = 'si') {
// Condicional
if ($tengoHambre === 'si') {
echo "Sí, tengo hambre" . "
";
} else {
echo "No, no tengo hambre" . "
";
}
}
// Invocar sin argumento dará el valor por defecto
estado();
// Sí, tengo hambre
// Invocar con un valor diferente...
// activará la condicional false
estado('no');
// No, no tengo hambre
// Incluso, si no se usa algún otro valor de la condicion
estado('blablabla');
// No, no tengo hambre
?>
Sin embargo, ATENCIÓN: si tenemos parámetros (también llamados argumentos) de función que deberán esperar valores (también llamados Parámetros obligatorios), entonces estos parámetros deben ir primero y luego, los parámetros predeterminados. ¿Por qué, si PHP es una tecnología pilas? la razón de ser ordenados con los argumentos predeterminados es que PHP no validaba con rigidez estricta si lo que ingresamos en cada argumento es un texto o un número. Por lo que tampoco validaba (nuevamente, con rigor) qué valor le corresponde a cada parámetro. Al colocar primero los parámetros que exigen datos PHP simplemente ubicará que esos valores deben ir a esos argumentos.
En .PHP
<?php
// ERROR
// Primero param. determinado, luego param. de función
function ejemplo($edad=25, $nombre) {}
// CORRECTO
// Primero param. de función, luego el determinado
function ejemplo($nombre, $edad=25) {}
?>
La versión 8.0 de PHP permite nombrar los argumentos (named arguments). Con eso valida mejor qué dato llenará tal argumento:
En .PHP
<?php
// Primer argumento pide dato
// Segundo argumento es pre determinado
function saludar($nombre, $edad = 25) {
echo "Soy $nombre con $edad años." . "<hr>";
}
// Se añade 'nombre:' para identificar a qué argumento va ese valor
// Inserto valor en argumento
saludar(nombre: "Carlos");
// Soy Carlos con 25 años.
/* Se añade 'edad:' y 'nombre:'
para identificar a qué argumento va ese valor */
// Inserto valores en argumentos
saludar(edad: 30, nombre: "Ana");
// Soy Ana con 30 años.
?>
Retorno de valores de función
Las funciones PHP solo pueden devolver un único valor con la palabra clave return. Además, se debe tener en cuenta que devolver no es lo mismo que mostrar. En sintaxis de programación, devolver es igual a que un valor esté fijado en memoria, listo para ser captado por una invocación de función. En cambio, mostrar es igual a evidenciar un dato en pantalla, por ejemplo, mediante la palabra clave echo. Es por eso que no siempre se muestra lo que se devuelve. Y casi siempre es mostrado todo lo que se devuelve.
En .PHP
<?php
function devolverEsto() {
return 42;
// TODO Esto ya NO devuelve
return 10;
return "hola";
}
// Aqui se DEVUELVE el dato 42...
devolverEsto();
// ...pero solo aquí se MUESTRA el dato 41
echo devolverEsto();
?>
Verificar la existencia de una función con function_exists()
Útil para comprobar funciones antes de invocarlas o de activarlas.
En .PHP
<?php
// Condicional
// funcion verifica presencia de funcion
if ( function_exists('unaFuncion') ){
// Si existe, activar la funcion...
unaFuncion();
// Si no existe...
} else {
echo "La función 'unaFuncion' no existe.";
// La función 'unaFuncion' no existe.
}
?>
En resumen, las funciones son parcelas de código, útiles para centralizar eventos que requieran ser siempre ejecutados, pero con datos renovados cada tanto. Para Tatroe y MacIntyre (2020, p. 153) es buena práctica no anidar eventos desde funciones: lo mejor, una función por cada operación.
En la siguiente sección abordaremos ...
BIBLIOGRAFÍA
Constructors (2003). Constructors, en sciencedirect.comwww.php.net (2025). ¿Qué es PHP?
Kevin Tatroe and Peter MacIntyre (2020). Programming PHP