Funciones en PHP

• Inicio
• PHP
• Funciones

Al combinar correctamente funciones y bucles podremos crear código mas compacto, legible y modular.

La modularidad en el software consiste en separar nuestro programa en multiples partes mas pequeñas, cada una independiente del resto y algunas piezas siendo intercambiables por otras y cuando estos módulos están bien construidos pueden ser reutilizados para re-componer aún mas software.

Creando tus propias funciones puedes definir instrucciones que se podrán ejecutar solo cuando tu lo requieras, puedes definir desde funciones básicas que encapsulen solo un par de instrucciones básicas hasta funciones con grandes cantidades de código que invocarán incluso a muchas otras funciones con sus respectivas instrucciones internas.

Creando una función básica

Veamos como empezar a crear y usar nuestras propias funciones, Pongamos de ejemplo la operación de sumar los impuestos a un valor monetario dado.

Para crear una función que calcule impuestos usaremos la palabra reservada "function" para indicarle a php que estamos por definir una función.

A la función tenemos que escribirle un nombre que hayamos inventado (debe seguir las mismas reglas de nombres que las variables y las constantes).

A continuación del nombre pondremos unos paréntesis y luego entre llaves escribiremos las instrucciones propias del algoritmo.

Debemos de tener mucho cuidado al nombrar nuestras funciones ya que si llegaran a colisionar con el nombre de alguna función existente (ya sea alguna función definida por nosotros o definida por módulos que empleemos o por una función propia de PHP) el código simplemente fallara en cuanto PHP detecte que se intenta duplicar el nombre de una función.

El código para la función quedara de la siguiente forma:

function taxPrice()
{
    $value = 238; // Valor inicial
    $taxedValue = $value * (1 + 0.16); // Aplicamos el impuesto 

    echo "Valor sin impuesto: \${$value}<br>";
    echo "Valor con impuesto (16%): \${$taxedValue}<br>";
}

Una vez definida ya podemos invocar a nuestra función las veces que sea necesario, y para ello solo debemos escribir el nombre de la función seguida de paréntesis y terminando con punto y coma como cualquier otra instrucción, invoquemosla por ejemplo dos veces solo para ver su comportamiento:

taxPrice();
taxPrice();

Al llamar a la función dos veces, ejecutaremos las instrucciones que esta encapsula dos veces, si ejecutamos la función aún más veces será el mismo comportamiento.

No tiene mucho sentido hacer esta operación con el mismo valor una y otra vez, el poder de las funciones reside en poder ser reutilizadas y para hacer que esta instrucción sea reutilizable necesitamos poder inyectarle un valor de entrada que sea diferente en cada ocasión.

Creando funciones con parámetros y argumentos

Las funciones pueden aceptar multiples valores de entrada para poder trabajar y como resultado estas pueden retornar un valor de salida.

Los argumentos de una función son los valores que esta puede recibir, para nuestro ejemplo solo se necesita un único valor, cambiaremos la función par aceptar como argumento el valor de la variable $value (que previamente definimos con el valor 238).

Para definir el argumento de una función debemos usar la misma sintaxis que para una variable y asignar un nombre de variable que contendrá el valor y lo pasaremos a la función usando los paréntesis de esta, la función quedara de la siguiente manera:

function taxPrice($value)
{
    $taxedValue = $value * (1 + 0.16); // Aplicamos el impuesto 

    echo "Valor sin impuesto: \${$value}<br>";
    echo "Valor con impuesto (16%): \${$taxedValue}<br>";
}

Ahora podemos llevar nuestra función pasándole diferentes valores y ahora si estaremos reutilizando nuestro código, par esto al invocar la función debemos pasar el valor necesario entre los paréntesis de la función tal que así:

taxPrice(100);
taxPrice(458);
taxPrice(299);

Los términos argumento y parámetro se suelen usar indistintamente aunque técnicamente son dos cosas diferentes aunque relacionadas, el argumento hace referencia al valor que se le pasa a la función y con el que esta opera, mientras que el termino parámetro hace referencia a las variables que contienen esos valores.

