Merge pull request mouredev#6540 from eulogioep/main

#21 - java, javascript, php y typescript

Author: Roswell468

Roadmap/21 - CALLBACKS/java/eulogioep.java

@@ -0,0 +1,104 @@
+/*
+ * TEORÍA DE CALLBACKS:
+ * 
+ * Un callback es una función que se pasa como argumento a otra función y se ejecuta
+ * después de que ocurra un evento específico o se complete una tarea. En Java, los
+ * callbacks se implementan típicamente usando interfaces funcionales o lambdas.
+ * 
+ * Los callbacks son útiles para:
+ * 1. Programación asíncrona
+ * 2. Manejo de eventos
+ * 3. Personalización de comportamiento
+ * 
+ * En Java, podemos implementar callbacks de varias formas:
+ * 1. Interfaces funcionales
+ * 2. Expresiones lambda
+ * 3. Referencias a métodos
+ */
+
+ import java.util.Random;
+ import java.util.concurrent.TimeUnit;
+ 
+ public class eulogioep {
+     
+     // Interfaces funcionales para los callbacks
+     @FunctionalInterface
+     interface SimpleCallback {
+         void execute();
+     }
+     
+     @FunctionalInterface
+     interface StringCallback {
+         void execute(String message);
+     }
+     
+     // Ejemplo simple de callback
+     public static void procesarTarea(String tarea, SimpleCallback onComplete) {
+         System.out.println("Iniciando tarea: " + tarea);
+         // Simulamos algún procesamiento
+         try {
+             Thread.sleep(1000);
+         } catch (InterruptedException e) {
+             e.printStackTrace();
+         }
+         
+         // Ejecutamos el callback
+         onComplete.execute();
+     }
+     
+     // Simulador de pedidos de restaurante
+     public static class RestaurantePedidos {
+         private Random random = new Random();
+         
+         public void procesarPedido(
+             String plato,
+             StringCallback onConfirmacion,
+             StringCallback onListo,
+             StringCallback onEntrega
+         ) {
+             // Callback de confirmación
+             onConfirmacion.execute("Pedido confirmado: " + plato);
+             
+             // Simular preparación
+             simularTiempo();
+             
+             // Callback de listo
+             onListo.execute("¡" + plato + " está listo!");
+             
+             // Simular entrega
+             simularTiempo();
+             
+             // Callback de entrega
+             onEntrega.execute(plato + " ha sido entregado. ¡Buen provecho!");
+         }
+         
+         private void simularTiempo() {
+             try {
+                 int tiempoEspera = random.nextInt(10) + 1;
+                 System.out.println("Procesando... (" + tiempoEspera + " segundos)");
+                 TimeUnit.SECONDS.sleep(tiempoEspera);
+             } catch (InterruptedException e) {
+                 e.printStackTrace();
+             }
+         }
+     }
+     
+     public static void main(String[] args) {
+         // Ejemplo simple de callback
+         System.out.println("=== Ejemplo Simple de Callback ===");
+         procesarTarea("Tarea de prueba", () -> 
+             System.out.println("¡Tarea completada!")
+         );
+         
+         System.out.println("\n=== Simulador de Restaurante ===");
+         RestaurantePedidos restaurante = new RestaurantePedidos();
+         
+         // Procesamos un pedido usando el simulador
+         restaurante.procesarPedido(
+             "Paella Valenciana",
+             mensaje -> System.out.println("CONFIRMACIÓN: " + mensaje),
+             mensaje -> System.out.println("LISTO: " + mensaje),
+             mensaje -> System.out.println("ENTREGA: " + mensaje)
+         );
+     }
+ }

Roadmap/21 - CALLBACKS/javascript/eulogioep.js

