|
|
(15 revisiones intermedias por el mismo usuario no mostrado) |
Línea 1: |
Línea 1: |
| <div id=parrafo> | | <div id=parrafo> |
− | <div class=slide>
| |
− | ==Funciones==
| |
− | <br />
| |
− | {{MRM_Objetivo|
| |
− | ;Las funciones es un elemento fundamental
| |
− | *Permite crear código modular
| |
− | *Una forma de estructurar nuestro programa
| |
− | }}
| |
− | </div>
| |
| | | |
− | <div class=slide>
| + | {{ManuelRomero/PHP/funciones}} |
− | ===Declaración de funciones===
| + | {{ManuelRomero/PHP/funcionesRecursivas}} |
− | <source lang=php>
| + | {{ManuelRomero/PHP/funcionesAnonimas}} |
− | // Declarar una función
| + | {{ManuelRomero/PHP/funcionesFlecha}} |
− | function nombre_de_funcion([tipo_de_parametro] $parametro_formal[=valor_por_defecto], ...)[: tipo_retorno]
| + | {{ManuelRomero/PHP/funciones/practica}} |
− | { | + | |
− | ...
| + | |
− | [return ...];
| + | |
− | }
| + | |
− | | + | |
− | // Llamar
| + | |
− | nombre_de_funcion($parametro_real);
| + | |
− | </source>
| + | |
− | | + | |
− | </div>
| + | |
− | <div class=slide>
| + | |
− | *Es importante diferenciar entre declarar una función e invocar a una función
| + | |
− | *Algo obvio, pero importante
| + | |
− | *En la declaración tenemos tres partes
| + | |
− | ;nombre o identificación de la función
| + | |
− | ;parámetros_formales
| + | |
− | *Se especifican entre paréntesisi(Estos han de existir, aunque no haya parámetros)
| + | |
− | *Se puede especificar el tipo de cada parámetro (a partir de versión 7.2)
| + | |
− | *Se puede asignar un valor por defecto (En este caso podría no aportarse valor para este parámetro en la invocación)
| + | |
− | ;Tipo de retorno
| + | |
− | Es opcional
| + | |
− | #Cuerpo de la función, dentro de él puede estar la instrucción return, en cuyo momento termina la ejecución de la función y se vuelve a la siguiente instrucción del programa, siguiente a la invocación de la función.
| + | |
− | #El return puede (debe) aportar el valor que queremos que la función retorno
| + | |
− | </div>
| + | |
− | | + | |
− | | + | |
− | <div class=slide>
| + | |
− | ;Identificador de función
| + | |
− | * El nombre de función es un identificador que empieza por una letra o guión bajo, seguido 0 o muchas letras, números o guiones bajos
| + | |
− | {{Tip|Expresión regular para el identificador de funciones | + | |
− | '''''[a-zA-Z_f_][a-zA-Z0-9_]*'''''
| + | |
− | }}
| + | |
− | </div>
| + | |
− | <div class=slide>
| + | |
− | ;Parámetros formales
| + | |
− | *Son nombres de variables que usaré al escribir el código o cuerpo de la función
| + | |
− | *El nombre ha de ser significativo y se convertirán en variables locales a la función
| + | |
− | *Una vez que se termina la función estas variables desaparecerán de memoria
| + | |
− | {{MRM_Puntos clave|Title=parámetros formales|
| + | |
− | Los parámetros formales son variables locales a la función}}
| + | |
− | </div>
| + | |
− | | + | |
− | ===Proceso de creación / invocación de una función===
| + | |
− | ;Lo primero es declarar una función
| + | |
− | *Esto implica dejar una zona de memoria identificada con el nombre de la función
| + | |
− | *En contenido de esas posiciones de memoria serán las acciones de la función
| + | |
− | *Estas acciones estarán establecidas no con valores reales, sino con los parámetros de la declaración
| + | |
− | *Estos parámetros se conocen como parámetros formales
| + | |
− | [[Archivo:declaracion_funcion.png]]
| + | |
− | ;Invocación de función
| + | |
− | *Es un tipo de instrucción, invocar a una acción o función.
| + | |
− | [[Archivo:invocacion_funcion_1.png]]
| + | |
− | *lo primero que ocurrirá es que voy a esa zona de memoria
| + | |
− | [[Archivo:invocacion_funcion_2.png]]
| + | |
− | *Lo siguiente es dar los valores reales (de la invocación) a los parámetros de la función (de la declaracion.
| + | |
− | [[Archivo:invocacion_funcion_3.png]]
| + | |
− | *Una vez que la función termina de ejecutarse, se retornará a la instrucción siguiente de la invocación
| + | |
− | *Si la función devuelve algún valor, se recogerá y asignará a la variable de la instrucción de asignación desde la cual se invocó
| + | |
− | | + | |
− | | + | |
− | | + | |
− | | + | |
− | <div class=slide>
| + | |
− | {{MRM_Actividad|Title=Ejercicio usando funciones|
| + | |
− | '''''Haz un programa donde en el programa principal se creen dos variables $a y $b'''''
| + | |
− | *Crea una función que reciba como parámetros locales '''''$a''''' y '''''$b'''''
| + | |
− | *La función visualizará el valor de las variables, las modificará y las volverá a visualizar
| + | |
− | *El programa principal
| + | |
− | #asignará valor a las variables
| + | |
− | #las visualizará
| + | |
− | #invocará a la función
| + | |
− | #volverá a visualizar las variables
| + | |
− | }} | + | |
− | </div>
| + | |
− | <div class=slide>
| + | |
− | *Una posible solución
| + | |
− | <source lang=php> <?php
| + | |
− | function a($a, $b){
| + | |
− | echo "Dentro de la función visualizando valores <hr />";
| + | |
− | echo "Valor de los parámetros \$a = $a \$b = $b <br />";
| + | |
− | $a+=5;
| + | |
− | $b+=5;
| + | |
− | echo "Valor de los parámetros \$a = $a \$b = $b <br />";
| + | |
− | echo "Salgo de la función";
| + | |
− | }
| + | |
− | //Ahora considero programa principal
| + | |
− | $a=100;
| + | |
− | $b=200;
| + | |
− | echo "En el main antes de invocar a la función visualizando variables<hr />";
| + | |
− | echo "Valor de variables \$a = $a \$b = $b <br />";
| + | |
− | a($a,$b);
| + | |
− | echo "En el mail después de invocar a la función visualizando variables<hr />";
| + | |
− | echo "Valor de variables \$a = $a \$b = $b <br />";
| + | |
− | ?>
| + | |
− | </source>
| + | |
− | </div>
| + | |
− | | + | |
− | <div class=slide>
| + | |
− | | + | |
− | ===Parámetros formales: Valores y referencias===
| + | |
− | *Cómo hemos visto, los parámetros formales son valores pasados en la invocación a la función
| + | |
− | *Si queremos que la función pueda modificar el valor de los valores de los parámetros, en este caso hemos de pasarlos por referencia
| + | |
− | *En este caso lo que ocurre en realidad es que pasamos la dirección de memoria dónde se guarda el valor.
| + | |
− | *La dirección de memoria, no la podremos visualizar ni operar con ella, pues en php no existe la aritmética de punteros o direcciones de memoria
| + | |
− | </div>
| + | |
− | | + | |
− | <div class=slide>
| + | |
− | ;Parámetros formales: Valores y referencias
| + | |
− | Para pasar el parámetro por referencia, simplemente hay que poner el símbolo de dirección de memoria '''''&''''' antes del nombre de la variable en la declaración de parámetros
| + | |
− | <source lang=php>
| + | |
− | function nombre_funcion(&$paramRef1, &$paramRef2, $paramVal1){
| + | |
− | ...
| + | |
− | }
| + | |
− | </source>
| + | |
− | </div>
| + | |
− | | + | |
− | | + | |
− | <div class=slide>
| + | |
− | {{MRM_Actividad|Title=Ejercicio usando funciones parámetros|
| + | |
− | '''''Haz un programa donde en el programa principal se creen dos variables $a y $b y $c'''''
| + | |
− | *Crea una función que reciba como parámetros locales '''''&$num1''''','''''&$num2''''' y '''''$num3'''''
| + | |
− | *La función visualizará el valor de las variables, las modificará y las volverá a visualizar
| + | |
− | *El programa principal
| + | |
− | #asignará valor a las variables
| + | |
− | #las visualizará
| + | |
− | #invocará a la función
| + | |
− | #volverá a visualizar las variables
| + | |
− | }} | + | |
− | </div>
| + | |
− | <source lang=php>
| + | |
− | | + | |
− | <?php
| + | |
− | function a(&$num1, &$num2, $num3){
| + | |
− | echo "Dentro de la función visibilizando valores <hr />";
| + | |
− | echo "Valor de los parámetros \$num1 = $num1 \$num2 = $num2 \$num3 = $num3<br />";
| + | |
− | $num1+=5;
| + | |
− | $num2+=5;
| + | |
− | $num3+=5;
| + | |
− |
| + | |
− | echo "Valor de los parámetros \$num1 = $num1 \$num2 = $num2 \$num3 = $num3<br />";
| + | |
− | echo "Salgo de la función";
| + | |
− | }
| + | |
− | //Ahora considero programa principal
| + | |
− | $a=100;
| + | |
− | $b=200;
| + | |
− | $c=300;
| + | |
− | echo "En el main antes de invocar a la función visualizando variables<hr />";
| + | |
− | echo "Valor de variables \$a = $a \$b = $b \$c = $c <br />";
| + | |
− | a($a,$b,$c);
| + | |
− | echo "En el mail después de invocar a la función visualizando variables<hr />";
| + | |
− | echo "Valor de variables \$a = $a \$b = $b \$c = $c <br />";
| + | |
− | ?>
| + | |
− | </source>
| + | |
− | <div class=slide>
| + | |
− | ;Invocando funciones
| + | |
− | *Una vez creada una función la podemos invocar como si fuera una instrucción del lenguaje
| + | |
− | *No sin razón en determinados ambientes se conoce a las funciones y procedimientos como instrucciones virtuales ...
| + | |
− | *En php puedo invocar a una función antes de declararla, siempre que la declare en el mismo fichero
| + | |
− | </div>
| + | |
− | | + | |
− | <div class=slide>
| + | |
− | | + | |
− | | + | |
− | {{MRM_Ejemplo|Title = ejemplo invocación a funciones| | + | |
− | {{Tip|Este código funcionará correctamente}}
| + | |
− | <source lang=php>
| + | |
− | <?php
| + | |
− | a(5,6);
| + | |
− | /*Mas instrucciones*/
| + | |
− | function a ($a, $b){
| + | |
− | echo "valor de $a";
| + | |
− | echo "valor de $b";
| + | |
− | }
| + | |
− | </source>
| + | |
− | }} | + | |
− | </div>
| + | |
− | | + | |
− | <div class=slide>
| + | |
− | | + | |
− | {{MRM_Ejemplo|Title = ejemplo invocación a funciones| | + | |
− | {{Tip|Este código no funcionará }}
| + | |
− | <source lang=php>
| + | |
− | <?php
| + | |
− | a(5,6);
| + | |
− | /*Mas instrucciones*/
| + | |
− | include ("funciones.php");
| + | |
− | ?>
| + | |
− | </source>
| + | |
− | *Contenido del ficheor funciones.php
| + | |
− | <source lang=php>
| + | |
− | <?php
| + | |
− | function a ($a, $b){
| + | |
− | echo "valor de $a";
| + | |
− | echo "valor de $b";
| + | |
− | }
| + | |
− | ?>
| + | |
− | </source>
| + | |
− | }} | + | |
− | </div>
| + | |
− | | + | |
− | | + | |
− | | + | |
− | <div class="slide">
| + | |
− | ===Variables dentro de una función===
| + | |
− | *Dentro de una función las variables que declaremos son locales a esa función.
| + | |
− | *No podré acceder a su valor fuera de la función
| + | |
− | *Esto también implica que dentro de una función no puedo acceder al valor de una variable definida fuera de la función
| + | |
− | *Observa el siguiente ejemplo
| + | |
− | <source lang=php>
| + | |
− | <?php
| + | |
− | | + | |
− | | + | |
− | function modifica_valor(){
| + | |
− | echo "Valor de <b>var1</b> dentro de función -$var1- <br /> ";
| + | |
− | $var1++;
| + | |
− | echo "Valor de <b>var1</b> dentro de función moficada -$var1- <br /> ";
| + | |
− | }
| + | |
− | | + | |
− | $var1 = 20;
| + | |
− | | + | |
− | echo "Valor de <b>var1</b> en programa principal antes de invocar función: -$var1- <br />";
| + | |
− | modifica_valor();
| + | |
− | echo "Valor de <b>var1</b> en progrma principal después de invocar la función: -$var1- <br />";
| + | |
− | ?>
| + | |
− | </source>
| + | |
− | *Vemos que genera la siguiente salida
| + | |
− | <source lang=bash>
| + | |
− | Valor de var1 en programa principal antes de invocar función: -20-
| + | |
− | Valor de var1 dentro de función --
| + | |
− | Valor de var1 dentro de función moficada -1-
| + | |
− | Valor de var1 en progrma principal después de invocar la función: -20-
| + | |
− | </source>
| + | |
− | *Sin embargo si quieremos acceder al valor de '''''$var ''''' dentro de la función, sí que podemos
| + | |
− | *Hemos de usar la palabra reservada '''''$global'''''
| + | |
− | <source lang=php>
| + | |
− | <?php
| + | |
− | | + | |
− | function modifica_valor(){
| + | |
− | global $var1; //Indicamos que esta variables se puede globalizar
| + | |
− | echo "Valor de <b>var1</b> dentro de función -$var1- <br /> ";
| + | |
− | $var1++;
| + | |
− | echo "Valor de <b>var1</b> dentro de función moficada -$var1- <br /> ";
| + | |
− | }
| + | |
− | | + | |
− | $var1 = 20;
| + | |
− | | + | |
− | echo "Valor de <b>var1</b> en programa principal antes de invocar función: -$var1- <br />";
| + | |
− | modifica_valor();
| + | |
− | echo "Valor de <b>var1</b> en progrma principal después de invocar la función: -$var1- <br />";
| + | |
− | ?>
| + | |
− | </source>
| + | |
− | *Ahora podemos observar cómo sí que se accede al valor dentro de la función
| + | |
− | <source lang=bash>
| + | |
− | Valor de var1 en programa principal antes de invocar función: -20-
| + | |
− | Valor de var1 dentro de función -20-
| + | |
− | Valor de var1 dentro de función moficada -21-
| + | |
− | Valor de var1 en progrma principal después de invocar la función: -21-
| + | |
− | </source>
| + | |
− | ===Funciones anónimas===
| + | |
− | <br />
| + | |
− | {{MRM_Definicion|Title=Qué son|
| + | |
− | ;Son funciones que no tienen nombre
| + | |
− | ;Se conocen como <span class=r>(funciones de clousura funciones cierre)</sapn>, y de hecho implementa la clase (Clousura)[https://www.php.net/manual/es/class.closure.php]
| + | |
− | | + | |
− | }} | + | |
− | ;Crear una función anónima:
| + | |
− | <source lang=php>
| + | |
− | function (){
| + | |
− | return "Hola desde una función anónima";
| + | |
− | }
| + | |
− | </source>
| + | |
− | <br />
| + | |
− | {{MRM_Pregunta|
| + | |
− | ;Ahora viene la paradoja de para qué puede servir y cómo la puedo invocar.
| + | |
− | }}
| + | |
− | ;Para invocar a una función anónima tenemos dos formas:
| + | |
− | :<span id=resaltado>A través de las variables de funciones</span>
| + | |
− | :<span id=resaltado>Como argumento en una función</span>, o sea que el parámetro de una función sea otra función
| + | |
− | | + | |
− | *Uso cuando necesito un parámetro en una función
| + | |
− | *Uso como valor de una variable
| + | |
− | *Uso de variables externas en la función con la palabra '''''use''''' (puede ser por valor o por referencia)
| + | |
− | | + | |
− | ===Funciones flecha===
| + | |
− | *Las funciones flecha es una forma más corta de escribir funciones anónimas simples
| + | |
− | Aparece en php en la versión 7.4
| + | |
− | *Limitaciones de funciones flecha.
| + | |
− | #
| + | |
| </div> | | </div> |
Variables dentro de una función
- Dentro de una función, las variables que declaremos son **locales** a esa función.
- No se puede acceder a su valor fuera de la función.
- Esto también implica que dentro de una función no se puede acceder al valor de una variable definida fuera de la función.
- Observa el siguiente ejemplo:
<?php
function modifica_valor(){
echo "Valor de <b>var1</b> dentro de la función: -$var1- <br />";
$var1++;
echo "Valor de <b>var1</b> dentro de la función, modificado: -$var1- <br />";
}
$var1 = 20;
echo "Valor de <b>var1</b> en el programa principal antes de invocar la función: -$var1- <br />";
modifica_valor();
echo "Valor de <b>var1</b> en el programa principal después de invocar la función: -$var1- <br />";
?>
- Genera la siguiente salida:
Valor de var1 en el programa principal antes de invocar la función: -20-
Valor de var1 dentro de la función: --
Valor de var1 dentro de la función, modificado: -1-
Valor de var1 en el programa principal después de invocar la función: -20-
- Si queremos acceder al valor de $var1 dentro de la función, podemos usar la palabra reservada global:
<?php
function modifica_valor(){
global $var1; // Indicamos que esta variable se puede usar globalmente.
echo "Valor de <b>var1</b> dentro de la función: -$var1- <br />";
$var1++;
echo "Valor de <b>var1</b> dentro de la función, modificado: -$var1- <br />";
}
$var1 = 20;
echo "Valor de <b>var1</b> en el programa principal antes de invocar la función: -$var1- <br />";
modifica_valor();
echo "Valor de <b>var1</b> en el programa principal después de invocar la función: -$var1- <br />";
?>
- Ahora, observamos que el valor dentro de la función se puede acceder y modificar.
Valor de var1 en el programa principal antes de invocar la función: -20-
Valor de var1 dentro de la función: -20-
Valor de var1 dentro de la función, modificado: -21-
Valor de var1 en el programa principal después de invocar la función: -21-
Funciones recursivas
- Al igual que en otros lenguajes de programación, en PHP el uso de funciones recursivas es una opción muy interesante cuando necesitamos obtener valores que dependen de cálculos repetitivos sobre sí mismos
- Claros ejemplos son casos de factoriales, secuencias de Fibonacci, o procesamiento de estructuras de datos jerárquicas (por ejemplo, árboles o directorios anidados).
¿Qué es una Función Recursiva?
Una función recursiva es aquella que se llama a sí misma para resolver un problema que puede dividirse en subproblemas más pequeños y de la misma naturaleza.
|
- La idea principal es que la función continúe llamándose a sí misma, resolviendo cada vez una parte más pequeña del problema, hasta que alcanza una condición base que detiene las llamadas recursivas.
- Ejemplo de Factorial con Recursividad
El cálculo del factorial de un número n es un ejemplo clásico de recursividad. El factorial de n (representado como n!) se calcula multiplicando n por el factorial de n - 1 hasta llegar a 1. En términos matemáticos:
𝑛!=𝑛 × (𝑛−1) × (𝑛−2)×...× 1
Podemos implementar esto en PHP usando una función recursiva:
function factorial($num) {
return $num <= 1 ? 1 : $num * factorial($num - 1);
}
echo factorial(5); // Salida: 120
- La condición base es cuando num es igual a 1, devolviendo 1 y deteniendo la recursión.
- Si num es mayor que 1, la función llama a factorial de nuevo con el valor num - 1, multiplicándolo por num.
Ventajas y Desventajas de la Recursión
- Ventajas
- Código más limpio y legible: Las soluciones recursivas suelen ser más compactas y fáciles de entender que sus equivalentes iterativas.
- Ideal para problemas jerárquicos: La recursión es muy útil para trabajar con datos que tienen una estructura de árbol o jerárquica, como explorar directorios o manejar datos de tipo árbol (DOM, menús anidados, etc.).
- Desventajas
- Consumo de memoria: Cada llamada recursiva agrega un nuevo nivel al stack de llamadas de PHP, lo cual puede llevar a un error de desbordamiento si la recursión es profunda o si no se define correctamente la condición base.
- Complejidad de depuración: Las funciones recursivas pueden ser más difíciles de depurar debido a la cantidad de llamadas anidadas que se realizan.
Consideraciones Importantes al Usar Recursividad en PHP
- Podríamos generalizar para cualquier lenguaje de programación
- Establecer una condición base clara
-
- Sin una condición base, la función entrará en un ciclo infinito de llamadas hasta que se agote la memoria.
- Evaluar el caso iterativo
-
- A veces, una solución iterativa (usando bucles) puede ser más eficiente y evitar problemas de memoria.
- Controlar la profundidad
-
- PHP establece un límite en la profundidad de recursión por defecto (generalmente 100 o 1000 niveles), aunque este límite puede configurarse. Sin embargo, es importante considerar la eficiencia y el consumo de memoria.
Funciones Anónimas
¿Qué son?
- Son funciones que no tienen nombre.
- También se conocen como funciones de clausura o funciones cierre. En PHP, las funciones anónimas implementan la clase `Closure` ([documentación de Closure](https://www.php.net/manual/es/class.closure.php)).
- Para crear una función anónima en PHP, se usa la siguiente estructura
-
function () {
return "Hola desde una función anónima";
};
|
Pregunta
- Puede parecer paradójico, pero ¿para qué sirve una función anónima y cómo podemos invocarla?
|
- En PHP, existen dos formas principales de invocar una función anónima
-
- 1. A través de variables de función.
- 2. Como argumento en otra función. Es decir, pasamos la función anónima como parámetro a otra función.
Variables de Función
- En PHP, podemos asignar una función anónima a una variable y luego invocar la función a través de esa variable. Esta técnica permite trabajar con funciones de forma similar a las variables, lo que puede ser cómodo en ciertos casos.
- Usar variables de función requiere tener presente que no podemos invocar la función antes de la asignación, ya que hasta ese punto, la función no existe en la variable.
- Para asignar una función anónima a una variable, simplemente declaramos la variable y le asignamos la función. Para invocarla, solo tenemos que llamar a la variable como si fuera una función, usando paréntesis `()`.
<?php
$mi_funcion = function () {
return "hola caracola";
};
echo $mi_funcion(); // Imprime: hola caracola
?>
- Si intentamos invocar la función antes de asignarla a la variable, obtendremos un error.*
// Error: La función no existe antes de la asignación
echo $mi_funcion();
$mi_funcion = function () {
return "hola caracola";
};
Comparación con Funciones Nombradas
En cambio, si usáramos una función nombrada en lugar de una función anónima, PHP podría procesarla sin importar el orden, debido a su interpretación en dos pasadas:
<?php
echo mi_funcion(); // Esto funcionará debido a la doble pasada de PHP
function mi_funcion() {
return "hola caracola";
}
?>
Pasar Funciones Anónimas como Parámetros en Otras Funciones
- Otra manera de usar funciones anónimas es pasarlas como parámetros en otras funciones. En PHP, hay varias funciones del sistema que aceptan una función de clausura como argumento. Al usar funciones anónimas en estos casos, podemos crear lógica personalizada que se ejecuta en el contexto de la función de nivel superior.
Algunos ejemplos de funciones del sistema que aceptan funciones de clausura como argumentos son:
- [`spl_autoload_register`](https://www.php.net/manual/es/function.spl-autoload-register.php)
- [`array_walk`](https://www.php.net/manual/es/function.array-walk.php)
- [`array_map`](https://www.php.net/manual/es/function.array-map.php)
- [`array_reduce`](https://www.php.net/manual/es/function.array-reduce.php)
Uso de `call_user_func` para Invocar Funciones Anónimas
- Otra forma de invocar una función anónima es mediante la función `call_user_func`. Esta función acepta una función anónima como primer argumento y, opcionalmente, otros argumentos que serán pasados a la función anónima.
<?php
call_user_func(function ($nombre) {
echo "Hola $nombre";
}, "Manuel");
// Este código imprimirá: Hola Manuel
?>
Mejorar la Legibilidad Usando Variables
- En lugar de escribir la función anónima directamente en call_user_func, podemos asignarla a una variable para mejorar la legibilidad del código.
<?php
$saludar = function ($nombre) {
echo "Hola $nombre";
};
call_user_func($saludar, "Manuel");
// Este código imprimirá: Hola Manuel
?>
Acceso a Variables del Entorno: `use` vs. `global`
- Cuando trabajamos con funciones anónimas en PHP, hay una característica importante sobre cómo acceder a las variables del entorno.
- En PHP, las funciones anónimas no tienen acceso directo a las variables del entorno en el que se crean.
- Si necesitamos usar esas variables dentro de la función anónima, tenemos dos opciones: usar `use` o declarar las variables como `global`.
Uso de `use` para Capturar Variables del Entorno
- El operador `use` permite capturar variables del entorno en el momento en que se define la función anónima.
- Esto es útil cuando queremos hacer referencia a valores específicos del entorno externo sin modificarlos (o incluso, modificarlos en algunos casos específicos).
- `use` permite pasar variables del entorno a la función anónima por valor, aunque también es posible pasarlas por referencia si se indica con `&`.
- Cuando usamos `use`, la variable queda "capturada" en el estado en el que estaba al momento de declarar la función anónima.
- Ejemplo con `use`
-
$mensaje = "Hola";
$mi_funcion = function() use ($mensaje) {
echo $mensaje;
};
$mi_funcion(); // Imprime: Hola
- En este ejemplo, '$mensaje se pasa a la función anónima con use y puede ser utilizada dentro de la función.
- Sin embargo, cualquier cambio en $mensaje dentro de la función no afectará a la variable $mensaje fuera de la función a menos que la pasemos por referencia.
- Para modificar la variable del entorno, podemos hacerlo pasando la variable por referencia con use (&$variable):
$contador = 1;
$incrementar = function() use (&$contador) {
$contador++;
};
$incrementar();
echo $contador; // Imprime: 2
- En este ejemplo, $contador se pasa por referencia a la función anónima, por lo que cualquier modificación dentro de la función afectará también al valor de $contador fuera de ella.
Funciones Flecha
Las funciones flecha (o arrow functions) se introdujeron en PHP 7.4 como una forma compacta y conveniente de escribir funciones anónimas.
- Son especialmente útiles cuando necesitamos una función rápida, generalmente en una línea, y son comunes en funciones de callback o como argumentos en otras funciones.
- Sin embargo, tienen ciertas limitaciones en comparación con las funciones anónimas tradicionales.
Sintaxis de las Funciones Flecha
La sintaxis de una función flecha es más breve que la de una función anónima tradicional. La estructura básica es la siguiente:
$variable = fn() => expresion;
$variable = fn($parametro) => expresion_con_parametro;
$mi_funcion = fn($parametro) => $parametro * 2;
- La palabra clave fn indica el inicio de la función flecha.
- Los parámetros se colocan entre paréntesis.
- La flecha `=>` separa los parámetros del cuerpo de la función.
- Solo se permite una expresión en el cuerpo de la función, cuyo valor se retorna automáticamente.
Limitaciones de las Funciones Flecha
- Aunque las funciones flecha ofrecen una sintaxis más concisa, tienen ciertas limitaciones:
- 1. Solo permiten una única expresión: Las funciones flecha solo pueden contener una sola expresión. Esto significa que no pueden tener múltiples líneas de código ni declaraciones complejas.
- 2. No pueden usarse de forma recursiva: Al no permitir referencia a sí mismas, no es posible implementar recursión con funciones flecha. Si necesitas recursión, deberás usar una función anónima tradicional o una función nombrada.
- 3. Limitaciones en el uso de `use`: En funciones anónimas, es común usar `use` para capturar variables del entorno en el momento de la definición de la función.
- Sin embargo, en las funciones flecha, use no es necesario, ya que heredan automáticamente las variables del ámbito externo.
- A diferencia de las funciones anónimas, no es posible personalizar qué variables se capturan ni controlar si se pasan por referencia o por valor.
- Las funciones flecha siempre heredan las variables por valor.
- Esto significa que, si necesitas modificar una variable del entorno dentro de la función flecha, no puedes hacerlo directamente. Para lograr este efecto, deberías usar una función anónima y pasar la variable por referencia con `use (&$variable)`.
4. Sin acceso a `$this` fuera de objetos: Aunque las funciones flecha heredan el valor de `$this` cuando se utilizan dentro de un objeto, no pueden acceder a `$this` si no están dentro del contexto de un objeto.
Ejemplos de Uso de Funciones Flecha
$factor = 3;
// Función flecha que hereda $factor del entorno
$multiplicar = fn($num) => $num * $factor;
echo $multiplicar(5); // Salida: 15
- En este ejemplo, la función flecha accede a la variable `$factor` desde el ámbito en el que fue definida. No necesitamos `use`, ya que la variable es heredada automáticamente.
- Si intentáramos modificar `$factor` dentro de la función, no afectaría el valor de `$factor` en el ámbito externo:
$factor = 3;
$incrementar = fn($num) => $factor += $num;
echo $incrementar(2); // Salida: 5 (modificado solo dentro de la función)
echo $factor; // Salida: 3 (sin cambios en el entorno externo)
- Para realizar este tipo de modificación en el ámbito externo, se debe usar una función anónima en lugar de una función flecha:
$factor = 3;
$incrementar = function($num) use (&$factor) {
$factor += $num;
};
$incrementar(2);
echo $factor; // Salida: 5 (modificado en el ámbito externo)
Resumen sobre fn()=>expresion
Las funciones flecha en PHP son útiles para simplificar el código en situaciones en las que necesitamos una función rápida y sencilla, especialmente como callback o dentro de funciones de una sola línea.
Sin embargo, debido a sus limitaciones (como la imposibilidad de usar `use` para pasar variables específicas por referencia o de forma selectiva), se debe de evaluar cuándo es más apropiado usar una función anónima en lugar de una función flecha.
|
Estadísticas de Tareas con Funciones
- Descripción del problema
-
- Queremos construir una aplicación básica que nos permita analizar el estado de tres tareas predefinidas.
- Cada tarea puede estar en estado "pendiente" o "completada".
- Utilizaremos una función para calcular estadísticas de estas tareas y mostrar los resultados en una página web.
Objetivos del ejercicio:
- Crear una página web en PHP que muestre tres tareas predefinidas con su estado.
- Implementar una función llamada contarTareas que reciba como parámetros los estados de las tres tareas.
- Usar la función para calcular y devolver:
- El número total de tareas.
- El número de tareas completadas.
- El número de tareas pendientes.
- Mostrar las estadísticas calculadas en la página web de forma clara y ordenada.
Requisitos específicos:
Las tareas deben ser representadas como variables simples, no arrays.
Ejemplo:
$tarea1_estado = 'pendiente';
$tarea2_estado = 'completada';
$tarea3_estado = 'pendiente';
- La función contarTareas debe:
- Calcular las estadísticas a partir de los estados proporcionados.
- Modificar directamente las variables total, completadas y pendientes usando parámetros por referencia.
- Ejemplo de firma de la función:
function contarTareas($t1, $t2, $t3, &$total, &$completadas, &$pendientes)
- Mostrar las estadísticas en una lista dentro de la página web:
- Ejemplo de salida:
* Total de tareas: 3
* Tareas completadas: 1
* Tareas pendientes: 2
Pautas para resolver el ejercicio:
- Crea las variables para almacenar los estados de las tres tareas.
- Escribe la función contarTareas siguiendo la estructura solicitada.
- Llama a la función desde tu código principal, pasando los estados de las tareas y las variables de estadísticas.
- Usa HTML con Bootstrap para estructurar la página:
platilla |
---|
<?php
function contarTareasCompletadas(string $t1, string $t2, string $t3): int
{
}
function crearTareas(&$tarea_1, &$tarea_2, &$tarea_3)
{
}
function asigarEstado(): string
{
}
function asigarEstilo($estado)
{
}
// Variables simples para las tareas
//Declaramos 3 tareas
crearTareas($tarea_1, $tarea_2, $tarea_3);
//Establecemso el estado de las tareas (de cada una)
$tarea_1_estado = asigarEstado();
$tarea_2_estado = asigarEstado();
$tarea_3_estado = asigarEstado();
//Contamos las tareas
$completadas = contarTareasCompletadas($tarea_1_estado, $tarea_2_estado, $tarea_3_estado);
$pendientes = $tareas_total - $completadas;
//Asignamos estilo a las tareas
$tarea_1_estilo = asigarEstilo($tarea_1_estado);
$tarea_2_estilo = asigarEstilo($tarea_2_estado);
$tarea_3_estilo = asigarEstilo($tarea_3_estado);
?>
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Gestor de Tareas - Funciones</title>
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body class="bg-light">
<div class="container py-5">
<h1 class="text-center mb-4">Gestor de Tareas</h1>
<!-- Introducción -->
<div class="mb-4">
<p>En esta página trabajaremos con funciones para calcular estadísticas de tareas.
Actualmente, hay tres tareas predefinidas.</p>
</div>
<!-- Tareas con variables simples -->
<div class="card mb-4">
<div class="card-body">
<h2 class="card-title">Tareas Iniciales</h2>
<ul class="list-group">
<li class="list-group-item "><span
class="fw-bold fs-4">Tarea 1:</span>
<span class="badge ">estado tarea 1</span>
</li>
<li class="list-group-item "><span
class="fw-bold fs-4">Tarea 2:</span>
<span class="badge ">estado tarea 2</span>
</li>
<li class="list-group-item "><span
class="fw-bold fs-4">Tarea 3:</span>
<span class="badge ">estado tarea 3</span>
</li>
</ul>
</div>
</div>
<!-- Estadísticas -->
<div class="card">
<div class="card-body">
<h2 class="card-title">Estadísticas de Tareas</h2>
<ul class="list-group">
<li class="list-group-item">Total de tareas:
<strong> Total de tareas</strong></li>
<li class="list-group-item">Tareas completadas:
<strong>total de tareas completadas</strong></li>
<li class="list-group-item">Tareas pendientes:
<strong>Total tareas pendientes</strong></li>
</ul>
</div>
<!-- Gráfica de estadísticas -->
<!-- podemosintentar meter un gráfico de js -->
</body>
</html>
|
- Una sección que liste las tareas y su estado.
- Una sección separada para mostrar las estadísticas calculadas.
- Prueba diferentes combinaciones de estados para verificar que las estadísticas se calculan correctamente.