Funciones propias de PHP

PHP cuenta con sus propias funciones internas para ayudarnos a resolver todo tipo de problemas, en este sitio web veremos muchas de ellas, pero aún así te recomiendo buscar y aprender a usar las que sean de tu interés.

Por nombrar algunos de los apartados de funciones que tiene PHP:

• Gestión de archivos
• Procesamiento de texto
• Persistencia de datos
• Conexión con bases de datos
• Envío de correo electrónico
• Envío de peticiones http a otros servidores
• Implementación de seguridad mediante criptografía
• Operaciones con fechas
• Generación y procesado de imágenes
• Operaciones matemáticas
• Codificación y decodificación de datos en multiples formatos

Si en el ejemplo anterior quisiéramos cambiar los textos o mostrar mas información o si se desea cambiar la operación tendremos problemas, ya que al cambiar la función se cambiara el resultado en todos los lugares del software donde esta se este invocando.

Para ganar mayor flexibilidad siempre es recomendable separar nuestro código en trozos lo mas pequeños posibles, y evitar repetir código siempre que sea posible.

Funciones que retornan valores

Como ya mencionamos, ademas de recibir argumentos de entrada para operar, las funciones pueden retornar valores para luego usar estos valores en otras partes del código o incluso en otras funciones.

Para poder retornar valores desde una función solo es necesario usar la palabra reservada "return" dentro de ella y al finalizar todas las instrucciones deseadas, para ejemplificar dividiremos el código de la función anterior en dos, una función para aplicar el calculo de impuestos y otra función para mostrar la salida.

function taxPrice($value)
{
    return $value * (1 + 0.16); // Aplicamos el impuesto 
}

function renderValue($startingValue, $endingValue)
{
    echo "Valor sin impuesto: \${$startingValue}<br>";
    echo "Valor con impuesto (16%): \${$endingValue}<br>";
}

$startingValue = 100;
$endingValue = taxPrice($startingValue); // 116
renderValue($startingValue, $endingValue);

$startingValue = 458;
$endingValue = taxPrice($startingValue); // 531.28
renderValue($startingValue, $endingValue);

$startingValue = 299;
$endingValue = taxPrice($startingValue); // 346.84
renderValue($startingValue, $endingValue);

En este nuevo ejemplo ahora tenemos dos funciones, por un lado esta la que acepta un valor y retorna otro valor diferente y por otro lado tenemos a la función que imprime la información que necesitamos, que en este caso son dos valores, el valor inicial sin impuesto y el valor final con impuestos aplicados.

Y ahora tenemos tres lineas de código por cada valor, la primera línea es para definir el valor inicial ($startingValue), la segunda línea llama a la función que aplica los impuestos y lo guarda en una variable ($endingValue) y la ultima línea para imprimir los valores resultantes.

Como apreciaras ahora parece que tenemos más código del que había originalmente, la diferencia con el código anterior es que ahora nuestro código es mas modular y mantenible, podemos hacer cambios mas fácilmente, y podemos reutilizar nuestras funciones en otros lugares fuera de este código y en otro contexto.

Aunque realmente el código tiene varias líneas de mas que pueden quitarse para simplificar el script, además de que podríamos incluir arreglos y bucles para quitar todo el código duplicado e incluso añadir muchos mas valores que antes para poder apreciar el poder de la reutilización del código, veamos como sería:

function taxPrice($value)
{
    return $value * (1 + 0.16); // Aplicamos el impuesto 
}

function renderValue($startingValue, $endingValue)
{
    echo "<p>
        Valor sin impuesto: \${$startingValue}<br>
        Valor con impuesto (16%): \${$endingValue}<br>
    </p>";
}
$values = [100, 458, 299, 900.4, 50.33, 777, 372.1, 397, 1004.5, 89.9];

foreach($values as $startingValue){
    renderValue($startingValue,taxPrice($startingValue));
}

Espero que con este código haya quedado mas claro como con unas cuantas líneas usando funciones, bucles y arreglos podemos procesar de forma masiva toneladas de datos.