@@ -0,0 +1,80 @@
+/*
+ * TEORÍA DE CALLBACKS EN JAVASCRIPT:
+ *
+ * Un callback es una función que se pasa como argumento a otra función y se ejecuta
+ * después de que ocurra un evento específico o se complete una tarea. En JavaScript,
+ * los callbacks son muy comunes debido a su naturaleza asíncrona.
+ *
+ * Los callbacks son fundamentales en JavaScript para:
+ * 1. Manejar operaciones asíncronas
+ * 2. Event handling (manejo de eventos)
+ * 3. Funciones de orden superior
+ *
+ * En JavaScript, los callbacks pueden ser:
+ * 1. Funciones anónimas
+ * 2. Funciones flecha
+ * 3. Referencias a funciones nombradas
+ */
+
+// Ejemplo simple de callback
+function procesarTarea(tarea, callback) {
+  console.log(`Iniciando tarea: ${tarea}`);
+
+  // Simulamos un proceso asíncrono con setTimeout
+  setTimeout(() => {
+    callback();
+  }, 1000);
+}
+
+// Ejemplo de uso simple
+console.log("=== Ejemplo Simple de Callback ===");
+procesarTarea("Tarea de prueba", () => {
+  console.log("¡Tarea completada!");
+});
+
+// Simulador de pedidos de restaurante
+class RestaurantePedidos {
+  procesarPedido(plato, onConfirmacion, onListo, onEntrega) {
+    console.log("\n=== Simulador de Restaurante ===");
+
+    // Callback de confirmación
+    onConfirmacion(`Pedido confirmado: ${plato}`);
+
+    // Simular preparación
+    const tiempoPreparacion = this.#tiempoAleatorio();
+    console.log(`Preparando... (${tiempoPreparacion} segundos)`);
+
+    setTimeout(() => {
+      // Callback de listo
+      onListo(`¡${plato} está listo!`);
+
+      // Simular entrega
+      const tiempoEntrega = this.#tiempoAleatorio();
+      console.log(`Llevando a la mesa... (${tiempoEntrega} segundos)`);
+
+      setTimeout(() => {
+        // Callback de entrega
+        onEntrega(`${plato} ha sido entregado. ¡Buen provecho!`);
+      }, tiempoEntrega * 1000);
+    }, tiempoPreparacion * 1000);
+  }
+
+  // Método privado para generar tiempo aleatorio
+  #tiempoAleatorio() {
+    return Math.floor(Math.random() * 10) + 1;
+  }
+}
+
+// Crear instancia del restaurante
+const restaurante = new RestaurantePedidos();
+
+// Procesar un pedido
+restaurante.procesarPedido(
+  "Paella Valenciana",
+  (mensaje) => console.log(`CONFIRMACIÓN: ${mensaje}`),
+  (mensaje) => console.log(`LISTO: ${mensaje}`),
+  (mensaje) => console.log(`ENTREGA: ${mensaje}`)
+);
+
+// Para evitar que el programa termine antes de que se completen los callbacks
+console.log("Esperando a que se procese el pedido...");

Roadmap/21 - CALLBACKS/php/eulogioep.php

@@ -0,0 +1,94 @@
+<?php
+/*
+ * TEORÍA DE CALLBACKS EN PHP:
+ * 
+ * Un callback en PHP es una función que se pasa como argumento a otra función
+ * para ser ejecutada más tarde. PHP ofrece varias formas de implementar callbacks:
+ * 
+ * 1. Funciones anónimas (closures)
+ * 2. Arrays callable ([objeto/clase, método])
+ * 3. Strings con nombres de funciones
+ * 4. Arrow functions (PHP 7.4+)
+ * 
+ * Los callbacks son útiles para:
+ * 1. Personalizar el comportamiento de funciones
+ * 2. Implementar patrones de diseño como Observer
+ * 3. Manejar eventos y procesamiento asíncrono (en la medida que PHP lo permite)
+ */
+
+// Función de utilidad para simular espera
+function simularEspera() {
+    $segundos = rand(1, 10);
+    echo "Procesando... ({$segundos} segundos)\n";
+    sleep($segundos);
+}
+
+// Ejemplo simple de callback
+function procesarTarea(string $tarea, callable $callback): void {
+    echo "Iniciando tarea: {$tarea}\n";
+    
+    // Simulamos algún procesamiento
+    sleep(1);
+    
+    // Ejecutamos el callback
+    $callback();
+}
+
+// Clase para el simulador de restaurante
+class RestaurantePedidos {
+    public function procesarPedido(
+        string $plato,
+        callable $onConfirmacion,
+        callable $onListo,
+        callable $onEntrega
+    ): void {
+        // Callback de confirmación
+        $onConfirmacion("Pedido confirmado: {$plato}");
+        
+        // Simular preparación
+        simularEspera();
+        
+        // Callback de listo
+        $onListo("¡{$plato} está listo!");
+        
+        // Simular entrega
+        simularEspera();
+        
+        // Callback de entrega
+        $onEntrega("{$plato} ha sido entregado. ¡Buen provecho!");
+    }
+}
+
+// Función principal para ejecutar los ejemplos
+function main(): void {
+    echo "=== Ejemplo Simple de Callback ===\n";
+    
+    // Ejemplo usando una función anónima
+    procesarTarea("Tarea de prueba", function() {
+        echo "¡Tarea completada!\n";
+    });
+    
+    echo "\n=== Simulador de Restaurante ===\n";
+    
+    $restaurante = new RestaurantePedidos();
+    
+    // Procesamos un pedido usando el simulador
+    $restaurante->procesarPedido(
+        "Paella Valenciana",
+        // Callback de confirmación - usando arrow function (PHP 7.4+)
+        fn($mensaje) => echo "CONFIRMACIÓN: {$mensaje}\n",
+        // Callback de listo - usando función anónima tradicional
+        function($mensaje) {
+            echo "LISTO: {$mensaje}\n";
+        },
+        // Callback de entrega - también usando función anónima
+        function($mensaje) {
+            echo "ENTREGA: {$mensaje}\n";
+        }
+    );
+}
+
+// Ejecutar el programa
+main();
+
+?>

