Diferencia entre revisiones de «Usuario:ManuelRomero/ProgramacionWeb/funciones»

• Una posible solución

    <?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";
       }
       //Programa principal
       $a = 100;
       $b = 200;
       echo "En el main antes de invocar la función visualizando variables<hr />";
       echo "Valor de variables \$a = $a \$b = $b <br />";
       a($a, $b);
       echo "En el main después de invocar la función visualizando variables<hr />";
       echo "Valor de variables \$a = $a \$b = $b <br />";
?>

Parámetros formales: Valores y referencias

• Como hemos visto, los parámetros formales reciben valores pasados en la invocación de la función.
• Si queremos que la función pueda modificar el valor de los parámetros, debemos pasarlos **por referencia**.
• Esto permite que se pase la dirección de memoria donde se guarda el valor, en lugar del valor en sí.
• En PHP no podemos visualizar ni operar con la dirección de memoria, ya que no existe la aritmética de punteros.

Parámetros formales

Valores y referencias

Para pasar el parámetro por referencia, simplemente coloca el símbolo & antes del nombre de la variable en la declaración de los parámetros:

function nombre_funcion(&$paramRef1, &$paramRef2, $paramVal1){
   ...
}

Invocando funciones

• Una vez creada una función, se puede invocar como si fuera una instrucción.
• No sin razón, en ciertos contextos se refiere a funciones como "instrucciones virtuales".
• En PHP, puedes invocar una función antes de declararla, siempre que esté en el mismo archivo.

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

• Analicemos este caso

1. La condición base es cuando num es igual a 1, devolviendo 1 y deteniendo la recursión.
2. 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;

• O con parámetros

$variable = fn($parametro) => expresion_con_parametro;

• Ejemplo:

$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';

1. La función contarTareas debe:
   1. Calcular las estadísticas a partir de los estados proporcionados.
   2. Modificar directamente las variables total, completadas y pendientes usando parámetros por referencia.
   3. Ejemplo de firma de la función:

 
 function contarTareas($t1, $t2, $t3, &$total, &$completadas, &$pendientes)

1. Mostrar las estadísticas en una lista dentro de la página web:
   1. 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:

<?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.