Roadmap/21 - CALLBACKS/typescript/eulogioep.ts

@@ -0,0 +1,107 @@
+/*
+ * TEORÍA DE CALLBACKS EN TYPESCRIPT:
+ *
+ * TypeScript extiende JavaScript añadiendo tipos estáticos. Para callbacks,
+ * esto significa que podemos definir claramente:
+ * 1. Los tipos de los parámetros que el callback acepta
+ * 2. El tipo de valor que el callback retorna
+ *
+ * Ventajas de usar callbacks en TypeScript:
+ * 1. Mejor intellisense y autocompletado en IDEs
+ * 2. Detección temprana de errores de tipo
+ * 3. Documentación más clara a través de tipos
+ * 4. Refactorización más segura
+ */
+
+// Definición de tipos para los callbacks
+type SimpleCallback = () => void;
+type MessageCallback = (message: string) => void;
+
+// Interface para estructurar los callbacks del restaurante
+interface RestaurantCallbacks {
+  onConfirmation: MessageCallback;
+  onReady: MessageCallback;
+  onDelivery: MessageCallback;
+}
+
+// Clase para manejar pedidos del restaurante
+class RestaurantOrders {
+  // Método privado para generar tiempo aleatorio
+  private getRandomTime(): number {
+    return Math.floor(Math.random() * 10) + 1;
+  }
+
+  // Método para procesar un pedido
+  public processOrder(dish: string, callbacks: RestaurantCallbacks): void {
+    const { onConfirmation, onReady, onDelivery } = callbacks;
+
+    // Confirmación inmediata
+    onConfirmation(`Order confirmed: ${dish}`);
+
+    // Simular preparación
+    const prepTime = this.getRandomTime();
+    console.log(`Preparing... (${prepTime} seconds)`);
+
+    setTimeout(() => {
+      // Plato listo
+      onReady(`${dish} is ready!`);
+
+      // Simular entrega
+      const deliveryTime = this.getRandomTime();
+      console.log(`Delivering to table... (${deliveryTime} seconds)`);
+
+      setTimeout(() => {
+        // Entrega completada
+        onDelivery(`${dish} has been delivered. Enjoy your meal!`);
+      }, deliveryTime * 1000);
+    }, prepTime * 1000);
+  }
+}
+
+// Ejemplo simple de callback
+function processTask(task: string, callback: SimpleCallback): void {
+  console.log(`Starting task: ${task}`);
+
+  setTimeout(() => {
+    callback();
+  }, 1000);
+}
+
+// Función principal asíncrona
+async function main() {
+  console.log("=== Simple Callback Example ===");
+
+  // Ejemplo simple usando Promise para manejar el callback
+  await new Promise<void>((resolve) => {
+    processTask("Test task", () => {
+      console.log("Task completed!");
+      resolve();
+    });
+  });
+
+  console.log("\n=== Restaurant Simulator ===");
+
+  const restaurant = new RestaurantOrders();
+
+  // Creamos un Promise que se resolverá cuando se complete todo el proceso
+  await new Promise<void>((resolve) => {
+    restaurant.processOrder("Paella Valenciana", {
+      onConfirmation: (message: string) => {
+        console.log(`CONFIRMATION: ${message}`);
+      },
+      onReady: (message: string) => {
+        console.log(`READY: ${message}`);
+      },
+      onDelivery: (message: string) => {
+        console.log(`DELIVERY: ${message}`);
+        resolve(); // Resolvemos el Promise cuando se complete la entrega
+      },
+    });
+  });
+}
+
+// Ejecutar el programa principal
+console.log("Starting the program...");
+main().then(() => {
+  console.log("\nProgram completed successfully!");
+});