diff --git a/examen-sesiones/ejercicio1/contacto.php b/examen-sesiones/ejercicio1/contacto.php new file mode 100644 index 00000000..46341311 --- /dev/null +++ b/examen-sesiones/ejercicio1/contacto.php @@ -0,0 +1,29 @@ + + + + + + + + + contacto + + + + + +
+ +
+ +
+

pgina de contacto

+ +
+ + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio1/header.php b/examen-sesiones/ejercicio1/header.php new file mode 100644 index 00000000..ca452ae5 --- /dev/null +++ b/examen-sesiones/ejercicio1/header.php @@ -0,0 +1,18 @@ + +
+
+
+

Hola, ' . $_SESSION['nombre'] . ' ' . $_SESSION['apellido'] . '

+
+
+
+ Inicio + Productos + Contacto +
+
+ +'; diff --git a/examen-sesiones/ejercicio1/index.php b/examen-sesiones/ejercicio1/index.php new file mode 100644 index 00000000..a42a7ba4 --- /dev/null +++ b/examen-sesiones/ejercicio1/index.php @@ -0,0 +1,55 @@ + + + + + + + + + Examen + + + + + + + + + + +
+
+
+

Inicia sesión

+
+
+ +
+
+ +
+ +
+ + +
+ +
+
+
+
+
+ + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio1/inicio.php b/examen-sesiones/ejercicio1/inicio.php new file mode 100644 index 00000000..19a5a35f --- /dev/null +++ b/examen-sesiones/ejercicio1/inicio.php @@ -0,0 +1,29 @@ + + + + + + + + + inicio + + + + + +
+ +
+ +
+

pagina de inicio

+ +
+ + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio1/productos.php b/examen-sesiones/ejercicio1/productos.php new file mode 100644 index 00000000..6125a932 --- /dev/null +++ b/examen-sesiones/ejercicio1/productos.php @@ -0,0 +1,29 @@ + + + + + + + + + productos + + + + + +
+ +
+ +
+

pgina de productos

+ +
+ + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio2/agregarProducto.php b/examen-sesiones/ejercicio2/agregarProducto.php new file mode 100644 index 00000000..6d62c899 --- /dev/null +++ b/examen-sesiones/ejercicio2/agregarProducto.php @@ -0,0 +1,58 @@ + $_POST['nombre'], + "precio" => $_POST['precio'], + "descripcion" => $_POST['descripcion'], + ]); + header('Location: index.php'); + exit; +} +?> + + + + + + + + agregarProducto + + + + + + +
+
+

Agregar Producto

+
+ +
+ +
+ +
+ +
+ +
+ +
+ + +
+ + +
+ +
+
+
+
+ + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio2/functiones.php b/examen-sesiones/ejercicio2/functiones.php new file mode 100644 index 00000000..306a4ab6 --- /dev/null +++ b/examen-sesiones/ejercicio2/functiones.php @@ -0,0 +1,47 @@ + "manzana", + "precio" => "0.33€", + "descripcion" => "es una manzana" + ], + [ + "nombre" => "leche", + "precio" => "1.29€", + "descripcion" => "un litro de leche" + ], + [ + "nombre" => "canelones", + "precio" => "5.99€", + "descripcion" => "pack de 6 canelones" + ], + [ + "nombre" => "zanahoria", + "precio" => "0.20€", + "descripcion" => "es naranja" + ], + [ + "nombre" => "mango", + "precio" => "2.99€", + "descripcion" => "bastante dulce" + ] +]; + +if (!isset($_SESSION["productos"])) { + $_SESSION["productos"] = $productos; +} + +function agregar() +{ + foreach ($_SESSION['productos'] as $producto) { + echo ' + + ' . $producto['nombre'] . ' + ' . $producto['precio'] . ' + ' . $producto['descripcion']. ' + + '; + } +} diff --git a/examen-sesiones/ejercicio2/index.php b/examen-sesiones/ejercicio2/index.php new file mode 100644 index 00000000..b379306f --- /dev/null +++ b/examen-sesiones/ejercicio2/index.php @@ -0,0 +1,44 @@ + + + + + + + + + Document + + + + + + +
+

Productos

+ + + + + + + + + + + + +
NombrePrecioDescripción
+ +
+ Agregar nuevo +
+
+ + + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio3/home.php b/examen-sesiones/ejercicio3/home.php new file mode 100644 index 00000000..670fae95 --- /dev/null +++ b/examen-sesiones/ejercicio3/home.php @@ -0,0 +1,27 @@ + + + + + + + + + home + + + + + +
+
+

Hola,

+
+ +
+
+
+ + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio3/login.php b/examen-sesiones/ejercicio3/login.php new file mode 100644 index 00000000..056f5cea --- /dev/null +++ b/examen-sesiones/ejercicio3/login.php @@ -0,0 +1,73 @@ + "admin", "password" => "1234"], + ["user" => "yehor", "password" => "yehor"], +]; + +// Procesamiento del formulario. + +if ($_SERVER['REQUEST_METHOD'] == 'POST') { + $_SESSION['user'] = $_POST['user']; + $_SESSION['password'] = $_POST['password']; + + if (isset($_POST['user']) && isset($_POST['password'])) { + foreach ($users as $usuario) { + if ($usuario['user'] == $_POST['user'] && $usuario['password'] == $_POST['password']) { + $_SESSION['user'] = $_POST['user']; + header('Location:home.php'); + exit; + } else { + $credIncorrecto = 'Usuario o contraseña son incorrectos'; + } + } + } +} +?> + + + + + + + + login + + + + + +
+ + + + + +
+
+

Inicia sesión

+
+
+ + +
+
+ + +
+ +
+ + +
+ +
+
+ +
+
+
+ + + \ No newline at end of file diff --git a/examen-sesiones/ejercicio3/logout.php b/examen-sesiones/ejercicio3/logout.php new file mode 100644 index 00000000..e4bc3fac --- /dev/null +++ b/examen-sesiones/ejercicio3/logout.php @@ -0,0 +1,6 @@ + + + + + +Respuesta: falso +correcto 9 + + + +12. El siguiente código guardará el nombre en una sesión. (V/F) +session_start(); +if ($_SERVER['REQUEST_METHOD'] === 'GET') { + $_SESSION['nombre'] = $_GET['nombre']; +} +
+ + +
+ + +Respuesta: falso +correcto 10 + + + +13. El siguiente código tiene un error. (V/F) +session_start(); +$_SESSION[‘email’] = $_POST[“email”] +if ($_POST['email']) { + echo ‘

Bienvenido ‘ . $_POST['email'] . ‘ !!!

’ ; +} + +Respuesta: falso +correcto 11 + + + +14. Este código PHP tiene 3 errores. (V/F) +$username = “Rodrigo”; +
Bienvenido + +Respuesta: verdadero +correcto 12 + + + +15. El siguiente formulario HTML tiene un error y no enviará datos. (V/F) +
+ + +
+ +Respuesta: falso +correcto 13 + + +correctos - 13 +incorrectos - 2 + +- 2,21 puntos \ No newline at end of file diff --git a/practicas/biblioteca POO/ejercicio.php b/practicas/biblioteca POO/ejercicio.php new file mode 100644 index 00000000..315e4540 --- /dev/null +++ b/practicas/biblioteca POO/ejercicio.php @@ -0,0 +1,86 @@ +titol = $titol; + $this->autor = $autor; + $this->anyPublicado = $anyPublicado; + $this->foto = $foto; + } +} + +class Biblioteca +{ + public array $llibres = []; + public function afegirLlibre() { + array_push($llibres); + } + + public function mostrarLlibres() {} + + public function cercarLlibre() {} +} + +?> + + + + + + + + + Gestión de Libros + + + + +
+

Añadir un libro

+
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+ + +

Buscar libros

+
+
+ + +
+ +
+ + +

Libros añadidos

+
+ +
+
+ + + + \ No newline at end of file diff --git a/practicas/cajaFuerte/bienvenida.php b/practicas/cajaFuerte/bienvenida.php new file mode 100644 index 00000000..e69de29b diff --git a/practicas/cajaFuerte/index.php b/practicas/cajaFuerte/index.php new file mode 100644 index 00000000..cb64869e --- /dev/null +++ b/practicas/cajaFuerte/index.php @@ -0,0 +1,49 @@ + + + + + +Sombrero Seleccionador de Hogwarts + + + +
+

Benvinguts a Hogwarts

+AQUI VA EL FORMULARI +
+ + + +Aquí us deixo l'array multidimensional ja construit.... més fàcil impossible + +// Array multidimensional amb la informació de cada casa +$casas_info = [ +"Gryffindor" => [ +"background_color" => "#740001", +"text_color" => "#FFD700", +"welcome_message" => "Coratge, valor i determinació. Benvingut a Gryffindor!", +"message_background" => "#D3A625", +"image" => "" +], +"Hufflepuff" => [ +"background_color" => "#FFDB00", +"text_color" => "#60605B", +"welcome_message" => "Lleialtat, paciència i treball dur. Benvingut a Hufflepuff!", +"message_background" => "#EEE117", +"image" => "" +], +"Ravenclaw" => [ +"background_color" => "#0E1A40", +"text_color" => "#946B2D", +"welcome_message" => "Intel·ligència, creativitat i saviesa. Benvingut a Ravenclaw!", +"message_background" => "#5D5D5D", +"image" => "" +], +"Slytherin" => [ +"background_color" => "#1A472A", +"text_color" => "#AAAAAA", +"welcome_message" => "Ambició, astúcia i lideratge. Benvingut a Slytherin!", +"message_background" => "#5D5D5D", +"image" => "" +] +]; \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/componentes/header.php" "b/practicas/patrones de dise\303\261o/componentes/header.php" new file mode 100644 index 00000000..1e3decf3 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/componentes/header.php" @@ -0,0 +1,5 @@ +
+
+ Patrones de Diseño +
+
\ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/componentes/nav.php" "b/practicas/patrones de dise\303\261o/componentes/nav.php" new file mode 100644 index 00000000..8134228d --- /dev/null +++ "b/practicas/patrones de dise\303\261o/componentes/nav.php" @@ -0,0 +1,22 @@ + \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/index.php" "b/practicas/patrones de dise\303\261o/index.php" new file mode 100644 index 00000000..44e759d5 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/index.php" @@ -0,0 +1,73 @@ + + + + + + Patrones de Diseño + + + + +
+

Patrones de Diseño

+

Los patrones de diseño (design patterns) son soluciones habituales a problemas comunes en el diseño de software. + Cada patrón es como un plano que se puede personalizar para resolver un problema de diseño particular de tu código.

+ +
+
+
+
+
Patrones Creacionales
+

Estos patrones proporcionan mecanismos para la creación de objetos que aumentan la flexibilidad y reutilización del código.

+ Ver más +
+
+
+
+
+
+
Patrones Estructurales
+

Se enfocan en la composición de clases y objetos para formar estructuras más grandes y eficientes.

+ Ver más +
+
+
+
+
+
+
Patrones de Comportamiento
+

Se centran en la comunicación entre objetos y la asignación de responsabilidades.

+ Ver más +
+
+
+
+
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Chain.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Chain.php" new file mode 100644 index 00000000..3721d120 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Chain.php" @@ -0,0 +1,188 @@ + + + + + + + + Patrón Chain of Responsibility + + + + + +
+
Patrón Chain of Responsibility
+ +
+
Propósito
+

El patrón Chain of Responsibility permite pasar una solicitud a lo largo de una cadena de manejadores. Cada manejador decide si procesa la solicitud o la pasa al siguiente de la cadena.

+
+ +
+
Problema
+

Supongamos que tienes un sistema de pedidos en línea y necesitas verificar varias cosas, como la autenticación del usuario y la validación de datos, pero no quieres que todo el código se vuelva complejo y difícil de gestionar.

+
+ +
+
Solución
+

Con Chain of Responsibility, puedes organizar las verificaciones en diferentes manejadores, y cada uno decide si puede manejar la solicitud o si la pasa al siguiente manejador en la cadena.

+
+ +
+
Analogía en el mundo real
+

Es como cuando llamas al soporte técnico. Primero hablas con un contestador automático, luego con un operador y, finalmente, con un ingeniero. Cada uno maneja la solicitud y si no puede, la pasa al siguiente nivel.

+
+ +
+
Estructura
+
    +
  • Interfaz Manejadora: Define un método para procesar solicitudes.
    • +
  • Manejadores Concretos: Implementan la lógica para procesar una solicitud específica.
    • +
  • Cliente: Puede componer la cadena de manejadores según sea necesario.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Interfaz de manejo
+interface Handler {
+    method handleRequest(request)
+}
+
+// Manejador concreto que verifica la autenticación
+class AuthenticationHandler implements Handler {
+    method handleRequest(request) {
+        if (request.isAuthenticated()) {
+            nextHandler.handleRequest(request)
+        } else {
+            reject(request)
+        }
+    }
+}
+
+// Manejador concreto que valida los datos
+class ValidationHandler implements Handler {
+    method handleRequest(request) {
+        if (request.isValid()) {
+            nextHandler.handleRequest(request)
+        } else {
+            reject(request)
+        }
+    }
+}
+
+// Cliente que configura la cadena de manejadores
+class RequestProcessor {
+    private field handlerChain: Handler
+
+    constructor RequestProcessor(handlerChain: Handler) {
+        this.handlerChain = handlerChain
+    }
+
+    method process(request) {
+        handlerChain.handleRequest(request)
+    }
+}
+
+// La aplicación utiliza la cadena de responsabilidad
+class Application {
+    method init() {
+        authHandler = new AuthenticationHandler()
+        validationHandler = new ValidationHandler()
+        authHandler.setNext(validationHandler)
+        processor = new RequestProcessor(authHandler)
+        processor.process(request)
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando tienes una serie de verificaciones que se deben realizar de manera secuencial, pero no sabes de antemano el orden o las verificaciones que se van a hacer.
    • +
  • Cuando quieres separar responsabilidades en diferentes clases y hacer que sean fáciles de extender.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crea una interfaz manejadora que defina el método común para manejar solicitudes.
    • +
  • Crea los manejadores concretos con la lógica específica para manejar las solicitudes.
    • +
  • Configura la cadena de manejadores según sea necesario, pasando las solicitudes a través de ellos.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Hace el código más flexible y modular, permite agregar nuevos manejadores sin romper el código cliente.
    • +
  • Contras: Algunas solicitudes pueden no ser procesadas si no hay manejadores adecuados.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Command: Ambos patrones permiten mover solicitudes entre objetos, pero Chain of Responsibility pasa la solicitud a través de una cadena de manejadores.
    • +
  • Mediator: Mientras que el patrón Mediator centraliza la comunicación, Chain of Responsibility permite que los manejadores trabajen de manera independiente.
    • +
  • Observer: Ambos patrones permiten que objetos reaccionen a eventos, pero Chain of Responsibility pasa las solicitudes en lugar de reaccionar a cambios de estado.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Command.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Command.php" new file mode 100644 index 00000000..f10f5313 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Command.php" @@ -0,0 +1,208 @@ + + + + + + + + Patrón Command + + + + + +
+
Patrón Command
+ +
+
Propósito
+

El patrón Command convierte una solicitud en un objeto autónomo, lo que permite parametrizar los objetos con solicitudes, retrasar la ejecución de una solicitud y manejar las solicitudes de forma más flexible.

+
+ +
+
Problema
+

Supón que tienes una interfaz de usuario con múltiples botones y cada botón realiza una acción diferente. En lugar de tener que escribir el código de cada acción en cada parte del sistema, quieres encapsularlas de manera que sea más fácil manejarlas y extenderlas.

+
+ +
+
Solución
+

El patrón Command te permite encapsular las solicitudes de los usuarios como objetos, permitiendo pasar estas solicitudes como parámetros, almacenarlas, deshacerlas o ejecutar múltiples acciones en secuencia de manera flexible.

+
+ +
+
Analogía en el mundo real
+

Es como si tuvieras un asistente personal que, cuando le das una orden, esta se convierte en una tarea que él puede ejecutar más tarde, o incluso delegar a otra persona si es necesario.

+
+ +
+
Estructura
+
    +
  • Comando: Define una interfaz para ejecutar una operación.
    • +
  • Comando Concreto: Implementa la interfaz de comando y define la acción específica a ejecutar.
    • +
  • Invocador: Pide al comando ejecutar una solicitud.
    • +
  • Receptor: Realiza la acción asociada con el comando.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Interfaz de comando
+interface Command {
+    method execute()
+}
+
+// Comando concreto que realiza una acción específica
+class LightOnCommand implements Command {
+    private field light: Light
+
+    constructor LightOnCommand(light: Light) {
+        this.light = light
+    }
+
+    method execute() {
+        light.turnOn()
+    }
+}
+
+class LightOffCommand implements Command {
+    private field light: Light
+
+    constructor LightOffCommand(light: Light) {
+        this.light = light
+    }
+
+    method execute() {
+        light.turnOff()
+    }
+}
+
+// Receptor que conoce cómo ejecutar las acciones reales
+class Light {
+    method turnOn() {
+        print("La luz está encendida.")
+    }
+
+    method turnOff() {
+        print("La luz está apagada.")
+    }
+}
+
+// Invocador que solicita al comando ejecutar la acción
+class RemoteControl {
+    private field command: Command
+
+    method setCommand(command: Command) {
+        this.command = command
+    }
+
+    method pressButton() {
+        command.execute()
+    }
+}
+
+// Cliente que configura los comandos
+class Application {
+    method init() {
+        light = new Light()
+        lightOn = new LightOnCommand(light)
+        lightOff = new LightOffCommand(light)
+
+        remote = new RemoteControl()
+        remote.setCommand(lightOn)
+        remote.pressButton()  // La luz está encendida.
+        remote.setCommand(lightOff)
+        remote.pressButton()  // La luz está apagada.
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando necesitas invocar operaciones en diferentes objetos de manera desacoplada.
    • +
  • Cuando deseas permitir la desactivación, ejecución o ejecución repetida de comandos.
    • +
  • Cuando el sistema debe manejar un conjunto de operaciones pero no quieres que el invocador dependa de los detalles de ejecución de esas operaciones.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crea una interfaz común para los comandos que defina el método `execute`.
    • +
  • Crea los comandos concretos que implementan la interfaz y realizan las acciones específicas.
    • +
  • Configura un invocador que reciba y ejecute los comandos, permitiendo cambiar dinámicamente las acciones a realizar.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Desacopla los invocadores de las acciones específicas, permite deshacer acciones, y es fácil agregar nuevas acciones sin modificar el invocador.
    • +
  • Contras: El sistema puede volverse complejo cuando hay muchos comandos, especialmente si no se organiza adecuadamente.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Chain of Responsibility: Ambos patrones permiten que una solicitud sea manejada por varios objetos, pero en Command, el objeto que recibe la solicitud es explícitamente invocado, mientras que en Chain of Responsibility se pasa a lo largo de una cadena de objetos.
    • +
  • Strategy: Ambos patrones permiten cambiar el comportamiento de un objeto en tiempo de ejecución. Sin embargo, Strategy enfoca en cambiar el algoritmo, mientras que Command se enfoca en encapsular la solicitud como objeto.
    • +
  • Observer: Ambos patrones pueden involucrar la ejecución de acciones en respuesta a eventos, pero Command encapsula una acción, mientras que Observer se enfoca en notificar a los observadores.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Iterator.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Iterator.php" new file mode 100644 index 00000000..9955e771 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Iterator.php" @@ -0,0 +1,217 @@ + + + + + + + + Patrón Iterator + + + + + +
+
Patrón Iterator
+ +
+
Propósito
+

Iterator es un patrón de diseño de comportamiento que te permite recorrer elementos de una colección sin exponer su representación subyacente (lista, pila, árbol, etc.).

+
+ +
+
Problema
+

Las colecciones son de los tipos de datos más utilizados en programación. Sin embargo, una colección tan solo es un contenedor para un grupo de objetos.

+

Varios tipos de colecciones almacenan sus elementos de maneras distintas (listas, pilas, árboles, grafos, etc.). Necesitas una forma de recorrer cada elemento de la colección sin tener que acceder directamente a ellos de manera repetitiva. Diferentes estructuras pueden requerir diferentes algoritmos de recorrido, lo que complica el código cliente.

+
+ +
+
Solución
+

La idea central del patrón Iterator es extraer el comportamiento de recorrido de una colección y colocarlo en un objeto independiente llamado iterador. Los iteradores implementan varios algoritmos de recorrido, y múltiples iteradores pueden recorrer la misma colección de forma independiente.

+

Este patrón asegura que el cliente no dependa de la estructura interna de la colección y pueda usar un algoritmo de recorrido sin preocuparse por su implementación.

+
+ +
+
Analogía en el mundo real
+

Es como cuando visitas Roma: puedes hacerlo siguiendo un mapa, utilizando una aplicación móvil o contratando a un guía turístico. Cada una de estas opciones actúa como un iterador sobre las distintas atracciones de la ciudad.

+
+ +
+
Estructura
+
    +
  • Interfaz Iteradora: Declara las operaciones necesarias para recorrer una colección, como obtener el siguiente elemento o verificar si hay más elementos.
    • +
  • Iteradores Concretos: Implementan algoritmos específicos para recorrer la colección.
    • +
  • Interfaz Colección: Declara un método para obtener iteradores compatibles con la colección.
    • +
  • Colecciones Concretas: Implementan la interfaz Colección y retornan instancias de iteradores concretos.
    • +
  • Cliente: Trabaja con colecciones e iteradores a través de sus interfaces, sin acoplarse a clases específicas.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// La interfaz de colección debe declarar un método fábrica para
+// producir iteradores.
+interface SocialNetwork is
+    method createFriendsIterator(profileId): ProfileIterator
+    method createCoworkersIterator(profileId): ProfileIterator
+
+// Facebook implementa la interfaz SocialNetwork
+class Facebook implements SocialNetwork is
+    method createFriendsIterator(profileId) is
+        return new FacebookIterator(this, profileId, "friends")
+    method createCoworkersIterator(profileId) is
+        return new FacebookIterator(this, profileId, "coworkers")
+
+// La interfaz común a todos los iteradores.
+interface ProfileIterator is
+    method getNext(): Profile
+    method hasMore(): bool
+
+// Clase iteradora concreta
+class FacebookIterator implements ProfileIterator is
+    private field facebook: Facebook
+    private field profileId, type: string
+    private field currentPosition
+    private field cache: array of Profile
+
+    constructor FacebookIterator(facebook, profileId, type) is
+        this.facebook = facebook
+        this.profileId = profileId
+        this.type = type
+
+    private method lazyInit() is
+        if (cache == null)
+            cache = facebook.socialGraphRequest(profileId, type)
+
+    method getNext() is
+        if (hasMore())
+            result = cache[currentPosition]
+            currentPosition++
+            return result
+
+    method hasMore() is
+        lazyInit()
+        return currentPosition < cache.length
+
+// Clase cliente que utiliza el iterador
+class SocialSpammer is
+    method send(iterator: ProfileIterator, message: string) is
+        while (iterator.hasMore())
+            profile = iterator.getNext()
+            System.sendEmail(profile.getEmail(), message)
+                
+// Configuración de la aplicación
+class Application is
+    field network: SocialNetwork
+    field spammer: SocialSpammer
+
+    method config() is
+        if working with Facebook
+            this.network = new Facebook()
+        if working with LinkedIn
+            this.network = new LinkedIn()
+        this.spammer = new SocialSpammer()
+
+    method sendSpamToFriends(profile) is
+        iterator = network.createFriendsIterator(profile.getId())
+        spammer.send(iterator, "Very important message")
+
+    method sendSpamToCoworkers(profile) is
+        iterator = network.createCoworkersIterator(profile.getId())
+        spammer.send(iterator, "Very important message")
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando tu colección tiene una estructura de datos compleja, pero quieres ocultar esa complejidad a los clientes.
    • +
  • Para evitar que el código cliente dependa de detalles específicos de la implementación de la colección.
    • +
  • Para reducir la duplicación del código de recorrido en tu aplicación.
    • +
  • Cuando necesitas recorrer diferentes tipos de colecciones o cuando no conoces las estructuras de datos de antemano.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Declara la interfaz iteradora, que debe incluir al menos un método para obtener el siguiente elemento.
    • +
  • Declara la interfaz de colección con métodos para obtener iteradores.
    • +
  • Implementa iteradores concretos para las colecciones que quieras recorrer.
    • +
  • Implementa la interfaz de colección en las clases de colección y vincula la colección con los iteradores.
    • +
  • Utiliza los iteradores en lugar de recorrer directamente la colección en el código cliente.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Ayuda a mantener el principio de responsabilidad única y el principio de abierto/cerrado. Permite recorrer la misma colección en paralelo y retrazar la iteración si es necesario.
    • +
  • Contras: Puede resultar excesivo si se trabaja solo con colecciones simples. En algunas colecciones especializadas, el uso de un iterador puede ser menos eficiente que recorrer los elementos directamente.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Composite: Puedes utilizar Iteradores para recorrer árboles Composite.
    • +
  • Factory Method: Puedes usar el patrón Factory Method junto con Iterator para permitir que las subclases de la colección devuelvan distintos tipos de iteradores.
    • +
  • Memento: Puedes usar Memento junto con Iterator para capturar el estado de la iteración y reanudarla si fuera necesario.
    • +
  • Visitor: Puedes utilizar Visitor junto con Iterator para recorrer estructuras de datos complejas y ejecutar operaciones sobre sus elementos.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Mediator.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Mediator.php" new file mode 100644 index 00000000..d2951125 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Mediator.php" @@ -0,0 +1,165 @@ + + + + + + + + Patrón Mediator + + + + + +
+
Patrón Mediator
+ +
+
Propósito
+

Mediator es un patrón de diseño de comportamiento que te permite reducir las dependencias caóticas entre objetos. El patrón restringe las comunicaciones directas entre los objetos, forzándolos a colaborar únicamente a través de un objeto mediador.

+
+ +
+
Problema
+

Las relaciones entre los elementos de la interfaz de usuario pueden volverse caóticas cuando la aplicación crece. Los elementos pueden tener muchas relaciones entre ellos, lo que hace que el código sea difícil de mantener y reutilizar.

+

Por ejemplo, en un formulario, si varios campos dependen unos de otros (por ejemplo, un campo de texto que solo aparece si se marca una casilla), se generan dependencias mutuas que complican la reutilización de estos componentes.

+
+ +
+
Solución
+

El patrón Mediator sugiere que los componentes de una interfaz no se comuniquen directamente entre sí, sino que lo hagan a través de un objeto mediador. De este modo, los componentes dependen únicamente del mediador y no de los demás componentes, lo que facilita la reutilización y el mantenimiento del código.

+
+ +
+
Analogía en el mundo real
+

Es como la torre de control del tráfico aéreo: los aviones no se comunican directamente entre sí, sino que lo hacen a través de la torre de control, que regula el tráfico y garantiza que los aviones aterrizan de manera ordenada y segura.

+
+ +
+
Estructura
+
    +
  • Interfaz Mediadora: Declara un método de notificación que los componentes pueden usar para enviar mensajes al mediador.
    • +
  • Mediadores Concretos: Implementan la lógica específica de los componentes que gestionan, redirigiendo las comunicaciones entre ellos.
    • +
  • Componentes: Los objetos que interactúan a través del mediador, enviando notificaciones sin conocerse entre sí.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// La interfaz mediadora declara un método utilizado por los
+// componentes para notificar al mediador sobre varios eventos.
+interface Mediator is
+    method notify(sender: Component, event: string)
+
+// La clase concreta mediadora. Gestiona las relaciones entre los componentes.
+class AuthenticationDialog implements Mediator is
+    private field loginButton, registrationButton: Button
+    private field loginFields, registrationFields: Textbox
+
+    method notify(sender, event) is
+        if (sender == loginButton && event == "click")
+            // Procesa la lógica de inicio de sesión
+        if (sender == registrationButton && event == "click")
+            // Procesa la lógica de registro
+
+// Los componentes se comunican con el mediador sin conocer a otros componentes
+class Button extends Component is
+    method click() is
+        dialog.notify(this, "click")
+
+class Textbox extends Component is
+    method keypress() is
+        dialog.notify(this, "keypress")
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando las clases están fuertemente acopladas y necesitas hacerlas más independientes.
    • +
  • Cuando las relaciones entre los componentes son demasiado complejas y necesitas gestionarlas de forma centralizada.
    • +
  • Cuando desees reutilizar componentes sin que dependan de otros específicos.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Identifica las clases que se beneficiarían de ser menos dependientes entre sí.
    • +
  • Declara la interfaz mediadora con un método para recibir notificaciones de los componentes.
    • +
  • Implementa el mediador que gestione las interacciones entre los componentes.
    • +
  • Modifica los componentes para que se comuniquen solo con el mediador y no entre ellos directamente.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Mejora la mantenibilidad y reutilización del código. Reduce el acoplamiento entre componentes.
    • +
  • Contras: Puede hacer que el mediador se convierta en un objeto todopoderoso, lo que puede ser difícil de mantener si no se gestiona adecuadamente.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Observer: Ambos patrones manejan la comunicación entre objetos, pero Mediator centraliza el flujo de mensajes, mientras que Observer lo distribuye.
    • +
  • Command: Puedes combinar Mediator con Command para delegar las acciones a objetos comando que se gestionan desde el mediador.
    • +
  • Strategy: El patrón Mediator puede coordinar las diferentes estrategias aplicadas por los componentes.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Memento.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Memento.php" new file mode 100644 index 00000000..c773384f --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Memento.php" @@ -0,0 +1,188 @@ + + + + + + + + Patrón Memento + + + + + +
+
Patrón Memento
+ +
+
Propósito
+

Memento es un patrón de diseño de comportamiento que permite guardar y restaurar el estado de un objeto sin exponer su implementación interna. Este patrón es útil cuando se necesita la capacidad de deshacer acciones o restaurar el estado anterior de un objeto.

+
+ +
+
Problema
+

Cuando se tiene un objeto cuyo estado cambia a lo largo del tiempo, puede ser necesario restaurar el estado previo de ese objeto sin exponer su implementación interna. Sin embargo, el objeto no debe ser responsable de gestionar su propio estado guardado.

+
+ +
+
Solución
+

El patrón Memento propone utilizar tres componentes: el objeto originador, que mantiene el estado que puede cambiar; el memento, que guarda el estado del originador; y el cuidador de memento, que almacena los mementos y se encarga de restaurar el estado cuando sea necesario.

+
+ +
+
Analogía en el mundo real
+

Es similar a un libro de notas en el que vas escribiendo. Si te equivocas, puedes hacer una copia de seguridad (memento) antes de escribir. Si algo va mal, puedes restaurar tu copia de seguridad y seguir desde allí sin perder todo tu progreso.

+
+ +
+
Estructura
+
    +
  • Originador: El objeto cuyo estado se guarda. Tiene un método para crear un memento con su estado actual.
    • +
  • Memento: Representa el estado del originador. Está diseñado para ser inmutable y no debe cambiar después de su creación.
    • +
  • Cuidador de Memento: Almacena los mementos y se encarga de restaurar el estado del originador cuando lo necesite.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// El Originador mantiene el estado actual y puede crear un memento.
+class Originador {
+    private state: string;
+
+    // Establece el estado
+    method setState(state: string) {
+        this.state = state;
+    }
+
+    // Crea un memento que guarda el estado actual
+    method createMemento(): Memento {
+        return new Memento(this.state);
+    }
+
+    // Restaura el estado desde un memento
+    method restoreMemento(memento: Memento) {
+        this.state = memento.getState();
+    }
+}
+
+// El Memento guarda el estado de un Originador
+class Memento {
+    private state: string;
+
+    constructor(state: string) {
+        this.state = state;
+    }
+
+    // Devuelve el estado guardado
+    method getState(): string {
+        return this.state;
+    }
+}
+
+// El Cuidador de Memento guarda y recupera el estado del Originador
+class Caretaker {
+    private mementos: Array = [];
+
+    // Guarda un memento
+    method saveMemento(memento: Memento) {
+        this.mementos.push(memento);
+    }
+
+    // Recupera un memento
+    method getMemento(index: number): Memento {
+        return this.mementos[index];
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando se necesita un mecanismo para deshacer cambios en un objeto sin exponer su implementación interna.
    • +
  • Cuando se desea preservar el estado de un objeto de manera que se pueda restaurar más tarde.
    • +
  • Cuando es necesario gestionar múltiples estados previos de un objeto sin que cada uno de esos estados dependa directamente del otro.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crea un objeto originador que mantenga el estado que puede cambiar.
    • +
  • Define un memento que almacene ese estado de forma inmutable.
    • +
  • Implementa un cuidador de memento que almacene los mementos y pueda restaurar el estado anterior cuando sea necesario.
    • +
  • Asegúrate de que el originador no exponga su estado, permitiendo su restauración únicamente a través del memento.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Facilita el deshacer acciones y mantener la integridad del estado de los objetos. Se puede acceder al estado anterior sin exponer la implementación interna.
    • +
  • Contras: Puede generar un gran número de objetos memento, lo que podría generar un uso elevado de memoria. Además, la gestión de mementos puede complicarse si no se organiza adecuadamente.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Command: Puede combinarse con el patrón Command para permitir deshacer o rehacer comandos ejecutados.
    • +
  • State: El patrón Memento puede ser útil cuando se desea guardar los diferentes estados en los que un objeto puede estar, mientras que el patrón State define cómo se comportan esos estados.
    • +
  • Observer: En ciertos casos, el patrón Memento puede usarse junto con Observer para notificar cambios en el estado de los objetos observados.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Observer.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Observer.php" new file mode 100644 index 00000000..05361a0a --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Observer.php" @@ -0,0 +1,196 @@ + + + + + + + + Patrón Observer + + + + + +
+
Patrón Observer
+ +
+
Propósito
+

El patrón **Observer** es un patrón de diseño de comportamiento que te permite definir un mecanismo de suscripción para notificar a varios objetos sobre cualquier evento que le suceda al objeto que están observando, sin necesidad de que esos objetos estén directamente acoplados entre sí.

+
+ +
+
Problema
+

Imagina que tienes dos tipos de objetos: un objeto **Cliente** y un objeto **Tienda**. El cliente está interesado en una marca particular de producto (por ejemplo, un nuevo modelo de iPhone). En lugar de ir a la tienda a diario para ver si el producto está disponible, el cliente prefiere recibir notificaciones sobre su disponibilidad. La tienda, por su parte, podría enviar correos a todos los clientes, pero esto sería ineficiente si muchos clientes no están interesados en ese producto en particular.

+
+ +
+
Solución
+

El patrón Observer sugiere crear un mecanismo de suscripción en el objeto **notificador** (en este caso, la tienda), permitiendo que los objetos suscriptores (clientes) se registren para recibir notificaciones cuando haya actualizaciones o eventos que les interesen. Así, la tienda solo notificará a los clientes interesados sin enviar correos masivos.

+
+ +
+
Analogía en el mundo real
+

Un ejemplo sencillo de la vida real es el sistema de suscripción a revistas o periódicos. Si te suscribes, ya no tienes que ir a la tienda a buscar el último número, sino que el notificador (revista o periódico) te envía los nuevos números directamente a tu buzón. Los suscriptores se pueden dar de baja o cambiar de revista en cualquier momento.

+
+ +
+
Estructura
+
    +
  • Notificador (Publisher): El objeto que genera eventos y mantiene una lista de suscriptores a los que notificará sobre estos eventos.
    • +
  • Suscriptor (Subscriber): El objeto que se suscribe al notificador para recibir notificaciones sobre ciertos eventos.
    • +
  • Interfaz de Suscripción: El notificador y suscriptores se comunican a través de una interfaz común que permite la actualización de los suscriptores cuando ocurre un evento.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Clase base de EventManager para manejar suscripciones y notificaciones
+class EventManager is
+    private field listeners: hash map of event types and listeners
+
+    method subscribe(eventType, listener) is
+        listeners.add(eventType, listener)
+
+    method unsubscribe(eventType, listener) is
+        listeners.remove(eventType, listener)
+
+    method notify(eventType, data) is
+        foreach (listener in listeners.of(eventType)) do
+            listener.update(data)
+
+// Notificador concreto que notifica a los suscriptores sobre eventos
+class Editor is
+    public field events: EventManager
+    private field file: File
+
+    constructor Editor() is
+        events = new EventManager()
+
+    method openFile(path) is
+        this.file = new File(path)
+        events.notify("open", file.name)
+
+    method saveFile() is
+        file.write()
+        events.notify("save", file.name)
+
+// Interfaz para los suscriptores
+interface EventListener is
+    method update(filename)
+
+// Suscriptores concretos que responden a las actualizaciones
+class LoggingListener implements EventListener is
+    private field log: File
+    private field message: string
+
+    constructor LoggingListener(log_filename, message) is
+        this.log = new File(log_filename)
+        this.message = message
+
+    method update(filename) is
+        log.write(replace('%s',filename,message))
+
+class EmailAlertsListener implements EventListener is
+    private field email: string
+    private field message: string
+
+    constructor EmailAlertsListener(email, message) is
+        this.email = email
+        this.message = message
+
+    method update(filename) is
+        system.email(email, replace('%s',filename,message))
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando un objeto (el notificador) cambia su estado y se requiere que varios otros objetos (suscriptores) se actualicen, pero no se conoce de antemano cuántos suscriptores habrá.
    • +
  • Cuando los suscriptores deben poder registrarse o cancelarse dinámicamente durante el tiempo de ejecución.
    • +
  • Cuando se desea evitar el acoplamiento directo entre los objetos que interactúan, permitiendo que se comuniquen a través de eventos.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crea una interfaz **EventListener** que declare el método `update()` que todos los suscriptores deben implementar.
    • +
  • Define un **EventManager** que maneje las suscripciones, desuscripciones y notificaciones de eventos.
    • +
  • Implementa un **notificador** que mantenga la lista de suscriptores y notifique a todos cuando ocurra un evento relevante.
    • +
  • Los **suscriptores** deben implementar la interfaz **EventListener** y reaccionar a las actualizaciones que les envíe el notificador.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Alta flexibilidad y bajo acoplamiento entre los objetos. Nuevos suscriptores pueden añadirse sin modificar la clase del notificador.
    • +
  • Contras: Los suscriptores pueden ser notificados en un orden no determinado. Puede haber una sobrecarga si el número de suscriptores es muy grande.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Chain of Responsibility: Ambos patrones permiten la comunicación entre objetos, pero **Chain of Responsibility** pasa una solicitud a través de una cadena de objetos, mientras que **Observer** mantiene una lista de suscriptores que reciben notificaciones de eventos.
    • +
  • Command: En **Command**, el emisor de una solicitud está acoplado a su receptor, mientras que en **Observer**, los suscriptores pueden registrarse dinámicamente para recibir notificaciones sin acoplarse al notificador.
    • +
  • Mediator: **Mediator** centraliza la comunicación entre objetos, mientras que en **Observer** los objetos se comunican directamente con los suscriptores.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-State.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-State.php" new file mode 100644 index 00000000..ee87293d --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-State.php" @@ -0,0 +1,252 @@ + + + + + + + + + Patrón State + + + + + + +
+
Patrón State
+ +
+
Propósito
+

El **Patrón State** permite que un objeto cambie su comportamiento dependiendo de su estado interno, eliminando grandes estructuras condicionales (`if` o `switch`). Cada estado se encapsula en una clase separada, lo que hace que el código sea más flexible y fácil de mantener.

+
+ +
+
Problema
+

Cuando un objeto tiene múltiples estados y su comportamiento cambia según el estado actual, el uso de estructuras condicionales (`if` o `switch`) puede hacer que el código sea difícil de leer, mantener y escalar. + Un ejemplo común es un **reproductor de música**, que puede estar en **modo pausado, reproduciendo o bloqueado**, y cada estado tiene reglas específicas sobre cómo responder a eventos.

+
+ +
+
Solución
+

El patrón **State** sugiere encapsular cada estado en su propia clase y delegar el comportamiento al estado actual. + El objeto principal (el **contexto**) mantiene una referencia al estado actual y delega el trabajo a esa instancia.

+
+ +
+
Estructura
+
    +
  • Contexto: Mantiene una referencia a un objeto de estado y delega en él su comportamiento.
    • +
  • Estado: Interfaz que define los métodos comunes a todos los estados.
    • +
  • Estados Concretos: Clases que implementan la interfaz de estado y definen el comportamiento específico.
    • +
+
+ +
+
Ejemplo en Código
+
+ 
+// Interfaz común para los estados
+interface Estado {
+    void clickPlay();
+    void clickLock();
+    void clickNext();
+    void clickPrevious();
+}
+
+// Estado: Bloqueado
+class EstadoBloqueado implements Estado {
+    private Reproductor reproductor;
+
+    public EstadoBloqueado(Reproductor reproductor) {
+        this.reproductor = reproductor;
+    }
+
+    @Override
+    public void clickPlay() {
+        // No hace nada
+    }
+
+    @Override
+    public void clickLock() {
+        reproductor.cambiarEstado(new EstadoListo(reproductor));
+    }
+
+    @Override
+    public void clickNext() {}
+    @Override
+    public void clickPrevious() {}
+}
+
+// Estado: Listo para reproducir
+class EstadoListo implements Estado {
+    private Reproductor reproductor;
+
+    public EstadoListo(Reproductor reproductor) {
+        this.reproductor = reproductor;
+    }
+
+    @Override
+    public void clickPlay() {
+        reproductor.cambiarEstado(new EstadoReproduciendo(reproductor));
+        System.out.println("Reproduciendo...");
+    }
+
+    @Override
+    public void clickLock() {
+        reproductor.cambiarEstado(new EstadoBloqueado(reproductor));
+    }
+
+    @Override
+    public void clickNext() {
+        System.out.println("Siguiente canción...");
+    }
+
+    @Override
+    public void clickPrevious() {
+        System.out.println("Canción anterior...");
+    }
+}
+
+// Estado: Reproduciendo
+class EstadoReproduciendo implements Estado {
+    private Reproductor reproductor;
+
+    public EstadoReproduciendo(Reproductor reproductor) {
+        this.reproductor = reproductor;
+    }
+
+    @Override
+    public void clickPlay() {
+        reproductor.cambiarEstado(new EstadoListo(reproductor));
+        System.out.println("Pausado...");
+    }
+
+    @Override
+    public void clickLock() {
+        reproductor.cambiarEstado(new EstadoBloqueado(reproductor));
+    }
+
+    @Override
+    public void clickNext() {
+        System.out.println("Avanzando...");
+    }
+
+    @Override
+    public void clickPrevious() {
+        System.out.println("Retrocediendo...");
+    }
+}
+
+// Contexto: Reproductor de Música
+class Reproductor {
+    private Estado estadoActual;
+
+    public Reproductor() {
+        this.estadoActual = new EstadoListo(this);
+    }
+
+    public void cambiarEstado(Estado nuevoEstado) {
+        this.estadoActual = nuevoEstado;
+    }
+
+    public void clickPlay() { estadoActual.clickPlay(); }
+    public void clickLock() { estadoActual.clickLock(); }
+    public void clickNext() { estadoActual.clickNext(); }
+    public void clickPrevious() { estadoActual.clickPrevious(); }
+}
+
+// Uso del patrón
+public class Main {
+    public static void main(String[] args) {
+        Reproductor reproductor = new Reproductor();
+
+        reproductor.clickPlay();  // Reproduciendo...
+        reproductor.clickNext();  // Siguiente canción...
+        reproductor.clickLock();  // Bloqueado
+        reproductor.clickPlay();  // No hace nada (bloqueado)
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando un objeto tiene múltiples estados con diferentes comportamientos.
    • +
  • Cuando se quiere eliminar los grandes bloques de `if` o `switch`.
    • +
  • Cuando los estados pueden cambiar dinámicamente en tiempo de ejecución.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Separa la lógica de cada estado en clases individuales, mejorando la mantenibilidad.
    • +
  • Pros: Facilita la adición de nuevos estados sin modificar el código existente.
    • +
  • Contras: Puede aumentar la complejidad si hay pocos estados o cambios poco frecuentes.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Strategy: Ambos encapsulan comportamientos en clases separadas, pero **State** cambia dinámicamente entre ellos.
    • +
  • Flyweight: Puede usarse junto con **State** para compartir estados entre múltiples objetos.
    • +
  • Command: Mientras **Command** encapsula una acción como objeto, **State** encapsula un comportamiento.
    • +
+
+ +
+ + + + + \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Strategy.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Strategy.php" new file mode 100644 index 00000000..6504dce0 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Strategy.php" @@ -0,0 +1,199 @@ + + + + + + + + + Patrón Strategy + + + + + + +
+
Patrón Strategy
+ +
+
Propósito
+

El patrón **Strategy** es un patrón de diseño de comportamiento que permite definir una familia de algoritmos, encapsularlos en clases separadas y hacer que sus objetos sean intercambiables dinámicamente.

+
+ +
+
Problema
+

Imagina que desarrollas una aplicación de navegación que ayuda a los usuarios a planificar rutas. Inicialmente, solo se generaban rutas en coche, pero más tarde se añadieron rutas a pie y en transporte público.

+

El código de la aplicación creció de forma descontrolada, volviéndose difícil de mantener. Cada nuevo algoritmo aumentaba la complejidad y afectaba otras partes del código, dificultando el trabajo en equipo.

+
+ +
+
Solución
+

El patrón Strategy propone extraer los algoritmos de enrutamiento y colocarlos en clases separadas, llamadas estrategias. La clase principal de navegación (contexto) delega el cálculo de rutas a la estrategia seleccionada.

+

Esto permite agregar nuevas estrategias sin modificar el código existente, mejorando la flexibilidad y mantenibilidad del sistema.

+
+ +
+
Analogía en el mundo real
+

Si necesitas llegar al aeropuerto, puedes elegir entre distintas estrategias de transporte: taxi, autobús o bicicleta. Dependiendo de tus necesidades (tiempo, costo), seleccionas la mejor opción.

+
+ +
+
Estructura
+
    +
  • Contexto: Mantiene una referencia a una estrategia y la utiliza para realizar una tarea.
    • +
  • Interfaz de Estrategia: Declara un método común para todas las estrategias.
    • +
  • Estrategias Concretas: Implementan diferentes variantes del algoritmo.
    • +
  • Cliente: Configura el contexto con una estrategia específica.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Interfaz común para todas las estrategias
+interface Strategy is
+    method execute(a, b)
+
+// Estrategias concretas con diferentes implementaciones
+class ConcreteStrategyAdd implements Strategy is
+    method execute(a, b) is
+        return a + b
+
+class ConcreteStrategySubtract implements Strategy is
+    method execute(a, b) is
+        return a - b
+
+class ConcreteStrategyMultiply implements Strategy is
+    method execute(a, b) is
+        return a * b
+
+// Clase Contexto que usa una estrategia específica
+class Context is
+    private strategy: Strategy
+
+    method setStrategy(Strategy strategy) is
+        this.strategy = strategy
+
+    method executeStrategy(int a, int b) is
+        return strategy.execute(a, b)
+
+// Código cliente que selecciona y usa una estrategia
+class ExampleApplication is
+    method main() is
+        Create context object.
+
+        Read first number.
+        Read last number.
+        Read the desired action from user input.
+
+        if (action == addition) then
+            context.setStrategy(new ConcreteStrategyAdd())
+
+        if (action == subtraction) then
+            context.setStrategy(new ConcreteStrategySubtract())
+
+        if (action == multiplication) then
+            context.setStrategy(new ConcreteStrategyMultiply())
+
+        result = context.executeStrategy(First number, Second number)
+
+        Print result.
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando necesitas cambiar dinámicamente el comportamiento de un objeto en tiempo de ejecución.
    • +
  • Si tienes muchas clases similares que solo se diferencian en su comportamiento.
    • +
  • Cuando quieres aislar la lógica de negocio de los detalles de implementación de los algoritmos.
    • +
  • Cuando un gran condicional gestiona múltiples variantes de un algoritmo.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Identifica los algoritmos que pueden cambiar y extrae cada uno en su propia clase.
    • +
  • Define una interfaz común para todas las estrategias.
    • +
  • Crea una clase de contexto que use la estrategia seleccionada.
    • +
  • Permite que los clientes configuren la estrategia del contexto dinámicamente.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Permite intercambiar algoritmos en tiempo de ejecución.
    • +
  • Pros: Aísla los detalles de implementación del código que los usa.
    • +
  • Pros: Reduce la duplicación de código al eliminar estructuras condicionales grandes.
    • +
  • Contras: Puede aumentar la complejidad si hay pocas estrategias y no cambian con frecuencia.
    • +
  • Contras: Los clientes deben conocer las diferencias entre estrategias para elegir la correcta.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • State: Similar a Strategy, pero las estrategias pueden cambiarse automáticamente según el estado del contexto.
    • +
  • Command: Permite parametrizar un objeto con una acción, pero tiene un propósito distinto al de Strategy.
    • +
  • Template Method: Usa herencia para definir partes de un algoritmo, mientras que Strategy usa composición.
    • +
  • Decorator: Cambia la "piel" de un objeto, mientras que Strategy cambia su "interior".
    • +
+
+ +
+ + + + + \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-TemplateMethod.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-TemplateMethod.php" new file mode 100644 index 00000000..108b51b8 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-TemplateMethod.php" @@ -0,0 +1,178 @@ + + + + + + + + + Patrón Template Method + + + + + + +
+
Patrón Template Method
+ +
+
Propósito
+

El patrón **Template Method** es un patrón de diseño de comportamiento que define la estructura de un algoritmo en una clase base, permitiendo que las subclases sobrescriban ciertos pasos sin cambiar su estructura general.

+
+ +
+
Problema
+

Cuando varias clases comparten un algoritmo similar pero con ligeras diferencias, se genera duplicación de código. Template Method permite evitar esto al estructurar el algoritmo en pasos personalizables.

+
+ +
+
Solución
+

El patrón Template Method propone dividir un algoritmo en una serie de pasos dentro de un **método plantilla** en una clase base. Las subclases deben implementar los pasos abstractos y pueden sobrescribir los opcionales si es necesario.

+
+ +
+
Analogía en el mundo real
+

Un ejemplo real es la construcción de viviendas en masa. Todas las casas siguen un mismo esquema base, pero los clientes pueden modificar ciertos aspectos como el color de las paredes o el tipo de ventanas.

+
+ +
+
Estructura
+
    +
  • Método plantilla: Define la estructura del algoritmo en la clase base.
    • +
  • Pasos abstractos: Deben ser implementados por las subclases.
    • +
  • Pasos opcionales: Tienen una implementación por defecto pero pueden ser sobrescritos.
    • +
  • Ganchos (Hooks): Métodos opcionales que permiten modificar el comportamiento sin alterar la estructura del algoritmo.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+class GameAI is
+    method turn() is
+        collectResources()
+        buildStructures()
+        buildUnits()
+        attack()
+
+    method collectResources() is
+        foreach (s in this.builtStructures) do
+            s.collect()
+
+    abstract method buildStructures()
+    abstract method buildUnits()
+    
+    method attack() is
+        enemy = closestEnemy()
+        if (enemy == null)
+            sendScouts(map.center)
+        else
+            sendWarriors(enemy.position)
+
+    abstract method sendScouts(position)
+    abstract method sendWarriors(position)
+
+class OrcsAI extends GameAI is
+    method buildStructures() is
+        // Construcción específica de los orcos
+
+    method buildUnits() is
+        // Creación de unidades específicas de los orcos
+
+    method sendScouts(position) is
+        // Exploradores orcos
+
+    method sendWarriors(position) is
+        // Guerreros orcos
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando tienes muchas clases con algoritmos casi idénticos, pero con algunas diferencias mínimas.
    • +
  • Cuando quieres permitir a los clientes extender únicamente partes particulares de un algoritmo sin cambiar su estructura.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Identificar los pasos comunes en varias clases.
    • +
  • Crear una clase base con un **método plantilla** que llame a los distintos pasos en orden.
    • +
  • Declarar los pasos abstractos en la clase base y permitir que las subclases los implementen.
    • +
  • Agregar ganchos (hooks) opcionales si es necesario.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Reduce la duplicación de código y facilita la extensión de algoritmos complejos.
    • +
  • Contras: Puede volverse difícil de mantener si tiene demasiados pasos y puede limitar la flexibilidad en comparación con otros patrones como Strategy.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Factory Method: Es una especialización de Template Method.
    • +
  • Strategy: Se basa en la composición y permite cambiar comportamientos en tiempo de ejecución, mientras que Template Method usa herencia y es estático.
    • +
+
+ +
+ + + + + \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento-Visitor.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Visitor.php" new file mode 100644 index 00000000..8f094981 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento-Visitor.php" @@ -0,0 +1,184 @@ + + + + + + + + + Patrón Visitor + + + + + + +
+
Patrón Visitor
+ +
+
Propósito
+

El patrón **Visitor** es un patrón de diseño de comportamiento que permite separar algoritmos de los objetos sobre los que operan, facilitando la adición de nuevas operaciones sin modificar las clases de los objetos.

+
+ +
+
Problema
+

Imagina un sistema con clases de nodos representados en un grafo (por ejemplo, ciudades, industrias, etc.). Si quieres agregar nuevas funcionalidades como la exportación a XML o el cálculo de impuestos, modificar las clases existentes puede ser riesgoso y difícil de mantener. Cada vez que agregas una nueva operación, corres el riesgo de romper algo en el sistema.

+
+ +
+
Solución
+

El patrón Visitor propone crear un objeto visitante que implemente las nuevas operaciones. Este visitante recorre las instancias de las clases y realiza la operación sobre ellas, sin necesidad de modificar las clases de los nodos. De esta forma, puedes añadir nuevas funcionalidades sin alterar el código existente.

+
+ +
+
Analogía en el mundo real
+

Una analogía en el mundo real sería el proceso de inspección de vehículos. Un inspector puede aplicar diferentes pruebas (como la prueba de emisiones o la revisión de frenos) sin tener que cambiar la estructura de un coche. El coche (objeto) sigue siendo el mismo, pero se le aplican diferentes pruebas (operaciones) a través de un inspector (visitor).

+
+ +
+
Estructura
+
    +
  • Elemento: El objeto que será visitado. Define un método `accept` que recibe un visitante.
    • +
  • Visitante: Define las operaciones que se realizarán sobre los elementos. Debe implementar un método para cada tipo de elemento concreto.
    • +
  • Elementos concretos: Implementan el método `accept`, que llama al método correspondiente del visitante.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Visitante que realiza diferentes operaciones sobre los elementos
+class Visitor {
+    method visit(ElementA element) {
+        // Realizar operación sobre ElementA
+    }
+
+    method visit(ElementB element) {
+        // Realizar operación sobre ElementB
+    }
+}
+
+// Elemento base que puede ser visitado por un visitante
+class Element {
+    method accept(visitor: Visitor) {
+        visitor.visit(this)
+    }
+}
+
+// Elementos concretos con tipos específicos
+class ElementA extends Element {
+    method accept(visitor: Visitor) {
+        visitor.visit(this)
+    }
+}
+
+class ElementB extends Element {
+    method accept(visitor: Visitor) {
+        visitor.visit(this)
+    }
+}
+
+// Implementación del visitante
+class ConcreteVisitor extends Visitor {
+    method visit(ElementA element) {
+        // Operación específica para ElementA
+    }
+
+    method visit(ElementB element) {
+        // Operación específica para ElementB
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando se necesita realizar operaciones sobre una estructura compleja de objetos y no deseas modificar las clases de esos objetos.
    • +
  • Cuando se quiere mantener el código abierto para la extensión pero cerrado para la modificación (principio de abierto/cerrado).
    • +
  • Cuando la estructura de clases de los objetos es estable, pero las operaciones que se realizan sobre ellas pueden cambiar o crecer con el tiempo.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Define una interfaz **Visitor** con un método `visit` para cada tipo de objeto que se va a visitar.
    • +
  • Crea una clase base **Elemento** que tenga un método `accept` que reciba un visitante y le pase a la visita correspondiente.
    • +
  • Los **Elementos concretos** deben implementar el método `accept` y llamar al método `visit` adecuado del visitante.
    • +
  • Los **Visitantes** concretos implementan las operaciones sobre los elementos sin modificarlos directamente.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Permite añadir nuevas operaciones sin modificar las clases existentes. Mejora la flexibilidad y el mantenimiento del código.
    • +
  • Contras: Puede ser complejo de implementar si hay muchas clases de elementos y visitantes. Si se agregan o eliminan tipos de elementos, todos los visitantes deben ser actualizados.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Strategy: Ambos patrones permiten cambiar el comportamiento de un objeto sin modificar su clase. Sin embargo, **Visitor** se enfoca en añadir nuevas operaciones, mientras que **Strategy** se enfoca en cambiar comportamientos específicos.
    • +
  • Composite: **Composite** permite tratar objetos individuales y compuestos de la misma forma, mientras que **Visitor** se enfoca en realizar operaciones sobre la estructura de objetos.
    • +
  • Decorator: Mientras que **Decorator** añade funcionalidades adicionales a un objeto sin alterar su estructura, **Visitor** agrega operaciones sin modificar los objetos visitados.
    • +
+
+ +
+ + + + + \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/patrones/comportamiento.php" "b/practicas/patrones de dise\303\261o/patrones/comportamiento.php" new file mode 100644 index 00000000..e2250dbe --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/comportamiento.php" @@ -0,0 +1,171 @@ + + + + + + + + + Patrones de Comportamiento + + + + + +
+
+
+

Patrones de Comportamiento

+

Selecciona un patrón de comportamiento para aprender más.

+ + + +
+
Chain of Responsibility
+

Permite pasar solicitudes a lo largo de una cadena de manejadores. Cada manejador decide si la procesa o pasa al siguiente manejador.

+ Ver más +
+ +
+
Command
+

Convierte una solicitud en un objeto independiente que contiene toda la información sobre la solicitud.

+ Ver más +
+ +
+
Iterator
+

Permite recorrer elementos de una colección sin exponer su representación subyacente.

+ Ver más +
+ +
+
Mediator
+

Permite reducir las dependencias caóticas entre objetos, forzando la colaboración solo a través de un objeto mediador.

+ Ver más +
+ +
+
Memento
+

Permite guardar y restaurar el estado previo de un objeto sin revelar los detalles de su implementación.

+ Ver más +
+ +
+
Observer
+

Permite definir un mecanismo de suscripción para notificar a varios objetos sobre cualquier evento.

+ Ver más +
+ +
+
State
+

Permite a un objeto alterar su comportamiento cuando su estado interno cambia.

+ Ver más +
+ +
+
Strategy
+

Permite definir una familia de algoritmos, colocarlos en clases separadas y hacerlos intercambiables.

+ Ver más +
+ +
+
Template Method
+

Define el esqueleto de un algoritmo en la superclase pero permite que las subclases sobrescriban pasos del algoritmo.

+ Ver más +
+ +
+
Visitor
+

Permite separar algoritmos de los objetos sobre los que operan.

+ Ver más +
+
+
+
+ + + + + \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/patrones/creacionales-AbstractFalctory.php" "b/practicas/patrones de dise\303\261o/patrones/creacionales-AbstractFalctory.php" new file mode 100644 index 00000000..2d1ce49b --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/creacionales-AbstractFalctory.php" @@ -0,0 +1,171 @@ + + + + + + + + Patrón Abstract Factory + + + + + +
+

Patrón Abstract Factory

+ +
+
Propósito
+

El patrón Abstract Factory permite producir familias de objetos relacionados sin especificar sus clases concretas. Es útil cuando el sistema debe ser independiente de cómo se crean, componen y representan los objetos.

+
+ +
+
Problema
+

Si estás trabajando con una tienda de muebles y necesitas crear productos como Sillas, Sofás y Mesillas, y quieres que estos productos tengan distintas variantes (moderna, victoriana, etc.), puedes enfrentar dificultades para gestionar estas variantes si el código cliente depende de clases concretas.

+
+ +
+
Solución
+

La solución es usar el patrón Abstract Factory, donde se definen interfaces para las familias de productos. Las fábricas concretas implementan estas interfaces y permiten que el código cliente trabaje con las fábricas sin preocuparse de los detalles de implementación.

+
+ +
+
Estructura
+
    +
  • Producto abstracto: Define una interfaz para los productos que se pueden crear.
    • +
  • Producto concreto: Implementa las interfaces de los productos definidos en la fábrica abstracta.
    • +
  • Fábrica abstracta: Declara los métodos de creación de productos abstractos.
    • +
  • Fábrica concreta: Implementa los métodos de creación de productos específicos, según la variante.
    • +
  • Cliente: Usa las fábricas abstractas para crear productos, sin depender de clases concretas.
    • +
+
+ +
+
Ejemplo
+
+ 
+interface GUIFactory {
+    function createButton();
+    function createCheckbox();
+}
+
+class WinFactory implements GUIFactory {
+    function createButton() { return new WinButton(); }
+    function createCheckbox() { return new WinCheckbox(); }
+}
+
+interface Button {
+    function paint();
+}
+
+class WinButton implements Button {
+    function paint() { echo "Botón estilo Windows"; }
+}
+
+interface Checkbox {
+    function paint();
+}
+
+class WinCheckbox implements Checkbox {
+    function paint() { echo "Checkbox estilo Windows"; }
+}
+
+class Application {
+    private $factory;
+    
+    function __construct(GUIFactory $factory) {
+        $this->factory = $factory;
+    }
+    
+    function createUI() {
+        $button = $this->factory->createButton();
+        $checkbox = $this->factory->createCheckbox();
+        
+        $button->paint();
+        $checkbox->paint();
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando tu código necesita trabajar con múltiples variantes de productos sin saber sus clases concretas.
    • +
  • Cuando desees asegurar la compatibilidad entre productos creados por diferentes fábricas.
    • +
  • Cuando quieras crear sistemas fáciles de extender con nuevos tipos de productos sin modificar el código cliente.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Desacopla la creación de productos, facilita la extensión de productos sin afectar el código cliente.
    • +
  • Contras: Aumenta la complejidad del sistema debido a la cantidad de interfaces y clases.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Factory Method: Ambos patrones encapsulan la creación de objetos, pero Abstract Factory se enfoca en familias de objetos.
    • +
  • Builder: Abstract Factory crea productos de una familia, mientras que Builder construye productos complejos paso a paso.
    • +
  • Prototype: Utiliza un prototipo de productos que puede ser modificado, mientras que Abstract Factory asegura la compatibilidad entre productos.
    • +
  • Facade: Abstract Factory puede ser usado en conjunto con Facade para ocultar la complejidad de la creación de productos del cliente.
    • +
  • Bridge: Ambos patrones ayudan a desacoplar abstracciones y implementaciones, pero en el caso de Abstract Factory, se enfoca en la creación de productos específicos.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/creacionales-Builder.php" "b/practicas/patrones de dise\303\261o/patrones/creacionales-Builder.php" new file mode 100644 index 00000000..ef6f0e9d --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/creacionales-Builder.php" @@ -0,0 +1,214 @@ + + + + + + + + Resumen del Patrón Builder + + + + + +
+

Builder

+ +
+
Propósito
+

Builder es un patrón de diseño creacional que nos permite construir objetos complejos paso a paso. El patrón nos permite producir distintos tipos y representaciones de un objeto empleando el mismo código de construcción.

+
+ +
+
Problema
+

Imagina un objeto complejo que requiere una inicialización laboriosa, paso a paso, de muchos campos y objetos anidados. Normalmente, este código de inicialización está sepultado dentro de un monstruoso constructor con una gran cantidad de parámetros. O, peor aún: disperso por todo el código cliente.

+

Una gran cantidad de subclases genera otro problema. Crear una subclase por cada configuración posible de un objeto puede complicar demasiado el programa.

+

Por ejemplo, pensemos en cómo crear un objeto Casa. Para construir una casa sencilla, debemos construir cuatro paredes y un piso, así como instalar una puerta, colocar un par de ventanas y ponerle un tejado. Pero ¿qué pasa si quieres una casa más grande y luminosa, con un jardín y otros extras (como sistema de calefacción, instalación de fontanería y cableado eléctrico)?

+

La solución más sencilla es extender la clase base Casa y crear un grupo de subclases que cubran todas las combinaciones posibles de los parámetros. Pero, en cualquier caso, acabarás con una cantidad considerable de subclases. Cualquier parámetro nuevo, como el estilo del porche, exigirá que incrementes esta jerarquía aún más.

+

Existen otras soluciones, como un constructor telescópico, pero este puede volverse muy complejo y difícil de gestionar.

+
+ +
+
Solución
+

El patrón Builder sugiere que saques el código de construcción del objeto de su propia clase y lo coloques dentro de objetos independientes llamados constructores.

+
+ +
+
Aplicación del patrón Builder
+

El patrón Builder te permite construir objetos complejos paso a paso, organizando la construcción en una serie de pasos (por ejemplo, construirParedes, construirPuerta, etc.). Estos pasos pueden invocarse según sea necesario, sin tener que invocar todos los pasos. Además, diferentes constructores pueden implementar los mismos pasos de forma diferente para crear distintas representaciones del producto.

+

Un ejemplo sería la construcción de una casa que varíe en materiales: madera, piedra, oro, etc. Al invocar la misma serie de pasos, podemos obtener distintos tipos de casas sin modificar el código cliente.

+
+ +
+
Estructura
+
    +
  • Interfaz Constructora: Declara los métodos para los pasos de construcción comunes.
    • +
  • Constructores Concretos: Implementan la interfaz constructora y proporcionan las implementaciones específicas de los pasos.
    • +
  • Productos: Son los objetos que resultan de la construcción, que no necesariamente pertenecen a la misma jerarquía de clases.
    • +
  • Clase Directora: Define el orden en que se deben ejecutar los pasos de construcción, gestionando la creación de productos más complejos.
    • +
  • Cliente: Asocia un objeto constructor con la clase directora y comienza el proceso de construcción.
    • +
+
+ +
+
Ejemplo de Pseudocódigo
+
+ 
+// Ejemplo de clase automovil y manual
+class Car {
+    // Características del automóvil
+}
+
+class Manual {
+    // Instrucciones del automóvil
+}
+
+interface Builder {
+    method reset();
+    method setSeats(...);
+    method setEngine(...);
+    method setTripComputer(...);
+    method setGPS(...);
+}
+
+class CarBuilder implements Builder {
+    private field car:Car;
+    constructor CarBuilder() {
+        this.reset();
+    }
+    method reset() {
+        this.car = new Car();
+    }
+    method setSeats(...) { /* Establece los asientos */ }
+    method setEngine(...) { /* Establece el motor */ }
+    method setTripComputer(...) { /* Instala la computadora */ }
+    method setGPS(...) { /* Instala GPS */ }
+    method getProduct():Car {
+        product = this.car;
+        this.reset();
+        return product;
+    }
+}
+
+class CarManualBuilder implements Builder {
+    private field manual:Manual;
+    constructor CarManualBuilder() {
+        this.reset();
+    }
+    method reset() {
+        this.manual = new Manual();
+    }
+    method setSeats(...) { /* Documenta los asientos */ }
+    method setEngine(...) { /* Instrucciones motor */ }
+    method setTripComputer(...) { /* Instrucciones computadora */ }
+    method setGPS(...) { /* Instrucciones GPS */ }
+    method getProduct():Manual {
+        return this.manual;
+    }
+}
+
+class Director {
+    method constructSportsCar(builder: Builder) {
+        builder.reset();
+        builder.setSeats(2);
+        builder.setEngine(new SportEngine());
+        builder.setTripComputer(true);
+        builder.setGPS(true);
+    }
+}
+
+class Application {
+    method makeCar() {
+        director = new Director();
+        builder = new CarBuilder();
+        director.constructSportsCar(builder);
+        car = builder.getProduct();
+        builder = new CarManualBuilder();
+        director.constructSportsCar(builder);
+        manual = builder.getProduct();
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Utiliza el patrón Builder para evitar un “constructor telescópico”.
    • +
  • Cuando necesites construir distintas representaciones de un producto (por ejemplo, casas de piedra y madera).
    • +
  • Cuando la construcción de un producto requiera pasos similares pero con variaciones.
    • +
  • Para construir objetos complejos o árboles con el patrón Composite.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Permite construir objetos paso a paso, aplazar pasos o ejecutarlos de forma recursiva. Reutiliza el mismo código de construcción para distintas representaciones de productos.
    • +
  • Contras: Aumenta la complejidad del código al requerir varias clases nuevas.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Builder se puede usar junto con Factory Method, Abstract Factory o Prototype para crear productos más complejos.
    • +
  • Es útil en la creación de productos con estructuras recursivas, como árboles Composite.
    • +
  • Se puede combinar con Bridge para separar la abstracción y la implementación del proceso de construcción.
    • +
+
+ +
+ + + + \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/patrones/creacionales-FacrotyMethod.php" "b/practicas/patrones de dise\303\261o/patrones/creacionales-FacrotyMethod.php" new file mode 100644 index 00000000..d8c9ea4b --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/creacionales-FacrotyMethod.php" @@ -0,0 +1,129 @@ + + + + + + + + Patrón Factory Method + + + + + +
+

Patrón Factory Method

+ +
+
Propósito
+

El patrón Factory Method es un patrón de diseño creacional que proporciona una interfaz para crear objetos en una superclase, permitiendo a las subclases alterar el tipo de objetos que se crearán sin modificar el código cliente.

+
+ +
+
Problema
+

Si tienes un código muy acoplado a clases específicas, como en una aplicación de transporte que maneja camiones, agregar nuevas clases de transporte puede resultar en un código desordenado lleno de condicionales. Esto dificulta la extensibilidad y el mantenimiento del código.

+
+ +
+
Solución
+

La solución es usar el patrón Factory Method, que delega la creación de objetos a un método especializado. Este método puede ser sobrescrito en subclases para cambiar la clase de los productos creados, manteniendo el código flexible y escalable.

+
+ +
+
Estructura
+
    +
  • Producto: Declara una interfaz común para todos los productos que puede crear la clase creadora.
    • +
  • Producto Concreto: Implementaciones específicas de la interfaz de producto.
    • +
  • Creador: Declara el método de fábrica que devuelve objetos de tipo Producto.
    • +
  • Creador Concreto: Sobrescribe el método de fábrica para devolver un tipo específico de producto.
    • +
+
+ +
+
Ejemplo
+
+ 
+class Dialog:
+    def create_button(self):
+        pass
+
+class WindowsDialog(Dialog):
+    def create_button(self):
+        return WindowsButton()
+
+class WebDialog(Dialog):
+    def create_button(self):
+        return HTMLButton()
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando no conozcas las dependencias exactas y los tipos de objetos que tu código va a manejar.
    • +
  • Para desacoplar el código de creación de objetos del código cliente.
    • +
  • Cuando quieras que los usuarios puedan extender componentes sin modificar la lógica interna.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Reduce el acoplamiento, mejora la extensibilidad y el mantenimiento del código.
    • +
  • Contras: Puede llevar a un aumento en la complejidad del código, ya que requiere la creación de muchas subclases.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/creacionales-Prototype.php" "b/practicas/patrones de dise\303\261o/patrones/creacionales-Prototype.php" new file mode 100644 index 00000000..f8141d14 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/creacionales-Prototype.php" @@ -0,0 +1,189 @@ + + + + + + + + Patrón Prototype + + + + + +
+

Patrón Prototype

+ +
+
Propósito
+

El patrón Prototype permite copiar objetos existentes sin depender de sus clases. Este patrón delega el proceso de clonación a los propios objetos, lo que facilita la creación de copias sin necesidad de conocer la clase concreta del objeto.

+
+ +
+
Problema
+

Cuando necesitas crear una copia exacta de un objeto, lo más común es crear un nuevo objeto de la misma clase. Sin embargo, este enfoque depende de las clases concretas y puede ser complicado cuando los campos del objeto son privados o cuando no conocemos la clase exacta, solo su interfaz.

+
+ +
+
Solución
+

El patrón Prototype resuelve este problema al delegar la clonación a los propios objetos, proporcionando una interfaz común para clonar objetos. Cada objeto define su propio método clonar(), lo que permite la creación de copias sin depender de su clase concreta.

+
+ +
+
Estructura
+
    +
  • Interfaz Prototype: Declara el método de clonación.
    • +
  • Prototipo Concreto: Implementa el método de clonación y realiza la copia de los campos del objeto original.
    • +
  • Cliente: Usa el prototipo para crear copias sin necesidad de conocer la clase concreta.
    • +
+
+ +
+
Ejemplo
+
+ 
+// Prototipo base.
+abstract class Shape {
+    field X, Y, color;
+
+    constructor Shape(source) {
+        this.X = source.X;
+        this.Y = source.Y;
+        this.color = source.color;
+    }
+
+    abstract method clone(): Shape;
+}
+
+class Rectangle extends Shape {
+    field width, height;
+
+    constructor Rectangle(source) {
+        super(source);
+        this.width = source.width;
+        this.height = source.height;
+    }
+
+    method clone() {
+        return new Rectangle(this);
+    }
+}
+
+class Circle extends Shape {
+    field radius;
+
+    constructor Circle(source) {
+        super(source);
+        this.radius = source.radius;
+    }
+
+    method clone() {
+        return new Circle(this);
+    }
+}
+
+// Cliente
+class Application {
+    field shapes;
+
+    constructor Application() {
+        Circle circle = new Circle();
+        circle.X = 10;
+        circle.Y = 10;
+        circle.radius = 20;
+        shapes.add(circle);
+
+        Circle anotherCircle = circle.clone();
+        shapes.add(anotherCircle);
+    }
+
+    method businessLogic() {
+        Array shapesCopy = [];
+        foreach (s in shapes) {
+            shapesCopy.add(s.clone());
+        }
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando tu código necesita clonar objetos sin depender de sus clases concretas.
    • +
  • Cuando quieres reducir la cantidad de subclases mediante el uso de prototipos configurados.
    • +
  • Cuando trabajas con objetos pasados a través de interfaces y no conoces su tipo exacto.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Permite clonar objetos sin depender de su clase concreta, reduce la necesidad de subclases y facilita la creación de objetos complejos.
    • +
  • Contras: La clonación de objetos con referencias circulares puede ser complicada.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Factory Method: Prototype puede complementar Factory Method al permitir la clonación de objetos en lugar de crear nuevas instancias.
    • +
  • Abstract Factory: Ambos patrones crean objetos, pero Prototype se enfoca en copiar objetos ya existentes.
    • +
  • Composite y Decorator: Prototype puede ser útil al clonar estructuras complejas en lugar de reconstruirlas desde cero.
    • +
  • Builder: Prototype puede ser una alternativa más flexible al patrón Builder en algunos casos.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/creacionales-Singleton.php" "b/practicas/patrones de dise\303\261o/patrones/creacionales-Singleton.php" new file mode 100644 index 00000000..1b0f9848 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/creacionales-Singleton.php" @@ -0,0 +1,188 @@ + + + + + + + + Patrón Singleton + + + + + +
+

Patrón Singleton

+ +
+
Propósito
+

Singleton es un patrón de diseño creacional que nos permite asegurarnos de que una clase tenga una única instancia, a la vez que proporciona un punto de acceso global a dicha instancia.

+
+ +
+
Problema
+

El patrón Singleton resuelve dos problemas al mismo tiempo, vulnerando el Principio de responsabilidad única:

+
    +
  • Garantizar que una clase tenga una única instancia: Esto es útil para controlar el acceso a recursos compartidos, como bases de datos o archivos.
    • +
  • Acceso global a un objeto: Permite que los clientes trabajen con el mismo objeto sin darse cuenta, evitando sobrescritura accidental.
    • +
+
+ +
+
Solución
+

El patrón Singleton implementa dos pasos clave:

+
    +
  • Hacer privado el constructor para evitar la creación de instancias fuera de la clase Singleton.
    • +
  • Crear un método estático que devuelva la instancia única, almacenada en un campo estático para ser reutilizada.
    • +
+
+ +
+
Analogía en el mundo real
+

El gobierno es un ejemplo excelente de patrón Singleton. Un país sólo tiene un gobierno oficial, y la figura del gobierno es el punto de acceso global que identifica al grupo de personas a cargo.

+
+ +
+
Estructura
+
    +
  • Clase Singleton: Declara el método estático obtenerInstancia, que garantiza que sólo haya una instancia de la clase.
    • +
  • Constructor Privado: El constructor se oculta para evitar instanciación directa, permitiendo el acceso sólo a través del método estático.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// La clase Base de datos define el método `obtenerInstancia`
+// que permite a los clientes acceder a la misma instancia de
+// una conexión de la base de datos a través del programa.
+class Database is
+    // El campo para almacenar la instancia singleton debe
+    // declararse estático.
+    private static field instance: Database
+
+    // El constructor del singleton siempre debe ser privado
+    // para evitar llamadas de construcción directas con el
+    // operador `new`.
+    private constructor Database() is
+        // Algún código de inicialización, como la propia
+        // conexión al servidor de una base de datos.
+        // ...
+
+    // El método estático que controla el acceso a la instancia
+    // singleton.
+    public static method getInstance() is
+        if (Database.instance == null) then
+            acquireThreadLock() and then
+                // Garantiza que la instancia aún no se ha
+                // inicializado por otro hilo mientras ésta ha
+                // estado esperando el desbloqueo.
+                if (Database.instance == null) then
+                    Database.instance = new Database()
+        return Database.instance
+
+    // Lógica de negocio
+    public method query(sql) is
+        // Ejemplo de consulta a la base de datos.
+        // ...
+
+class Application is
+    method main() is
+        Database foo = Database.getInstance()
+        foo.query("SELECT ...")
+        Database bar = Database.getInstance()
+        bar.query("SELECT ...")
+        // `bar` es la misma instancia que `foo`.
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando una clase debe tener solo una instancia accesible globalmente, como un objeto de base de datos.
    • +
  • Cuando necesitas controlar el acceso a una variable global, garantizando una sola instancia.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Añadir un campo estático privado a la clase para almacenar la instancia Singleton.
    • +
  • Declarar un método estático para obtener la instancia Singleton.
    • +
  • Implementar una inicialización diferida dentro del método estático.
    • +
  • Declarar el constructor como privado para prevenir la creación directa de instancias.
    • +
  • Sustituir llamadas directas al constructor por el método estático.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Garantiza una única instancia, acceso global, y eficiencia con la inicialización diferida.
    • +
  • Contras: Puede violar el Principio de Responsabilidad Única, complicar pruebas unitarias, y causar problemas en entornos multihilo.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Fachada: Una fachada puede convertirse en un Singleton, ya que se necesita un solo objeto fachada en la mayoría de los casos.
    • +
  • Flyweight: Ambos patrones tienen una sola instancia compartida, pero Flyweight permite múltiples instancias con estados distintos.
    • +
  • Abstract Factory, Builder, Prototype: Pueden implementarse como Singletons si es necesario.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/creacionales.php" "b/practicas/patrones de dise\303\261o/patrones/creacionales.php" new file mode 100644 index 00000000..aa95c5b0 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/creacionales.php" @@ -0,0 +1,122 @@ + + + + + + + + Patrones Creacionales + + + + +
+
+
+

Patrones Creacionales

+

Selecciona un patrón creacional para aprender más.

+ + + +
+
Factory Method
+

Proporciona una interfaz para la creación de objetos en una superclase, mientras permite a las subclases alterar el tipo de objetos que se crearán.

+ Ver más +
+ +
+
Abstract Factory
+

Permite producir familias de objetos relacionados sin especificar sus clases concretas.

+ Ver más +
+ +
+
Builder
+

Permite construir objetos complejos paso a paso. Este patrón nos permite producir distintos tipos y representaciones de un objeto empleando el mismo código de construcción.

+ Ver más +
+ +
+
Prototype
+

Permite copiar objetos existentes sin que el código dependa de sus clases.

+ Ver más +
+ +
+
Singleton
+

Permite asegurarnos de que una clase tenga una única instancia, a la vez que proporciona un punto de acceso global a dicha instancia.

+ Ver más +
+
+
+
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales-Adapter.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales-Adapter.php" new file mode 100644 index 00000000..ece9e787 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales-Adapter.php" @@ -0,0 +1,184 @@ + + + + + + + + Patrón Adapter + + + + + +
+

Patrón Adapter

+ +
+
Propósito
+

Adapter es un patrón de diseño estructural que permite la colaboración entre objetos con interfaces incompatibles.

+
+ +
+
Problema
+

Imagina que estás creando una aplicación de monitoreo del mercado de valores. La aplicación descarga la información de bolsa desde varias fuentes en formato XML para presentarla al usuario con bonitos gráficos y diagramas. Pero decides integrar una biblioteca de análisis que solo funciona con datos en formato JSON. Esto crea un conflicto de interfaces.

+
+ +
+
Solución
+

El patrón Adapter resuelve este dilema creando un adaptador que actúa como intermediario entre los objetos con interfaces incompatibles, permitiendo que el cliente use la nueva biblioteca sin necesidad de modificar el código cliente existente.

+
+ +
+
Analogía en el mundo real
+

Imagina que viajas de Europa a Estados Unidos y tienes que usar un enchufe europeo en un país con enchufes americanos. El adaptador convierte el enchufe europeo en uno compatible con el estándar estadounidense.

+
+ +
+
Estructura
+
    +
  • Clase Cliente: Contiene la lógica de negocio y necesita usar la clase de servicio incompatible.
    • +
  • Interfaz con el Cliente: Define el protocolo de comunicación que los clientes usan para interactuar con las clases de servicio.
    • +
  • Clase de Servicio: La clase que tiene la funcionalidad que el cliente necesita, pero con una interfaz incompatible.
    • +
  • Clase Adaptadora: Envuelve la clase de servicio y convierte su interfaz a una que el cliente pueda utilizar.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Definición de un agujero redondo.
+class RoundHole is
+    constructor RoundHole(radius) { ... }
+    
+    method getRadius() is
+        return this.radius
+
+    method fits(peg: RoundPeg) is
+        return this.getRadius() >= peg.getRadius()
+
+// Definición de una pieza redonda.
+class RoundPeg is
+    constructor RoundPeg(radius) { ... }
+
+    method getRadius() is
+        return this.radius
+
+// Definición de una pieza cuadrada incompatible.
+class SquarePeg is
+    constructor SquarePeg(width) { ... }
+
+    method getWidth() is
+        return this.width
+
+// El adaptador convierte una pieza cuadrada en una pieza redonda.
+class SquarePegAdapter extends RoundPeg is
+    private field peg: SquarePeg
+
+    constructor SquarePegAdapter(peg: SquarePeg) is
+        this.peg = peg
+
+    method getRadius() is
+        return peg.getWidth() * Math.sqrt(2) / 2
+
+// Cliente que utiliza el adaptador para encajar piezas cuadradas en agujeros redondos.
+hole = new RoundHole(5)
+rpeg = new RoundPeg(5)
+hole.fits(rpeg) // verdadero
+
+small_sqpeg = new SquarePeg(5)
+large_sqpeg = new SquarePeg(10)
+small_sqpeg_adapter = new SquarePegAdapter(small_sqpeg)
+large_sqpeg_adapter = new SquarePegAdapter(large_sqpeg)
+hole.fits(small_sqpeg_adapter) // verdadero
+hole.fits(large_sqpeg_adapter) // falso
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando se necesita usar una clase existente cuya interfaz no es compatible con el resto del sistema.
    • +
  • Cuando se quiere reutilizar una clase de una biblioteca externa sin modificar su código.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crear una interfaz común que defina los métodos que el cliente necesita usar.
    • +
  • Implementar una clase adaptadora que envuelva la clase de servicio y convierta su interfaz a la interfaz común.
    • +
  • Utilizar el adaptador en lugar de la clase de servicio en el código cliente.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Permite la reutilización de clases con interfaces incompatibles y mantiene el código cliente limpio.
    • +
  • Contras: La complejidad aumenta, ya que se debe crear una nueva clase adaptadora para cada tipo de objeto incompatible.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Facade: Facade simplifica el acceso a un subsistema complejo, mientras que Adapter adapta interfaces para permitir su uso.
    • +
  • Decorator: Ambos patrones agregan funcionalidad a los objetos, pero Adapter cambia la interfaz mientras que Decorator mantiene la misma.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales-Bridge.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales-Bridge.php" new file mode 100644 index 00000000..4d276596 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales-Bridge.php" @@ -0,0 +1,201 @@ + + + + + + + + Patrón Bridge + + + + + +
+

Patrón Bridge (Puente)

+ +
+
Propósito
+

El patrón Bridge es un patrón de diseño estructural que permite dividir una clase grande, o un conjunto de clases relacionadas, en dos jerarquías separadas (abstracción e implementación) que pueden desarrollarse de manera independiente.

+
+ +
+
Problema
+

Si tienes una clase geométrica como "Forma" con subclases como "Círculo" y "Cuadrado", y luego quieres agregar un nuevo atributo como "Color", el número de combinaciones de clases crece exponencialmente. Por ejemplo, para agregar el color "Rojo" y "Azul", necesitarías crear combinaciones como "CírculoRojo" y "CuadradoAzul". Esto se vuelve problemático a medida que aumentan las combinaciones.

+
+ +
+
Solución
+

El patrón Bridge resuelve este problema separando las dimensiones del problema en dos jerarquías de clases: una para la forma y otra para el color. Así, la clase "Forma" tiene una referencia a un objeto de la jerarquía "Color" y delega el trabajo relacionado con el color. Esto elimina la explosión de clases combinadas y facilita la extensión de la jerarquía sin generar combinaciones innecesarias.

+
+ +
+
Analogía en el mundo real
+

Imagina una aplicación de interfaz gráfica que debe funcionar en varios sistemas operativos, como Windows, Linux y macOS. El patrón Bridge permite que el código de la interfaz (abstracción) y el código del sistema operativo (implementación) estén separados. Así, puedes cambiar la interfaz gráfica o la implementación sin afectar la otra parte del sistema.

+
+ +
+
Estructura
+
    +
  • Abstracción: La capa de control de alto nivel que delega el trabajo a la implementación.
    • +
  • Implementación: Declara la interfaz común para todas las implementaciones concretas.
    • +
  • Implementaciones Concretas: Contienen código específico de la plataforma.
    • +
  • Abstracción Refinada: Variantes de lógica de control que trabajan con diferentes implementaciones.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// La "abstracción" define la interfaz para el control
+// de las dos jerarquías de clase. Mantiene una referencia
+// a un objeto de la jerarquía de "implementación" y delega
+// el trabajo real a este objeto.
+class RemoteControl is
+    protected field device: Device
+    constructor RemoteControl(device: Device) is
+        this.device = device
+    method togglePower() is
+        if (device.isEnabled()) then
+            device.disable()
+        else
+            device.enable()
+    method volumeDown() is
+        device.setVolume(device.getVolume() - 10)
+    method volumeUp() is
+        device.setVolume(device.getVolume() + 10)
+    method channelDown() is
+        device.setChannel(device.getChannel() - 1)
+    method channelUp() is
+        device.setChannel(device.getChannel() + 1)
+
+
+// Se pueden extender clases de la jerarquía de abstracción
+// independientemente de las clases de dispositivo.
+class AdvancedRemoteControl extends RemoteControl is
+    method mute() is
+        device.setVolume(0)
+
+
+// La interfaz de "implementación" declara métodos comunes a
+// todas las clases concretas de implementación.
+interface Device is
+    method isEnabled()
+    method enable()
+    method disable()
+    method getVolume()
+    method setVolume(percent)
+    method getChannel()
+    method setChannel(channel)
+
+// Los dispositivos siguen la misma interfaz.
+class Tv implements Device is
+    // ...
+
+class Radio implements Device is
+    // ...
+
+// En el código cliente:
+tv = new Tv()
+remote = new RemoteControl(tv)
+remote.togglePower()
+
+radio = new Radio()
+remote = new AdvancedRemoteControl(radio)
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando necesitas dividir y organizar una clase monolítica que tenga muchas variantes de una sola funcionalidad.
    • +
  • Cuando una clase se vuelve difícil de manejar debido a la necesidad de añadir nuevas variantes o combinaciones de funcionalidades.
    • +
  • Cuando deseas extender una clase en varias dimensiones ortogonales e independientes.
    • +
  • Cuando necesitas cambiar implementaciones en tiempo de ejecución sin modificar la abstracción.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Identifica las dimensiones ortogonales de tus clases y extráelas en jerarquías separadas.
    • +
  • Define las operaciones necesarias en la clase base de abstracción.
    • +
  • Declara las operaciones comunes en la interfaz de implementación.
    • +
  • Desarrolla las clases de implementación para cada plataforma o tipo de dispositivo, asegurándote de que todas sigan la misma interfaz.
    • +
  • En la clase de abstracción, añade una referencia al objeto de implementación y delega la mayoría del trabajo al objeto de implementación.
    • +
  • El código cliente vincula la abstracción con la implementación, y luego trabaja únicamente con la abstracción.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Facilita el cambio y extensión de clases sin afectar el código existente, permite el desarrollo independiente de diferentes jerarquías de clases, y soporta el principio de abierto/cerrado.
    • +
  • Contras: La complejidad puede aumentar si la clase original es muy cohesionada o si no se identifican bien las dimensiones ortogonales.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Adapter: Adapter conecta clases incompatibles, mientras que Bridge divide una clase monolítica en jerarquías separadas y relacionadas.
    • +
  • Strategy: Ambos patrones utilizan la composición y delegación, pero Bridge se utiliza cuando existen dimensiones ortogonales, mientras que Strategy define una única familia de algoritmos.
    • +
  • Abstract Factory: Abstract Factory puede complementar Bridge cuando se necesita encapsular la relación entre abstracción e implementación.
    • +
  • Builder: Bridge y Builder pueden combinarse cuando diferentes constructores crean distintas implementaciones para una abstracción.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales-Composite.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales-Composite.php" new file mode 100644 index 00000000..f7630a25 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales-Composite.php" @@ -0,0 +1,178 @@ + + + + + + + + Patrón Composite + + + + + +
+

Patrón Composite

+ +
+
Propósito
+

El patrón Composite es un patrón de diseño estructural que permite tratar de manera uniforme objetos individuales y composiciones de objetos. Se utiliza para representar jerarquías de objetos, como árboles, donde los objetos pueden ser hojas (objetos simples) o nodos (composiciones de objetos).

+
+ +
+
Problema
+

Cuando necesitas representar jerarquías de objetos y deseas tratar los objetos individuales y las composiciones de la misma manera. Sin el patrón Composite, es difícil tratar a un objeto compuesto de la misma forma que un objeto simple, lo que lleva a un código repetitivo y difícil de mantener.

+
+ +
+
Solución
+

El patrón Composite resuelve este problema permitiendo que los objetos individuales y los compuestos de objetos implementen una interfaz común. De esta forma, tanto las hojas como los nodos pueden ser tratados de manera uniforme.

+
+ +
+
Analogía en el mundo real
+

Imagina una organización jerárquica dentro de una empresa, donde tienes a los empleados (hojas) y los directores (nodos) que supervisan a varios empleados. Ambos, empleados y directores, pueden ser tratados como miembros de la organización, aunque uno sea una persona y el otro un grupo de personas.

+
+ +
+
Estructura
+
    +
  • Componente: Define la interfaz común para objetos individuales y compuestos. Los métodos pueden ser abstractos o definidos según lo que compartan los objetos.
    • +
  • Hoja: Representa los objetos simples que no tienen componentes hijos. Implementan la interfaz de Componente y definen la funcionalidad de las hojas.
    • +
  • Composición (Composite): Representa los objetos compuestos, que tienen hijos y delegan las operaciones a los mismos. Implementa la interfaz de Componente y contiene una colección de hijos.
    • +
  • Cliente: Interactúa con los objetos de forma uniforme, sin preocuparse de si el objeto es una hoja o una composición.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Componente: Define la interfaz común para todas las clases
+interface Componente {
+    method operar(): void;
+}
+
+// Hoja: Representa objetos simples
+class Hoja implements Componente {
+    method operar() {
+        print("Operación en hoja");
+    }
+}
+
+// Composición: Representa objetos compuestos
+class Composicion implements Componente {
+    protected componentes: List = []
+
+    method agregar(component: Componente) {
+        this.componentes.add(component);
+    }
+
+    method operar() {
+        for each componente in componentes {
+            componente.operar();
+        }
+    }
+}
+
+// Uso del Composite:
+hoja1 = new Hoja()
+hoja2 = new Hoja()
+composicion = new Composicion()
+
+composicion.agregar(hoja1)
+composicion.agregar(hoja2)
+
+composicion.operar() // Llama a la operación en ambas hojas
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando tienes objetos que forman una jerarquía y deseas tratarlos de manera uniforme.
    • +
  • Cuando necesitas tratar a los objetos compuestos y a los objetos simples de la misma manera sin tener que diferenciarlos.
    • +
  • Cuando un sistema necesita manejar jerarquías y la composición de objetos es algo fundamental.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Define una interfaz común para los objetos de la jerarquía (hojas y composiciones).
    • +
  • Implementa las hojas como clases que contienen operaciones simples.
    • +
  • Implementa las composiciones como clases que contienen una colección de componentes y delegan las operaciones a ellos.
    • +
  • En el cliente, usa la interfaz común para interactuar con los objetos, sin preocuparte si son hojas o composiciones.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Simplifica el código cliente al tratar objetos simples y compuestos de la misma manera, facilita la adición de nuevos tipos de objetos sin modificar el cliente.
    • +
  • Contras: Puede hacer que el diseño sea más complejo, especialmente cuando la jerarquía se vuelve muy profunda o cuando es difícil identificar los componentes.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Decorator: Ambos patrones permiten agregar funcionalidad a un objeto, pero Composite se enfoca en la creación de jerarquías y relaciones entre objetos, mientras que Decorator se enfoca en la adición de funcionalidades a un solo objeto.
    • +
  • Flyweight: Flyweight se usa para compartir objetos en lugar de crear nuevos, mientras que Composite crea una estructura jerárquica, a menudo con objetos únicos que no se comparten.
    • +
  • Iterator: Composite puede utilizar un iterador para recorrer la jerarquía de objetos y aplicar operaciones a cada componente, mientras que Iterator es un patrón para acceder secuencialmente a los elementos de una colección.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales-Decorator.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales-Decorator.php" new file mode 100644 index 00000000..1b37c552 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales-Decorator.php" @@ -0,0 +1,10 @@ + + +.title-summary { + font-size: 1.5rem; + color: #e74c3c; + margin-bottom: 20px; + } \ No newline at end of file diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales-Facade.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales-Facade.php" new file mode 100644 index 00000000..478205f4 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales-Facade.php" @@ -0,0 +1,164 @@ + + + + + + + + Patrón Facade + + + + + +
+
Patrón Facade
+ +
+
Propósito
+

El patrón Facade es un patrón estructural que proporciona una interfaz simplificada a un subsistema complejo. Facilita la integración con bibliotecas o marcos sofisticados, proporcionando un acceso directo y reducido a las funcionalidades esenciales.

+
+ +
+
Problema
+

Trabajar directamente con un subsistema complejo puede hacer que el código se vuelva difícil de mantener y entender, ya que se debe gestionar la interacción entre muchos objetos y sus dependencias.

+
+ +
+
Solución
+

El patrón Facade oculta la complejidad del subsistema, proporcionando una interfaz sencilla que solo expone las funciones realmente necesarias para el cliente, sin necesidad de interactuar con la implementación interna.

+
+ +
+
Analogía en el mundo real
+

Imagina hacer un pedido telefónico en una tienda. El operador es una fachada que facilita el acceso a varios departamentos sin que el cliente tenga que interactuar con cada uno de ellos.

+
+ +
+
Estructura
+
    +
  • Fachada: Proporciona una interfaz simplificada para interactuar con el subsistema.
    • +
  • Subsistema: Un conjunto de clases complejas que realizan tareas específicas, que quedan ocultas detrás de la fachada.
    • +
  • Cliente: Utiliza la fachada para interactuar con el subsistema, sin conocer su complejidad interna.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Ejemplo de código de una fachada para un framework de conversión de vídeo
+class VideoConverter {
+    method convert(filename, format) {
+        videoFile = new VideoFile(filename)
+        codec = new CodecFactory().extract(videoFile)
+        if (format == "mp4") 
+            destinationCodec = new MPEG4Codec()
+        else 
+            destinationCodec = new OggCodec()
+        buffer = BitrateReader.read(videoFile, codec)
+        result = BitrateReader.convert(buffer, destinationCodec)
+        finalResult = AudioMixer.fix(result)
+        return new File(finalResult)
+    }
+}
+
+// El cliente solo interactúa con la fachada, sin preocuparse de los detalles
+class Application {
+    method main() {
+        converter = new VideoConverter()
+        file = converter.convert("funny-cats-video.ogg", "mp4")
+        file.save()
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando necesitas una interfaz simplificada a un subsistema complejo.
    • +
  • Para desacoplar el cliente de la complejidad del subsistema.
    • +
  • Cuando se requieren múltiples fachadas para gestionar subsistemas complejos y facilitar la interacción entre capas del sistema.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crea una clase fachada que proporcione una interfaz simple.
    • +
  • Encapsula las complejidades del subsistema dentro de esta fachada.
    • +
  • Haz que todo el código cliente interactúe solo con la fachada, ocultando la lógica interna del subsistema.
    • +
  • Si la fachada se vuelve muy compleja, considera dividirla en fachadas adicionales especializadas.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Facilita el acceso a subsistemas complejos, mejora la mantenibilidad y desacopla al cliente de la lógica interna del subsistema.
    • +
  • Contras: La fachada puede convertirse en un objeto todopoderoso que gestione demasiadas responsabilidades, lo que podría complicar su mantenimiento.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Adapter: Ambos patrones proporcionan una interfaz diferente, pero Facade simplifica el acceso a un subsistema completo, mientras que Adapter adapta la interfaz de un solo objeto.
    • +
  • Proxy: Ambos patrones pueden actuar como intermediarios, pero Proxy tiene la misma interfaz que el objeto que envuelve, mientras que Facade tiene una interfaz simplificada para un subsistema completo.
    • +
  • Mediator: Aunque ambos patrones coordinan la interacción entre clases, Mediator centraliza la comunicación, mientras que Facade simplifica el acceso a un subsistema sin cambiar la interacción interna.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales-Flyweight.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales-Flyweight.php" new file mode 100644 index 00000000..3b7daff4 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales-Flyweight.php" @@ -0,0 +1,197 @@ + + + + + + + + Patrón Flyweight + + + + + +
+
Patrón Flyweight
+ +
+
Propósito
+

El patrón Flyweight es un patrón estructural que permite reducir el uso de memoria al compartir la mayor cantidad de datos posible entre objetos similares. Es ideal cuando se necesita manejar grandes cantidades de objetos, pero algunos de estos comparten muchas características comunes.

+
+ +
+
Problema
+

En aplicaciones con muchos objetos similares, como un juego con partículas (balas, misiles, explosiones), la cantidad de memoria utilizada puede ser excesiva, ya que cada objeto podría tener la misma información almacenada repetidamente.

+
+ +
+
Solución
+

Flyweight ofrece la solución de separar el estado intrínseco (información común como color, textura, etc.) del estado extrínseco (información que cambia constantemente, como la posición o la velocidad). Los objetos compartidos se almacenan una sola vez, mientras que los datos que cambian se pasan como parámetros.

+
+ +
+
Analogía en el mundo real
+

Imagina que estás jugando un juego de disparos en una computadora. En lugar de crear una nueva imagen para cada bala disparada, el sistema usa una sola instancia de un objeto de bala, y solo cambia su posición en la pantalla.

+
+ +
+
Estructura
+
    +
  • Flyweight: Es el objeto que contiene el estado intrínseco compartido entre muchas instancias de objetos similares.
    • +
  • Contexto: Contiene el estado extrínseco de los objetos, como la posición o la velocidad.
    • +
  • Fábrica de Flyweights: Gestiona y reutiliza los objetos Flyweight, asegurando que se comparta el estado intrínseco entre las instancias.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// Ejemplo de un patrón Flyweight para un juego de disparos
+class BalaFlyweight {
+    private String color;
+    private String sprite; // Este es el estado intrínseco
+
+    // Constructor de Flyweight
+    public BalaFlyweight(String color, String sprite) {
+        this.color = color;
+        this.sprite = sprite;
+    }
+
+    public void mostrar(Contexto contexto) {
+        // El estado extrínseco (posición, velocidad) se pasa aquí
+        System.out.println("Bala de color " + color + " en " + contexto.getPosicion());
+    }
+}
+
+// Clase Contexto
+class Contexto {
+    private String posicion;
+    private String velocidad;
+
+    public Contexto(String posicion, String velocidad) {
+        this.posicion = posicion;
+        this.velocidad = velocidad;
+    }
+
+    public String getPosicion() {
+        return posicion;
+    }
+
+    public String getVelocidad() {
+        return velocidad;
+    }
+}
+
+// Fábrica de Flyweights
+class FábricaDeBalas {
+    private Map flyweights = new HashMap<>();
+
+    public BalaFlyweight obtenerFlyweight(String color) {
+        if (!flyweights.containsKey(color)) {
+            flyweights.put(color, new BalaFlyweight(color, "default-sprite"));
+        }
+        return flyweights.get(color);
+    }
+}
+
+// El cliente interactúa con el Flyweight
+class Juego {
+    public void jugar() {
+        FábricaDeBalas fabrica = new FábricaDeBalas();
+        Contexto contexto = new Contexto("Posición1", "Rápida");
+        
+        BalaFlyweight bala = fabrica.obtenerFlyweight("Rojo");
+        bala.mostrar(contexto);
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Cuando se necesita crear muchos objetos similares con grandes cantidades de datos compartidos.
    • +
  • Cuando se desea optimizar el uso de memoria, manteniendo solo una copia de los datos comunes.
    • +
  • En sistemas donde el rendimiento es crítico y hay una alta frecuencia de creación de objetos pequeños.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crea clases para los objetos Flyweight, separando el estado intrínseco (común) del estado extrínseco (cambiable).
    • +
  • Usa una fábrica para manejar la creación y reutilización de Flyweights, asegurándote de que los objetos comunes se compartan.
    • +
  • Al utilizar un Flyweight, pasa el estado extrínseco como parámetros de método, sin almacenar estos datos en el objeto Flyweight.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Reduce el uso de memoria, mejora el rendimiento, y evita la creación innecesaria de objetos duplicados.
    • +
  • Contras: Puede complicar el diseño, especialmente en sistemas donde los estados extrínsecos cambian frecuentemente.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Abstract Factory: Ambos patrones se utilizan para crear familias de objetos, pero Flyweight optimiza la memoria reutilizando instancias existentes.
    • +
  • Prototype: Mientras que Prototype crea una copia de un objeto, Flyweight crea un solo objeto compartido para ser reutilizado.
    • +
  • Decorator: Aunque Decorator se utiliza para añadir funcionalidad a los objetos, Flyweight se enfoca en compartir el estado común entre los objetos.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales-Proxy.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales-Proxy.php" new file mode 100644 index 00000000..99b659b4 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales-Proxy.php" @@ -0,0 +1,231 @@ + + + + + + + + Patrón Proxy + + + + + +
+
Patrón Proxy
+ +
+
Propósito
+

Proxy es un patrón de diseño estructural que te permite proporcionar un sustituto o marcador de posición para otro objeto. Un proxy controla el acceso al objeto original, permitiéndote hacer algo antes o después de que la solicitud llegue al objeto original.

+
+ +
+
Problema
+

¿Por qué querrías controlar el acceso a un objeto? Imagina que tienes un objeto enorme que consume una gran cantidad de recursos del sistema. Lo necesitas de vez en cuando, pero no siempre.

+

Las consultas a las bases de datos pueden ser muy lentas. Puedes llevar a cabo una implementación diferida, es decir, crear este objeto sólo cuando sea realmente necesario.

+

En un mundo ideal, querríamos meter este código directamente dentro de la clase de nuestro objeto, pero eso no siempre es posible. Por ejemplo, la clase puede ser parte de una biblioteca cerrada de un tercero.

+
+ +
+
Solución
+

El patrón Proxy sugiere que crees una nueva clase proxy con la misma interfaz que un objeto de servicio original. Después actualizas tu aplicación para que pase el objeto proxy a todos los clientes del objeto original. Al recibir una solicitud de un cliente, el proxy crea un objeto de servicio real y le delega todo el trabajo.

+

El proxy se camufla como objeto de la base de datos. Puede gestionar la inicialización diferida y el caché de resultados sin que el cliente o el objeto real de la base de datos lo sepan.

+

Si necesitas ejecutar algo antes o después de la lógica primaria de la clase, el proxy te permite hacerlo sin cambiar esa clase. Ya que el proxy implementa la misma interfaz que la clase original, puede pasarse a cualquier cliente que espere un objeto de servicio real.

+
+ +
+
Analogía en el mundo real
+

Una tarjeta de crédito es un proxy de un manojo de billetes. Las tarjetas de crédito pueden utilizarse para realizar pagos tanto como el efectivo.

+

Una tarjeta de crédito es un proxy de una cuenta bancaria, que, a su vez, es un proxy de un manojo de billetes. Ambos implementan la misma interfaz, por lo que pueden utilizarse para realizar un pago.

+

El consumidor se siente genial porque no necesita llevar un montón de efectivo encima. El dueño de la tienda también está contento porque los ingresos de la transacción se añaden electrónicamente a la cuenta bancaria de la tienda sin el riesgo de perder el depósito o sufrir un robo de camino al banco.

+
+ +
+
Estructura
+
    +
  • Interfaz de Servicio: Declara la interfaz del servicio que el proxy debe seguir.
    • +
  • Servicio: Es una clase que proporciona la lógica de negocio útil.
    • +
  • Proxy: Tiene un campo de referencia que apunta a un objeto de servicio y delega el trabajo cuando es necesario.
    • +
  • Cliente: Utiliza el servicio o el proxy a través de la misma interfaz, sin importar cuál se utilice.
    • +
+
+ +
+
Pseudocódigo
+
+ 
+// La interfaz de un servicio remoto
+interface ThirdPartyYouTubeLib {
+    method listVideos()
+    method getVideoInfo(id)
+    method downloadVideo(id)
+}
+
+// La implementación concreta de un conector de servicio.
+class ThirdPartyYouTubeClass implements ThirdPartyYouTubeLib {
+    method listVideos() {
+        // Envía una solicitud API a YouTube
+    }
+    method getVideoInfo(id) {
+        // Obtiene metadatos de algún video
+    }
+    method downloadVideo(id) {
+        // Descarga un archivo de video de YouTube
+    }
+}
+
+// El proxy para gestionar el almacenamiento en caché
+class CachedYouTubeClass implements ThirdPartyYouTubeLib {
+    private field service: ThirdPartyYouTubeLib
+    private field listCache, videoCache
+    private field needReset
+
+    constructor CachedYouTubeClass(service: ThirdPartyYouTubeLib) {
+        this.service = service
+    }
+
+    method listVideos() {
+        if (listCache == null || needReset)
+            listCache = service.listVideos()
+        return listCache
+    }
+
+    method getVideoInfo(id) {
+        if (videoCache == null || needReset)
+            videoCache = service.getVideoInfo(id)
+        return videoCache
+    }
+
+    method downloadVideo(id) {
+        if (!downloadExists(id) || needReset)
+            service.downloadVideo(id)
+    }
+}
+
+// La clase GUI que usa el proxy
+class YouTubeManager {
+    protected field service: ThirdPartyYouTubeLib
+
+    constructor YouTubeManager(service: ThirdPartyYouTubeLib) {
+        this.service = service
+    }
+
+    method renderVideoPage(id) {
+        info = service.getVideoInfo(id)
+        // Representa la página del video.
+    }
+
+    method renderListPanel() {
+        list = service.listVideos()
+        // Representa la lista de miniaturas de los videos.
+    }
+
+    method reactOnUserInput() {
+        renderVideoPage()
+        renderListPanel()
+    }
+}
+
+// La aplicación puede configurar proxies sobre la marcha
+class Application {
+    method init() {
+        aYouTubeService = new ThirdPartyYouTubeClass()
+        aYouTubeProxy = new CachedYouTubeClass(aYouTubeService)
+        manager = new YouTubeManager(aYouTubeProxy)
+        manager.reactOnUserInput()
+    }
+}
+
+
+
+ +
+
Aplicabilidad
+
    +
  • Inicialización diferida (proxy virtual): Para objetos pesados que consumen muchos recursos solo cuando se necesitan.
    • +
  • Control de acceso (proxy de protección): Limitar el acceso solo a ciertos clientes según las credenciales.
    • +
  • Ejecución local de un servicio remoto (proxy remoto): Gestionar solicitudes a un servicio en un servidor remoto.
    • +
  • Solicitudes de registro (proxy de registro): Registrar las solicitudes al objeto de servicio.
    • +
  • Resultados de solicitudes en caché (proxy de caché): Gestionar el ciclo de vida del caché para evitar solicitudes repetitivas.
    • +
  • Referencia inteligente: El proxy puede controlar la vida útil de un objeto pesado, liberando recursos cuando ya no se usa.
    • +
+
+ +
+
Cómo implementarlo
+
    +
  • Crea una interfaz de servicio si no existe una para hacer intercambiables los objetos proxy y servicio.
    • +
  • Crea la clase proxy que administre el ciclo de vida del objeto de servicio.
    • +
  • Implementa los métodos del proxy según su propósito, delegando el trabajo cuando sea necesario.
    • +
  • Considera usar la inicialización diferida para mejorar el rendimiento.
    • +
+
+ +
+
Pros y Contras
+
    +
  • Pros: Permite controlar el acceso a un objeto sin que los clientes lo sepan, y gestiona su ciclo de vida sin intervención.
    • +
  • Contras: Puede complicar el código con muchas clases adicionales y retrasar la respuesta del servicio.
    • +
+
+ +
+
Relaciones con otros patrones
+
    +
  • Adapter: Ambos patrones proporcionan acceso a objetos a través de una interfaz diferente, pero Proxy mantiene la misma interfaz del servicio.
    • +
  • Decorator: Ambos basados en la composición, pero Proxy gestiona el ciclo de vida de su servicio, mientras que Decorator lo hace el cliente.
    • +
  • Facade: Similar en que ambos pueden inicializar un objeto complejos, pero Proxy mantiene la misma interfaz del objeto de servicio.
    • +
+
+ +
+ + + + diff --git "a/practicas/patrones de dise\303\261o/patrones/estructurales.php" "b/practicas/patrones de dise\303\261o/patrones/estructurales.php" new file mode 100644 index 00000000..856abfd2 --- /dev/null +++ "b/practicas/patrones de dise\303\261o/patrones/estructurales.php" @@ -0,0 +1,141 @@ + + + + + + + + Patrones Estructurales + + + + +
+
+
+

Patrones Estructurales

+

Los patrones estructurales explican cómo ensamblar objetos y clases en estructuras más grandes, a la vez que se mantiene la flexibilidad y eficiencia de estas estructuras.

+ + + +
+
Adapter
+

Permite la colaboración entre objetos con interfaces incompatibles.

+ Ver más +
+ +
+
Bridge
+

Permite dividir una clase grande o un grupo de clases estrechamente relacionadas, en dos jerarquías separadas (abstracción e implementación) que pueden desarrollarse independientemente la una de la otra.

+ Ver más +
+ +
+
Composite
+

Permite componer objetos en estructuras de árbol y trabajar con esas estructuras como si fueran objetos individuales.

+ Ver más +
+ +
+
Decorator
+

Permite añadir funcionalidades a objetos colocando estos objetos dentro de objetos encapsuladores especiales que contienen estas funcionalidades.

+ Ver más +
+ +
+
Facade
+

Proporciona una interfaz simplificada a una biblioteca, un framework o cualquier otro grupo complejo de clases.

+ Ver más +
+ +
+
Flyweight
+

Permite mantener más objetos dentro de la cantidad disponible de memoria RAM compartiendo las partes comunes del estado entre varios objetos en lugar de mantener toda la información en cada objeto.

+ Ver más +
+ +
+
Proxy
+

Permite proporcionar un sustituto o marcador de posición para otro objeto. Un proxy controla el acceso al objeto original, permitiéndote hacer algo antes o después de que la solicitud llegue al objeto original.

+ Ver más +
+ +
+
+
+ + + + diff --git a/practicas/practica b/practicas/practica new file mode 100644 index 00000000..e69de29b diff --git a/practicas/practica POO 1/ejercicio1.php b/practicas/practica POO 1/ejercicio1.php new file mode 100644 index 00000000..9e40cf51 --- /dev/null +++ b/practicas/practica POO 1/ejercicio1.php @@ -0,0 +1,24 @@ +titol = $titol; + $this->autor = $autor; + } + public function descripcion() + { + return "El libro '$this->titol' ha estado escrito por '$this->autor'"; + } +} + +$libro = new Llibre("Libro", "Yo"); +$libro2 = new Llibre(); + +echo $libro->descripcion(); +echo $libro2->descripcion(); diff --git a/practicas/practica POO 1/ejercicio10.php b/practicas/practica POO 1/ejercicio10.php new file mode 100644 index 00000000..04ea359d --- /dev/null +++ b/practicas/practica POO 1/ejercicio10.php @@ -0,0 +1,63 @@ +nombre = $nombre; + $this->tipo = $tipo; + } + + public function describir() + { + return "L'animal és un " . $this->tipo . " anomenat " . $this->nombre . "."; + } +} + +if ($_SERVER["REQUEST_METHOD"] == "POST") { + $nombre = $_POST['nombre']; + $tipo = $_POST['tipo']; + + $animal = new Animal($nombre, $tipo); + $descripcio = $animal->describir(); +} + +?> + + + + + + + + Descripció d'Animal + + + + +

Formulari per descriure un Animal

+ +
+ +

+ + +

+ + +
+ + Descripció:"; + echo "

" . $descripcio . "

"; + } + ?> + + + + \ No newline at end of file diff --git a/practicas/practica POO 1/ejercicio2.php b/practicas/practica POO 1/ejercicio2.php new file mode 100644 index 00000000..c64a976b --- /dev/null +++ b/practicas/practica POO 1/ejercicio2.php @@ -0,0 +1,19 @@ +titol' y el autor es '$this->autor'"; + } +} + +$libro = new Llibre(); + +echo $libro->descr(); + +?> diff --git a/practicas/practica POO 1/ejercicio3.php b/practicas/practica POO 1/ejercicio3.php new file mode 100644 index 00000000..76c4d354 --- /dev/null +++ b/practicas/practica POO 1/ejercicio3.php @@ -0,0 +1,24 @@ +titulo = $titulo; + $this->autor = $autor; + } + + public function info() + { + return "El libro hecho por $this->autor y se llama $this->titulo"; + } +} + +$informacion = new Libro("Yoquese", "Yo"); + +echo $informacion->info(); diff --git a/practicas/practica POO 1/ejercicio4.php b/practicas/practica POO 1/ejercicio4.php new file mode 100644 index 00000000..a3961cfd --- /dev/null +++ b/practicas/practica POO 1/ejercicio4.php @@ -0,0 +1,24 @@ +titulo = $titulo; + $this->autor = $autor; + } + + public function info() + { + return "El libro hecho por $this->autor y se llama $this->titulo"; + } +} + +$informacion = new Libro("Yoquese", "Yo"); + +echo $informacion->info(); diff --git a/practicas/practica POO 1/ejercicio5.php b/practicas/practica POO 1/ejercicio5.php new file mode 100644 index 00000000..8cf0bd8a --- /dev/null +++ b/practicas/practica POO 1/ejercicio5.php @@ -0,0 +1,23 @@ +nombre = $nombre; + $this->edad = $edad; + } + + public function saludar() + { + return "Hola soy $this->nombre y tengo $this->edad años"; + } +} + +$saludar = new Persona("Anna", 25); +echo $saludar->saludar(); diff --git a/practicas/practica POO 1/ejercicio6.php b/practicas/practica POO 1/ejercicio6.php new file mode 100644 index 00000000..1c162616 --- /dev/null +++ b/practicas/practica POO 1/ejercicio6.php @@ -0,0 +1,50 @@ +nombre = $nombre; + $this->edad = $edad; + } +} + +if ($_SERVER["REQUEST_METHOD"] == "POST") { + $nombre = $_POST['nombre']; + $edad = $_POST['edad']; + + $persona = new Persona($nombre, $edad); + + echo "

Detalles de la persona:

"; + echo "Nombre: " . $persona->nombre . "
"; + echo "Edad: " . $persona->edad . "
"; +} +?> + + + + + + + + Ejercicio6 + + + +

Formulario de Persona

+
+ +

+ + +

+ + +
+ + + \ No newline at end of file diff --git a/practicas/practica POO 1/ejercicio7.php b/practicas/practica POO 1/ejercicio7.php new file mode 100644 index 00000000..e3ee7cd3 --- /dev/null +++ b/practicas/practica POO 1/ejercicio7.php @@ -0,0 +1,27 @@ +nombre = $nombre; + $this->precio = $precio; + } + + + + public function mostrarPrecio() + { + + echo 'El producto es ' . $this->nombre . ' y cuesta ' . $this->precio . ' €'; + } +} + +$producto1 = new Producto("Camiseta", 20); + +$producto1->mostrarPrecio(); diff --git a/practicas/practica POO 1/ejercicio8.php b/practicas/practica POO 1/ejercicio8.php new file mode 100644 index 00000000..37efb020 --- /dev/null +++ b/practicas/practica POO 1/ejercicio8.php @@ -0,0 +1,45 @@ +primerNum = $primerNum; + $this->segundoNum = $segundoNum; + } + + public function sumar() + { + return $this->primerNum + $this->segundoNum; + } + + public function restar() + { + return $this->primerNum - $this->segundoNum; + } + + public function multiplicar() + { + return $this->primerNum * $this->segundoNum; + } + + public function dividir() + { + return $this->primerNum / $this->segundoNum; + } + + public function calcular() + { + echo "Suma: " . $this->sumar() . "
"; + echo "Resta: " . $this->restar() . "
"; + echo "Multiplicación: " . $this->multiplicar() . "
"; + echo "División: " . $this->dividir() . "
"; + } +} + +$calculadora = new Calculadora(6, 3); +$calculadora->calcular(); diff --git a/practicas/practica POO 1/ejercicio9.php b/practicas/practica POO 1/ejercicio9.php new file mode 100644 index 00000000..ad3ab821 --- /dev/null +++ b/practicas/practica POO 1/ejercicio9.php @@ -0,0 +1,71 @@ +nombre = $nombre; + $this->precio = $precio; + } + + public function getNombre() + { + return $this->nombre; + } + + public function getPrecio() + { + return $this->precio; + } +} + +// Crear algunos productos +$productos = [ + new Producto("Camiseta", 15.99), + new Producto("Portátil", 899.99), + new Producto("Zapatos", 49.99), + new Producto("Libro", 12.50), + new Producto("Auriculares", 89.99) +]; + +?> + + + + + + + + Tabla de Productos + + + + +

Lista de Productos

+ + + + + + + + + + + "; + echo ""; + echo ""; + echo ""; + } + ?> + +
NombrePrecioCategoría
" . $producto->getNombre() . "" . $producto->getPrecio() . " 2€
+ + + + \ No newline at end of file diff --git a/practicas/practica POO 2/ejercicio1.php b/practicas/practica POO 2/ejercicio1.php new file mode 100644 index 00000000..7c982ba7 --- /dev/null +++ b/practicas/practica POO 2/ejercicio1.php @@ -0,0 +1,25 @@ + + +marca = $marca; + $this->model = $model; + } + + public function descripcion() + { + return 'El coche es de marca ' . $this->marca . ' y su modelo es ' . $this->model; + } +} + +$coche = new Coche('Lada', 'Sedan'); + +echo $coche->descripcion(); +?> \ No newline at end of file diff --git a/practicas/practica POO 2/ejercicio10.php b/practicas/practica POO 2/ejercicio10.php new file mode 100644 index 00000000..8e482473 --- /dev/null +++ b/practicas/practica POO 2/ejercicio10.php @@ -0,0 +1,65 @@ +nombre = $nombre; + $this->precio = $precio; + } + + public function getNombre() + { + return $this->nombre; + } + + public function getPrecio() + { + return $this->precio; + } +} + +$productos = [ + new Producto("Fresas", 5.99), + new Producto("Móvil", 599.99), + new Producto("Chanclas", 9.99), + new Producto("Libreta", 3.50), + new Producto("Ratón", 39.99) +]; +?> + + + + + + + + Document + + + + + + + + + + + + "; + echo ""; + echo ""; + echo ""; + } + ?> + +
NombrePrecio
" . $producto->getNombre() . "" . $producto->getPrecio() . " €
+ + + \ No newline at end of file diff --git a/practicas/practica POO 2/ejercicio2.php b/practicas/practica POO 2/ejercicio2.php new file mode 100644 index 00000000..2d8f474c --- /dev/null +++ b/practicas/practica POO 2/ejercicio2.php @@ -0,0 +1,17 @@ +marca . ' y su modelo es ' . $this->model; + } +} + + +$coche = new Coche1(); +echo $coche->descripcion(); diff --git a/practicas/practica POO 2/ejercicio3.php b/practicas/practica POO 2/ejercicio3.php new file mode 100644 index 00000000..289f33cb --- /dev/null +++ b/practicas/practica POO 2/ejercicio3.php @@ -0,0 +1,24 @@ +nombre = $nombre; + $this->edad = $edad; + } + + public function mensaje() + { + echo "Bienvenido, " . $this->nombre . " tienes " . $this->edad; + } +} + + +$persona = new Persona('Juan', 23); + +$persona->mensaje(); diff --git a/practicas/practica POO 2/ejercicio4.php b/practicas/practica POO 2/ejercicio4.php new file mode 100644 index 00000000..b8d4ba89 --- /dev/null +++ b/practicas/practica POO 2/ejercicio4.php @@ -0,0 +1,24 @@ +nombre = $nombre; + $this->edad = $edad; + } + + public function mensaje() + { + echo "Bienvenido, " . $this->nombre . " tienes " . $this->edad; + } +} + + +$persona = new Persona('Juan', 23); + +$persona->mensaje(); diff --git a/practicas/practica POO 2/ejercicio5.php b/practicas/practica POO 2/ejercicio5.php new file mode 100644 index 00000000..7ec92333 --- /dev/null +++ b/practicas/practica POO 2/ejercicio5.php @@ -0,0 +1,29 @@ +nombre = $nombre; + $this->edad = $edad; + } + + public function mensaje() + { + return "Bienvenido, " . $this->nombre . ". Tienes " . $this->edad; + } +} + + +$persona1 = new Persona('Juan', 23); + +$persona2 = new Persona('Ana', 30); + +echo $persona1->mensaje() . "
"; +echo $persona2->mensaje(); diff --git a/practicas/practica POO 2/ejercicio6.php b/practicas/practica POO 2/ejercicio6.php new file mode 100644 index 00000000..7d4eef4d --- /dev/null +++ b/practicas/practica POO 2/ejercicio6.php @@ -0,0 +1,23 @@ +numero1 = $numero1; + $this->numero2 = $numero2; + } + + public function sumar() + { + echo 'la suma de ', $this->numero1, " y ", $this->numero2, " es ", $this->numero1 + $this->numero2; + } +} + +$suma = new Calculadora(3, 7); + +$suma->sumar(); diff --git a/practicas/practica POO 2/ejercicio7.php b/practicas/practica POO 2/ejercicio7.php new file mode 100644 index 00000000..475e6cca --- /dev/null +++ b/practicas/practica POO 2/ejercicio7.php @@ -0,0 +1,58 @@ +nombre = $nombre; + $this->edad = $edad; + } + + public function describir(): string + { + return "Hola, " . $this->nombre . ", tienes " . $this->edad . " años."; + } +} + +if ($_SERVER["REQUEST_METHOD"] == "POST") { + $nombre = $_POST['nombre']; + $edad = $_POST['edad']; + + $user = new User($nombre, $edad); + $descripcio = $user->describir(); +} +?> + + + + + + + + Formulario + + + +

Formulario de Usuario

+ +
+ +

+ + +

+ + +
+ + Descripció:"; + echo "

" . $descripcio . "

"; + } + ?> + + + \ No newline at end of file diff --git a/practicas/practica POO 2/ejercicio8.php b/practicas/practica POO 2/ejercicio8.php new file mode 100644 index 00000000..c559bc20 --- /dev/null +++ b/practicas/practica POO 2/ejercicio8.php @@ -0,0 +1,18 @@ +nombre . ' y es un ' . $this->tipo; + } +} + +$animal = new Animal1(); +$animal->nombre = 'Tigre'; +$animal->tipo = 'Felino'; + +echo $animal->describir(); diff --git a/practicas/practica POO 2/ejercicio9.php b/practicas/practica POO 2/ejercicio9.php new file mode 100644 index 00000000..fe5ddbe5 --- /dev/null +++ b/practicas/practica POO 2/ejercicio9.php @@ -0,0 +1,24 @@ +nombre = $nombre; + $this->tipo = $tipo; + } + + public function saludar() + { + echo 'Hola soy un ', $this->tipo, ' y me llamo ', $this->nombre; + } +} + +$animal = new Animal('Paloma', 'Pajaro'); + +$animal->saludar(); diff --git a/practicas/practica juego UNO/baraja.class.php b/practicas/practica juego UNO/baraja.class.php new file mode 100644 index 00000000..b197388f --- /dev/null +++ b/practicas/practica juego UNO/baraja.class.php @@ -0,0 +1,32 @@ +barajaCartas[]=new Carta($color,$i,$idCarta); + } + } + } + + public function mezclarBaraja(){ + shuffle($this->barajaCartas); + } + + public function pintarBaraja(){ + foreach($this->barajaCartas as $carta){ + echo $carta->pinta_carta_link(); + echo "
"; + } + } + + public function manoJugador(){ + + } +} + +?> \ No newline at end of file diff --git a/practicas/practica juego UNO/carta.class.php b/practicas/practica juego UNO/carta.class.php new file mode 100644 index 00000000..d13e7bf4 --- /dev/null +++ b/practicas/practica juego UNO/carta.class.php @@ -0,0 +1,25 @@ +palo = $palo; + $this->numero = $numero; + $this->index = $index; + } + + + public function pinta_carta() + { + return "{$this->numero} {$this->palo}"; + } + public function pinta_carta_link() + { + return "{$this->numero} {$this->palo} "; + } +} diff --git a/practicas/practica juego UNO/cartas_uno/0_blue.png b/practicas/practica juego UNO/cartas_uno/0_blue.png new file mode 100644 index 00000000..4fd3b3e1 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/0_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/0_green.png b/practicas/practica juego UNO/cartas_uno/0_green.png new file mode 100644 index 00000000..99b2676a Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/0_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/0_red.png b/practicas/practica juego UNO/cartas_uno/0_red.png new file mode 100644 index 00000000..8a8d2242 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/0_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/0_yellow.png b/practicas/practica juego UNO/cartas_uno/0_yellow.png new file mode 100644 index 00000000..cd7f9d14 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/0_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/1_blue.png b/practicas/practica juego UNO/cartas_uno/1_blue.png new file mode 100644 index 00000000..e82fd6ca Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/1_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/1_green.png b/practicas/practica juego UNO/cartas_uno/1_green.png new file mode 100644 index 00000000..1581f069 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/1_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/1_red.png b/practicas/practica juego UNO/cartas_uno/1_red.png new file mode 100644 index 00000000..c378080a Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/1_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/1_yellow.png b/practicas/practica juego UNO/cartas_uno/1_yellow.png new file mode 100644 index 00000000..2f01a37d Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/1_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/2_blue.png b/practicas/practica juego UNO/cartas_uno/2_blue.png new file mode 100644 index 00000000..a7229aff Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/2_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/2_green.png b/practicas/practica juego UNO/cartas_uno/2_green.png new file mode 100644 index 00000000..9895103f Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/2_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/2_red.png b/practicas/practica juego UNO/cartas_uno/2_red.png new file mode 100644 index 00000000..fae98ce8 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/2_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/2_yellow.png b/practicas/practica juego UNO/cartas_uno/2_yellow.png new file mode 100644 index 00000000..5511b56c Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/2_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/3_blue.png b/practicas/practica juego UNO/cartas_uno/3_blue.png new file mode 100644 index 00000000..b514a51d Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/3_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/3_green.png b/practicas/practica juego UNO/cartas_uno/3_green.png new file mode 100644 index 00000000..6a3edcb0 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/3_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/3_red.png b/practicas/practica juego UNO/cartas_uno/3_red.png new file mode 100644 index 00000000..14625d5a Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/3_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/3_yellow.png b/practicas/practica juego UNO/cartas_uno/3_yellow.png new file mode 100644 index 00000000..0849bd82 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/3_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/4_blue.png b/practicas/practica juego UNO/cartas_uno/4_blue.png new file mode 100644 index 00000000..7b0df903 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/4_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/4_green.png b/practicas/practica juego UNO/cartas_uno/4_green.png new file mode 100644 index 00000000..3ab9d7ee Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/4_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/4_red.png b/practicas/practica juego UNO/cartas_uno/4_red.png new file mode 100644 index 00000000..9878abca Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/4_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/4_yellow.png b/practicas/practica juego UNO/cartas_uno/4_yellow.png new file mode 100644 index 00000000..2b8b0cb9 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/4_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/5_blue.png b/practicas/practica juego UNO/cartas_uno/5_blue.png new file mode 100644 index 00000000..c5d87fe7 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/5_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/5_green.png b/practicas/practica juego UNO/cartas_uno/5_green.png new file mode 100644 index 00000000..6043fd75 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/5_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/5_red.png b/practicas/practica juego UNO/cartas_uno/5_red.png new file mode 100644 index 00000000..95c9e2c8 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/5_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/5_yellow.png b/practicas/practica juego UNO/cartas_uno/5_yellow.png new file mode 100644 index 00000000..426359de Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/5_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/6_blue.png b/practicas/practica juego UNO/cartas_uno/6_blue.png new file mode 100644 index 00000000..bff36f1b Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/6_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/6_green.png b/practicas/practica juego UNO/cartas_uno/6_green.png new file mode 100644 index 00000000..f4a10a0f Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/6_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/6_red.png b/practicas/practica juego UNO/cartas_uno/6_red.png new file mode 100644 index 00000000..f0f1503f Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/6_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/6_yellow.png b/practicas/practica juego UNO/cartas_uno/6_yellow.png new file mode 100644 index 00000000..4e271956 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/6_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/7_blue.png b/practicas/practica juego UNO/cartas_uno/7_blue.png new file mode 100644 index 00000000..ebea0934 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/7_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/7_green.png b/practicas/practica juego UNO/cartas_uno/7_green.png new file mode 100644 index 00000000..041a1c06 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/7_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/7_red.png b/practicas/practica juego UNO/cartas_uno/7_red.png new file mode 100644 index 00000000..3d5e42a6 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/7_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/7_yellow.png b/practicas/practica juego UNO/cartas_uno/7_yellow.png new file mode 100644 index 00000000..c95258b1 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/7_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/8_blue.png b/practicas/practica juego UNO/cartas_uno/8_blue.png new file mode 100644 index 00000000..95fa9fe3 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/8_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/8_green.png b/practicas/practica juego UNO/cartas_uno/8_green.png new file mode 100644 index 00000000..71dea9b5 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/8_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/8_red.png b/practicas/practica juego UNO/cartas_uno/8_red.png new file mode 100644 index 00000000..a0573840 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/8_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/8_yellow.png b/practicas/practica juego UNO/cartas_uno/8_yellow.png new file mode 100644 index 00000000..eaacabd9 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/8_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/9_blue.png b/practicas/practica juego UNO/cartas_uno/9_blue.png new file mode 100644 index 00000000..10a65851 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/9_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/9_green.png b/practicas/practica juego UNO/cartas_uno/9_green.png new file mode 100644 index 00000000..72ab7363 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/9_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/9_red.png b/practicas/practica juego UNO/cartas_uno/9_red.png new file mode 100644 index 00000000..e40942c3 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/9_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/9_yellow.png b/practicas/practica juego UNO/cartas_uno/9_yellow.png new file mode 100644 index 00000000..0b220add Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/9_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/carta_girada.png b/practicas/practica juego UNO/cartas_uno/carta_girada.png new file mode 100644 index 00000000..196f8611 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/carta_girada.png differ diff --git a/practicas/practica juego UNO/cartas_uno/color_changer.png b/practicas/practica juego UNO/cartas_uno/color_changer.png new file mode 100644 index 00000000..b77fecc6 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/color_changer.png differ diff --git a/practicas/practica juego UNO/cartas_uno/picker_blue.png b/practicas/practica juego UNO/cartas_uno/picker_blue.png new file mode 100644 index 00000000..e2963ba1 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/picker_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/picker_green.png b/practicas/practica juego UNO/cartas_uno/picker_green.png new file mode 100644 index 00000000..a6e5ca55 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/picker_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/picker_red.png b/practicas/practica juego UNO/cartas_uno/picker_red.png new file mode 100644 index 00000000..2ba3ad6c Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/picker_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/picker_yellow.png b/practicas/practica juego UNO/cartas_uno/picker_yellow.png new file mode 100644 index 00000000..cd24ea67 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/picker_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/reverse_blue.png b/practicas/practica juego UNO/cartas_uno/reverse_blue.png new file mode 100644 index 00000000..06ef9b0c Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/reverse_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/reverse_green.png b/practicas/practica juego UNO/cartas_uno/reverse_green.png new file mode 100644 index 00000000..0e7eb472 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/reverse_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/reverse_red.png b/practicas/practica juego UNO/cartas_uno/reverse_red.png new file mode 100644 index 00000000..75b57267 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/reverse_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/reverse_yellow.png b/practicas/practica juego UNO/cartas_uno/reverse_yellow.png new file mode 100644 index 00000000..b0c6c33e Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/reverse_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/skip_blue.png b/practicas/practica juego UNO/cartas_uno/skip_blue.png new file mode 100644 index 00000000..5520e996 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/skip_blue.png differ diff --git a/practicas/practica juego UNO/cartas_uno/skip_green.png b/practicas/practica juego UNO/cartas_uno/skip_green.png new file mode 100644 index 00000000..dc07bcba Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/skip_green.png differ diff --git a/practicas/practica juego UNO/cartas_uno/skip_red.png b/practicas/practica juego UNO/cartas_uno/skip_red.png new file mode 100644 index 00000000..8c2b6c99 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/skip_red.png differ diff --git a/practicas/practica juego UNO/cartas_uno/skip_yellow.png b/practicas/practica juego UNO/cartas_uno/skip_yellow.png new file mode 100644 index 00000000..a722d338 Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/skip_yellow.png differ diff --git a/practicas/practica juego UNO/cartas_uno/video_fondo_uno.mp4 b/practicas/practica juego UNO/cartas_uno/video_fondo_uno.mp4 new file mode 100644 index 00000000..8ef06a9c Binary files /dev/null and b/practicas/practica juego UNO/cartas_uno/video_fondo_uno.mp4 differ diff --git a/practicas/practica juego UNO/formulario.php b/practicas/practica juego UNO/formulario.php new file mode 100644 index 00000000..1b2622c2 --- /dev/null +++ b/practicas/practica juego UNO/formulario.php @@ -0,0 +1,72 @@ + + + + + + + + + Formulario Jugadores + + + + + + + +
+

Formulario de Jugadores

+
+
+ + +
+ +
+ + +
+ +
+ +
+
+
+ + + + + \ No newline at end of file diff --git a/practicas/practica juego UNO/juego.php b/practicas/practica juego UNO/juego.php new file mode 100644 index 00000000..9b262e62 --- /dev/null +++ b/practicas/practica juego UNO/juego.php @@ -0,0 +1,53 @@ +jugar(); + $_SESSION['partida'] = serialize($partida); +} else { + header('Location:formulario.php'); +} + +?> + + + + + + + + + Document + + + +
+
+ "; + $nombreJugador = "jugador" . $i; + $nombreJugador = new Jugador(); + $nombreJugador->cartasRepartidas(); + $nombreJugador->mostrar_ma(); + echo "
"; + } ?> +
+
+ carta_en_mesa->pinta_carta(); + ?> +
+ + + + \ No newline at end of file diff --git a/practicas/practica juego UNO/jugador.class.php b/practicas/practica juego UNO/jugador.class.php new file mode 100644 index 00000000..7b2bd9af --- /dev/null +++ b/practicas/practica juego UNO/jugador.class.php @@ -0,0 +1,31 @@ +mano[] = $carta; + } + + public function mostrar_ma() + { + for ($i = 0; $i < count($this->mano); $i++) { + echo $this->mano[$i]->pinta_carta_link(); + echo "
"; + } + } + + public function cartasRepartidas() + { + $cartas_a_repartir = $_SESSION['cartasPorJugador']; + $partida = unserialize($_SESSION['partida']); + for ($i = 0; $i < $cartas_a_repartir; $i++) { + $carta = array_shift($partida->baraja->barajaCartas); + $this->afegir_carta($carta); + } + $_SESSION['partida'] = serialize($partida); + } +} diff --git a/practicas/practica juego UNO/partida.class.php b/practicas/practica juego UNO/partida.class.php new file mode 100644 index 00000000..e4723efb --- /dev/null +++ b/practicas/practica juego UNO/partida.class.php @@ -0,0 +1,51 @@ +numero_jugadores = $partida->numero_jugadores; + $this->numero_cartas = $partida->numero_cartas; + $this->turno = $partida->turno; + $this->constante_sentido = $partida->constante_sentido; + $this->baraja = $partida->baraja; + $this->array_jugadores = $partida->array_jugadores; + $this->carta_en_mesa = $partida->carta_en_mesa; + } else { + $this->numero_jugadores = $numeroJugadores; + $this->numero_cartas = $cartasPorJugador; + $this->turno = 0; + $this->constante_sentido = 1; + $this->baraja = new Baraja(); + $this->baraja->crearBaraja(); + $this->baraja->mezclarBaraja(); + $this->array_jugadores = []; + $this->carta_en_mesa = null; + } + } + + public function jugar(){ + $this->baraja = new Baraja(); + $this->baraja->crearBaraja(); + $this->baraja->mezclarBaraja(); + $this->carta_en_mesa = array_shift($this->baraja->barajaCartas); + echo $_SESSION['numeroJugadores']; + echo $_SESSION['cartasPorJugador']; + } + + public function compararCarta(){ + + } +} + +?> \ No newline at end of file diff --git a/practicas/practica1/hola.php b/practicas/practica1/hola.php new file mode 100644 index 00000000..7acd48fd --- /dev/null +++ b/practicas/practica1/hola.php @@ -0,0 +1,28 @@ + + + + + + + Visual Studio Code Remote :: PHP + +

Módulo 7 - Práctica 1. Mi primera aplicación en PHP

+ + + +
+ +
+ + +

Aquesta pàgina 'hola.php' forma part de la 'pràctica 1' del mòdul 7. En el fitxer 'index.php', + normalment s'hi defineixen les parts bàsiques d'una pàgina PHP, com ara el 'header', que conté informació inicial de la pàgina, + així com el logo o títol, i el 'body', on es mostren els continguts principals. També es pot veure l'estructura de 'columnes' + que separen les diferents seccions del disseny

+ + + + \ No newline at end of file diff --git a/practicas/practica2/ejercicio1/index.php b/practicas/practica2/ejercicio1/index.php new file mode 100644 index 00000000..471879e9 --- /dev/null +++ b/practicas/practica2/ejercicio1/index.php @@ -0,0 +1,41 @@ + + + + + + Document + + + + +

Ejercicio 1. Numeros pares entre 50 y 500

+ +
+ $i
"; + } + } + par(); + ?> + + + + + + diff --git a/practicas/practica2/ejercicio2/index.php b/practicas/practica2/ejercicio2/index.php new file mode 100644 index 00000000..8a9887d3 --- /dev/null +++ b/practicas/practica2/ejercicio2/index.php @@ -0,0 +1,52 @@ + + + + + + Document + + + +

Ejercicio2. Tablas de multiplicación

+
+

La tabla de multiplicación por $i

"; + echo"
"; + for($y = 1; $y < 11; $y++){ + echo "

$i * $y = " . ($i * $y) . "

"; + } + echo "
"; + echo'
'; + } + } + multiplicacion(); + ?> + + + \ No newline at end of file diff --git a/practicas/practica2/ejercicio3/index.php b/practicas/practica2/ejercicio3/index.php new file mode 100644 index 00000000..2d4d0ee4 --- /dev/null +++ b/practicas/practica2/ejercicio3/index.php @@ -0,0 +1,35 @@ + + + + + + Document + + + +

Tu numero aleatorio es $i

"; + if($i % 2 == 0){ + echo "

Este numero es par

"; + } else { + echo "

Este numero es impar

"; + } + echo""; + ?> + + + \ No newline at end of file diff --git a/practicas/practica2/ejercicio_extra1/index.php b/practicas/practica2/ejercicio_extra1/index.php new file mode 100644 index 00000000..a983c19c --- /dev/null +++ b/practicas/practica2/ejercicio_extra1/index.php @@ -0,0 +1,59 @@ + + + + + + Ejercicio extra + + + + + + "; + echo"

Los divisores de $nrandom son:

"; + echo"
"; + for($i = 1; $i <=100; $i++){ + if($nrandom % $i == 0){ + echo"

$i

"; + $primo++; + } + } + echo"
"; + if($primo == 2){ + echo"

El numero $nrandom ES un numero primo

"; + }else{ + echo"

El numero $nrandom NO ES un numero primo

"; + } + echo""; + } + + divisores(); + ?> + + \ No newline at end of file diff --git a/practicas/practica3/ejercicio3a.php b/practicas/practica3/ejercicio3a.php new file mode 100644 index 00000000..ef1501e0 --- /dev/null +++ b/practicas/practica3/ejercicio3a.php @@ -0,0 +1,214 @@ + "Elon", + "apellido" => " Musk", + "apodo" => "Elon", + "imagen" => "https://static.wikia.nocookie.net/doblaje/images/a/aa/ElonMusk.jpg/revision/latest?cb=20200203042454&path-prefix=es", + "descripcion" => "Elon me ha enseñado a soñar en grande, a no conformarme con lo establecido y a siempre buscar innovar, incluso cuando parece imposible." + ], + [ + "nombre" => "Oprah", + "apellido" => " Winfrey", + "apodo" => "Oprah", + "imagen" => "https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/Oprah_in_2014.jpg/800px-Oprah_in_2014.jpg", + "descripcion" => "Oprah me ha inspirado con su historia de superación personal y su capacidad para conectar con las personas a un nivel profundo, siempre promoviendo el empoderamiento." + ], + [ + "nombre" => "Michael", + "apellido" => " Jordan", + "apodo" => "MJ", + "imagen" => "https://cdn.britannica.com/09/188709-050-03BF34CB/Michael-Jordan.jpg", + "descripcion" => "Michael Jordan me enseñó que el fracaso es solo una parte del proceso hacia el éxito. Su ética de trabajo y mentalidad competitiva me motivan diariamente." + ], + [ + "nombre" => "Emma", + "apellido" => " Watson", + "apodo" => "Hermione", + "imagen" => "https://static.wikia.nocookie.net/littlewomen/images/a/ac/Emmawatson.png/revision/latest/thumbnail/width/360/height/360?cb=20191221175400", + "descripcion" => "Emma Watson no solo es una actriz increíble, sino también una defensora de los derechos de las mujeres, lo que me ha inspirado a ser una mejor persona." + ], + [ + "nombre" => "Serena", + "apellido" => " Williams", + "apodo" => "Serena", + "imagen" => "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTh4vLbPXxSVhDTg1Y4RAsoUZR77NFb6WpbjQ&s", + "descripcion" => "Serena Williams me enseñó a luchar hasta el final, sin importar cuántas veces la vida te derribe. Su pasión y fuerza son inigualables." + ], + [ + "nombre" => "Keanu", + "apellido" => " Reeves", + "apodo" => "Neo", + "imagen" => "https://i.redd.it/a7c3so8l2g761.jpg", + "descripcion" => "Keanu Reeves es un ejemplo de humildad y resiliencia. A pesar de los desafíos personales, sigue siendo una persona amable y generosa." + ], + [ + "nombre" => "Billie", + "apellido" => " Eilish", + "apodo" => "Billie", + "imagen" => "https://media.vogue.es/photos/609d3714fae5608e730970ed/4:3/w_1999,h_1499,c_limit/Billie-Eilish-Happier-Than-Ever.jpeg", + "descripcion" => "Billie Eilish me inspira por su autenticidad. No tiene miedo de ser diferente y siempre es fiel a sí misma, rompiendo barreras en la música y más allá." + ], + [ + "nombre" => "Cristiano", + "apellido" => " Ronaldo", + "apodo" => "CR7", + "imagen" => "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRMSGTtrTDtuCpVMqlcS8XLV61ORiQmOSCJUQ&s", + "descripcion" => "Cristiano Ronaldo me ha mostrado que la disciplina y el esfuerzo constante son las claves para ser el mejor en cualquier campo. Su dedicación es legendaria." + ], + [ + "nombre" => "Zendaya", + "apellido" => " ", + "apodo" => "Z", + "imagen" => "https://cdn.hobbyconsolas.com/sites/navi.axelspringer.es/public/media/image/2024/04/zendaya-3296707.jpg?tf=3840x", + "descripcion" => "Zendaya me inspira no solo por su talento como actriz, sino por su activismo social, abogando por causas importantes y usando su plataforma para hacer el bien." + ], +]; ?> + + + + + + + + + + + + Album example · Bootstrap + + + + + + + + + + + + + + + + + + + +
+ +
+
+ + + Album + + +
+
+
+ +
+ +
+
+
+

Album example

+

Something short and leading about the collection below—its contents, the creator, + etc. Make it short and sweet, but not too short so folks don’t simply skip over it entirely.

+

+ Main call to action + Secondary action +

+
+
+
+ +
+
+ +
+ "; + echo '
+
+ +
+

' . $idolo['nombre'] . $idolo['apellido'] . '

+

' . $idolo['apodo'] . '

+

' . $idolo['descripcion'] . '

+
+
+ + +
+ 9 mins +
+
+
+
'; + }; + ?> +
+
+
+ +
+ + + + + + \ No newline at end of file diff --git a/practicas/practica3/ejercicio3b.php b/practicas/practica3/ejercicio3b.php new file mode 100644 index 00000000..e25a6c73 --- /dev/null +++ b/practicas/practica3/ejercicio3b.php @@ -0,0 +1,79 @@ +"Maracuyá","imagen"=>"https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcT4F1A39Wrh_2hc_pwLVF9S7XCVWWujd5P9QQ&s"], + ["nombre"=>"Lichi","imagen"=>"https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQrfiHXO8oAP0Qz9froK6z6pDWWEHnWJZ2uCA&s"], + ["nombre"=>"Carambola","imagen"=>"https://www.absolutdrinks.com/wp-content/uploads/ingredient_carambola_1x1_c33856d40a52b8d5367a5156d4eeb415.jpg"], + ["nombre"=>"Mangostán","imagen"=>"https://www.elmundoforestal.com/wp-content/uploads/2020/09/mangostan.jpg"], + ["nombre"=>"Kumquat","imagen"=>"https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcS62ncxcX0_MQhUmcV5-qQ4VN9fX9_m2k-ZLQ&s"] +]; +?> + + + + + + Frutas favoritas + + + +
+

Selecciona tu fruta favorita

+ + + + + + + + + + + + + + + + '; + }else{ + echo ' + + + + + '; + } + } + ?> + +
FrutaEstadoAcción
'. $fruta['nombre'].'✔️ seleccionadaSeleccionar
'. $fruta['nombre'].'✖ No seleccionadaSeleccionar
+ + + + '. $nomfruta .' +
+
'. $nomfruta .'
+

¡Esta es tu fruta favorita!

+
+
+ '; + }; + ?> + + + + + + + \ No newline at end of file diff --git a/practicas/practica4/detall.php b/practicas/practica4/detall.php new file mode 100644 index 00000000..9f9dbbf8 --- /dev/null +++ b/practicas/practica4/detall.php @@ -0,0 +1,120 @@ + + + + + + Detalle + + + +'. $nombrePeli .' +
+
+
+ +
+ +
+

'. $sinopsisPeli .'

+

Duración: '. $duracionPeli .'

+

Director: '. $directorPeli .'

+

Actores: '. $repartoPeli .'

+

Calificación: '. $calificacionPeli .'

+

Genero: '. $generoPeli .'

+
+

Horarios: '. $horarioPeli .'

+
+
+
+ '; + }; + +?> + + \ No newline at end of file diff --git a/practicas/practica4/peliculas.php b/practicas/practica4/peliculas.php new file mode 100644 index 00000000..bf1829cc --- /dev/null +++ b/practicas/practica4/peliculas.php @@ -0,0 +1,163 @@ + "Avengers: Endgame", + "imagen" => "https://static.posters.cz/image/750/avengers-endgame-whatever-it-takes-i74250.jpg", + "horario" => "15:00, 18:30, 21:45", + "sinopsis" => "Los Vengadores restantes deben unirse para deshacer el caos causado por Thanos y restaurar el orden en el universo.", + "duracion" => "181 min", + "director" => "Anthony y Joe Russo", + "reparto" => "Robert Downey Jr., Chris Evans, Scarlett Johansson", + "calificacion" => "13 años", + "genero" => "Acción, Ciencia Ficción", + "trailer" => "https://www.youtube.com/embed/TcMBFSGVi1c?si=b6eLkrIG2OlSizmM" + ], + [ + "nombre" => "Titanic", + "imagen" => "https://play-lh.googleusercontent.com/560-H8NVZRHk00g3RltRun4IGB-Ndl0I0iKy33D7EQ0cRRwH78-c46s90lZ1ho_F1so=w240-h480-rw", + "horario" => "12:00, 16:00, 20:30", + "sinopsis" => "Un joven artista y una aristócrata se enamoran a bordo del trágico viaje del Titanic.", + "duracion" => "195 min", + "director" => "James Cameron", + "reparto" => "Leonardo DiCaprio, Kate Winslet, Billy Zane", + "calificacion" => "13 años", + "genero" => "Drama, Romance", + "trailer" => "https://www.youtube.com/embed/tA_qMdzvCvk?si=5PmPKQI5iJIoVlN7" + ], + [ + "nombre" => "El Señor de los Anillos: El Retorno del Rey", + "imagen" => "https://es.web.img2.acsta.net/medias/nmedia/18/89/68/19/20061877.jpg", + "horario" => "14:30, 18:15, 21:45", + "sinopsis" => "Frodo y Sam llevan el Anillo Único a Mordor para destruirlo, mientras Aragorn lidera la batalla final.", + "duracion" => "201 min", + "director" => "Peter Jackson", + "reparto" => "Elijah Wood, Viggo Mortensen, Ian McKellen", + "calificacion" => "12 años", + "genero" => "Fantasía, Aventura", + "trailer" => "https://www.youtube.com/embed/h-9RYiqyqjk?si=LGXFWdhfrJ0JZZ3i" + ], + [ + "nombre" => "Jonkler", + "imagen" => "https://i1.sndcdn.com/artworks-R5mR3jJq8kczzJ9Q-iTbxVA-t1080x1080.jpg", + "horario" => "17:00, 20:00, 22:30", + "sinopsis" => "Arthur Fleck, un comediante fallido, desciende lentamente a la locura y se convierte en el icónico Joker.", + "duracion" => "122 min", + "director" => "Todd Phillips", + "reparto" => "Joaquin Phoenix, Robert De Niro, Zazie Beetz", + "calificacion" => "18 años", + "genero" => "Crimen, Drama", + "trailer" => "https://www.youtube.com/embed/-sogmas7sbk?si=GUmmZ_V8aOvCmHdY" + ], + [ + "nombre" => "Avatar", + "imagen" => "https://m.media-amazon.com/images/S/pv-target-images/ae4816cade1a5b7f29787d0b89610132c72c7747041481c6619b9cc3302c0101.jpg", + "horario" => "13:00, 16:45, 20:30", + "sinopsis" => "Un exmarine parapléjico se infiltra en una colonia alienígena de Pandora, pero acaba cuestionando su lealtad.", + "duracion" => "162 min", + "director" => "James Cameron", + "reparto" => "Sam Worthington, Zoe Saldana, Sigourney Weaver", + "calificacion" => "12 años", + "genero" => "Ciencia Ficción, Aventura", + "trailer" => "https://www.youtube.com/embed/CpXJHWSXJW0?si=MB2dwzDegY4MERSt" + ], + [ + "nombre" => "The Dark Knight", + "imagen" => "https://m.media-amazon.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_.jpg", + "horario" => "15:30, 19:00, 22:15", + "sinopsis" => "Batman enfrenta su mayor desafío hasta ahora, cuando el Joker siembra el caos en Gotham.", + "duracion" => "152 min", + "director" => "Christopher Nolan", + "reparto" => "Christian Bale, Heath Ledger, Aaron Eckhart", + "calificacion" => "13 años", + "genero" => "Acción, Crimen", + "trailer" => "https://www.youtube.com/embed/EXeTwQWrcwY?si=HiT-rbbeUwzDLR7a" + ], + [ + "nombre" => "Spider-Man: No Way Home", + "imagen" => "https://pics.filmaffinity.com/Spider_Man_No_Way_Home-642739124-large.jpg", + "horario" => "14:00, 17:45, 21:15", + "sinopsis" => "Peter Parker pide ayuda a Doctor Strange para restaurar su identidad secreta, pero algo sale terriblemente mal.", + "duracion" => "148 min", + "director" => "Jon Watts", + "reparto" => "Tom Holland, Zendaya, Benedict Cumberbatch", + "calificacion" => "12 años", + "genero" => "Acción, Aventura", + "trailer" => "https://www.youtube.com/embed/ldMn-1iQzKE?si=DQNfP3j82Ayn7eh6" + ], + [ + "nombre" => "Inception", + "imagen" => "https://m.media-amazon.com/images/I/912AErFSBHL._AC_UF894,1000_QL80_.jpg", + "horario" => "16:00, 19:30, 22:45", + "sinopsis" => "Un ladrón que puede entrar en los sueños debe plantar una idea en la mente de un poderoso empresario.", + "duracion" => "148 min", + "director" => "Christopher Nolan", + "reparto" => "Leonardo DiCaprio, Joseph Gordon-Levitt, Ellen Page", + "calificacion" => "13 años", + "genero" => "Ciencia Ficción, Thriller", + "trailer" => "https://www.youtube.com/embed/YoHD9XEInc0?si=bzvgivimsM8v4pKq" + ] +]; +?> + + + + + + + Películas + + + + + +'; + foreach($peliculas as $pelicula){ + echo ' +
+
+ +
+
' . $pelicula['nombre'] . '
+

' . $pelicula['horario'] . '

+

Duración: ' . $pelicula['duracion'] . '

+

Calificación: ' . $pelicula['calificacion'] . '

+
+
+ + +
+
+
+
+
'; + } + echo '' +?> + + \ No newline at end of file diff --git a/practicas/practica4/trailer.php b/practicas/practica4/trailer.php new file mode 100644 index 00000000..c52aa61a --- /dev/null +++ b/practicas/practica4/trailer.php @@ -0,0 +1,66 @@ + + + + + + Document + + + + + + + + Tràiler de la pel·lícula + + + + + + +
+ Tràiler de '. $nombrePeli .' + + + +
+ Volver +
+ '; + }; + + ?> +
+ + + + + + + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/archivo.html b/practicas/practica5/funcionesPropias/archivo.html new file mode 100644 index 00000000..e2dba7d3 --- /dev/null +++ b/practicas/practica5/funcionesPropias/archivo.html @@ -0,0 +1,15 @@ + + + + + + Document + + +

DESCARGAR GRATIS SIN VIRUS(TE LO JURO ERMANO) ONLINE(NO OFLINE) SIN REGISTRO SIN IMPUESTOS(REAL) SIN ESPERAS OFICIAL☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️☑️

+


















+


















+


















+

Laura a 7 km de ti

 + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte1.php b/practicas/practica5/funcionesPropias/parte1.php new file mode 100644 index 00000000..a5be0dab --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte1.php @@ -0,0 +1,24 @@ + + + + + + Saludo personalizado + + + + + + +

+ +

+ + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte2.php b/practicas/practica5/funcionesPropias/parte2.php new file mode 100644 index 00000000..8664d0df --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte2.php @@ -0,0 +1,25 @@ + + + + + + Document + + + + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte3.php b/practicas/practica5/funcionesPropias/parte3.php new file mode 100644 index 00000000..a91cd77d --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte3.php @@ -0,0 +1,26 @@ + + + + + + Document + + + $limite) { + return substr($texto, 0, $limite) . "..."; + + } else { + return $texto; + } + }; + + echo generarResumen($texto, $limite); + + ?> + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte4.php b/practicas/practica5/funcionesPropias/parte4.php new file mode 100644 index 00000000..5f1f5761 --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte4.php @@ -0,0 +1,30 @@ + + + + + + Document + + + + + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte5.php b/practicas/practica5/funcionesPropias/parte5.php new file mode 100644 index 00000000..d5f4624d --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte5.php @@ -0,0 +1,21 @@ + + + + + + Document + + + + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte6.php b/practicas/practica5/funcionesPropias/parte6.php new file mode 100644 index 00000000..c93e05a7 --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte6.php @@ -0,0 +1,23 @@ + + + + + + Document + + + + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte7.php b/practicas/practica5/funcionesPropias/parte7.php new file mode 100644 index 00000000..4e36c008 --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte7.php @@ -0,0 +1,18 @@ + + + + + + Document + + + DESCARGAR .'); + }; + + echo generarEnlaceDescarga($archivo); + ?> + + \ No newline at end of file diff --git a/practicas/practica5/funcionesPropias/parte8.php b/practicas/practica5/funcionesPropias/parte8.php new file mode 100644 index 00000000..6bca7359 --- /dev/null +++ b/practicas/practica5/funcionesPropias/parte8.php @@ -0,0 +1,20 @@ + + + + + + Document + + + + + \ No newline at end of file diff --git a/practicas/practica6/tienda/data/assets/mercadona.png b/practicas/practica6/tienda/data/assets/mercadona.png new file mode 100644 index 00000000..760ae467 Binary files /dev/null and b/practicas/practica6/tienda/data/assets/mercadona.png differ diff --git a/practicas/practica6/tienda/data/productos.php b/practicas/practica6/tienda/data/productos.php new file mode 100644 index 00000000..ed925efa --- /dev/null +++ b/practicas/practica6/tienda/data/productos.php @@ -0,0 +1,8 @@ + "leche", "precio" => 1.25, "disponibilidad" => true], + ["nombre" => "pan", "precio" => 0.85, "disponibilidad" => false], + ["nombre" => "manzana", "precio" => 0.30, "disponibilidad" => true], + ["nombre" => "aceite", "precio" => 4.50, "disponibilidad" => true], + ["nombre" => "arroz", "precio" => 1.10, "disponibilidad" => false], +]; diff --git a/practicas/practica6/tienda/includes/footer.php b/practicas/practica6/tienda/includes/footer.php new file mode 100644 index 00000000..195fb158 --- /dev/null +++ b/practicas/practica6/tienda/includes/footer.php @@ -0,0 +1,32 @@ + +
+
+
+
Sobre nosotros
+

Proporcionamos servicios de alta calidad con un enfoque minimalista y funcional.

+
+
+
Enlaces
+ +
+
+
Síguenos
+ +
+
+
+ © 2023 Tu Empresa. Todos los derechos reservados. +
+
+ +'; diff --git a/practicas/practica6/tienda/includes/funciones.php b/practicas/practica6/tienda/includes/funciones.php new file mode 100644 index 00000000..6e91f7b8 --- /dev/null +++ b/practicas/practica6/tienda/includes/funciones.php @@ -0,0 +1,84 @@ + + + $_POST['nombre'], + "precio" => $_POST['precio'], + "disponibilidad" => $_POST['disponibilidad'], + ]; + } + + + + + + // mostrar la tabla + echo " + + + + + + + + "; + + foreach ($productos as $producto) { + echo " + + "; + + if ($producto['disponibilidad'] == true) { + echo " + + "; + } else { + echo " + + "; + } + + echo ""; + } + + echo "
NombrePrecioDisponibilidad
" . $producto['nombre'] . "" . $producto['precio'] . "Hay en stockNo hay en stock
"; +} + + + +function muestraInfoContacto($nombre, $telefono, $foto) +{ + // verificar si se mando furmulario con el boton + if ($_SERVER["REQUEST_METHOD"] == "POST") { + $nombre = $_POST['nombre']; + $telefono = $_POST['telefono']; + $imagen = $_POST['imagen']; + } + + // Mostrar la información + echo " +

Hola, $nombre

+

Su número de teléfono es: $telefono

+ + "; +} + + + +?> \ No newline at end of file diff --git a/practicas/practica6/tienda/includes/header.php b/practicas/practica6/tienda/includes/header.php new file mode 100644 index 00000000..2ced205d --- /dev/null +++ b/practicas/practica6/tienda/includes/header.php @@ -0,0 +1,32 @@ + +
+
+ +
+

Tu Empresa

+

Calidad y minimalismo

+
+ + + +
+
+
+'; diff --git a/practicas/practica6/tienda/index.php b/practicas/practica6/tienda/index.php new file mode 100644 index 00000000..e5515b25 --- /dev/null +++ b/practicas/practica6/tienda/index.php @@ -0,0 +1,98 @@ + + + + + + + Mercadona productos + + + + + + + + + + + +
+
+

Productos disponibles

+ + + + + +
+ + + + + + + + +
+ +
+ + +
+ + + + + + \ No newline at end of file diff --git a/practicas/practica6/tienda/inicio.php b/practicas/practica6/tienda/inicio.php new file mode 100644 index 00000000..76b77fe3 --- /dev/null +++ b/practicas/practica6/tienda/inicio.php @@ -0,0 +1,52 @@ + + + + + + + Bienvenido a Mercadona + + + + + + +
+
+

Bienvenido a Mercadona

+

Por favor, completa el siguiente formulario para continuar tu compra.

+
+ +
+ +
+
+ + +
+
+ + +
+
+ + +
+ +
+ +
+
+ + + + + + \ No newline at end of file diff --git a/practicas/practica8/funciones.php b/practicas/practica8/funciones.php new file mode 100644 index 00000000..1dbc1e5b --- /dev/null +++ b/practicas/practica8/funciones.php @@ -0,0 +1,73 @@ + [ + [ + "pregunta" => "Tengo ciudades, pero no casas. Tengo montañas, pero no árboles. Tengo agua, pero no peces. ¿Qué soy?", + "respuesta" => "Un mapa" + ], + [ + "pregunta" => "Si me nombras, desaparezco. ¿Qué soy?", + "respuesta" => "El silencio" + ], + [ + "pregunta" => "Cuanto más seco, más mojo. ¿Qué soy?", + "respuesta" => "Una toalla" + ], + [ + "pregunta" => "Tengo agujeros por todos lados, pero sigo reteniendo agua. ¿Qué soy?", + "respuesta" => "Una esponja" + ], + [ + "pregunta" => "Tengo cuatro patas, pero no camino. ¿Qué soy?", + "respuesta" => "Una silla" + ], + ], + + "mig" => [ + [ + "pregunta" => "Largo cuando soy joven, corto cuando soy viejo. ¿Qué soy?", + "respuesta" => "Una vela" + ], + [ + "pregunta" => "Me puedes romper sin tocarme o incluso sin verme. ¿Qué soy?", + "respuesta" => "Una promesa" + ], + [ + "pregunta" => "Mientras más quitas, más grande soy. ¿Qué soy?", + "respuesta" => "Un hoyo" + ], + [ + "pregunta" => "Soy algo que al partirse, une a la gente. ¿Qué soy?", + "respuesta" => "El pan" + ], + [ + "pregunta" => "Paso en un rincón, pero viajo por el mundo. ¿Qué soy?", + "respuesta" => "Una estampilla" + ], + ], + + "dificil" => [ + [ + "pregunta" => "Me puedes ver en el agua, pero no me mojo. ¿Qué soy?", + "respuesta" => "El reflejo" + ], + [ + "pregunta" => "Crecí, pero nunca fui pequeño. Caigo, pero no me rompo. ¿Qué soy?", + "respuesta" => "La nieve" + ], + [ + "pregunta" => "Tengo un ojo, pero no puedo ver. ¿Qué soy?", + "respuesta" => "Una aguja" + ], + [ + "pregunta" => "Cuanto más hay, menos ves. ¿Qué soy?", + "respuesta" => "La oscuridad" + ], + [ + "pregunta" => "Vuelo sin alas, lloro sin ojos. ¿Qué soy?", + "respuesta" => "Las nubes" + ], + ], +]; diff --git a/practicas/practica8/index.php b/practicas/practica8/index.php new file mode 100644 index 00000000..c7c6c088 --- /dev/null +++ b/practicas/practica8/index.php @@ -0,0 +1,44 @@ + + + + + + + + + + Inici + + + +
+

Benvingut!

+
+
+ + +
+
+ + +
+ +
+
+ + + \ No newline at end of file diff --git a/practicas/practica8/rooms/room1.php b/practicas/practica8/rooms/room1.php new file mode 100644 index 00000000..fad9dccc --- /dev/null +++ b/practicas/practica8/rooms/room1.php @@ -0,0 +1,52 @@ + + + + + + + + + + Habitación 1 + + + +
+ Hola, {$_SESSION['username']} +

Nivel de dificultad: {$_SESSION['dificultat']}

+ " + ?> +

Habitación 1

+

+
+
+ +
+ +
+ +
+ + + \ No newline at end of file diff --git a/practicas/practica8/rooms/room2.php b/practicas/practica8/rooms/room2.php new file mode 100644 index 00000000..4d2840b0 --- /dev/null +++ b/practicas/practica8/rooms/room2.php @@ -0,0 +1,48 @@ + + + + + + + + + Habitación 2 + + + +
+ Hola, {$_SESSION['username']} +

Nivel de dificultad: {$_SESSION['dificultat']}

+ " + ?> +

Habitación 2

+

+
+
+ +
+ +
+ +
+ + + \ No newline at end of file diff --git a/practicas/practica8/rooms/room3.php b/practicas/practica8/rooms/room3.php new file mode 100644 index 00000000..a0e4db40 --- /dev/null +++ b/practicas/practica8/rooms/room3.php @@ -0,0 +1,49 @@ + + + + + + + + + + Habitación 3 + + + +
+ Hola, {$_SESSION['username']} +

Nivel de dificultad: {$_SESSION['dificultat']}

+ " + ?> +

Habitación 3

+

+
+
+ +
+ +
+ +
+ + + \ No newline at end of file diff --git a/practicas/practica8/rooms/room4.php b/practicas/practica8/rooms/room4.php new file mode 100644 index 00000000..580b2b9c --- /dev/null +++ b/practicas/practica8/rooms/room4.php @@ -0,0 +1,49 @@ + + + + + + + + + + Habitación 4 + + + +
+ Hola, {$_SESSION['username']} +

Nivel de dificultad: {$_SESSION['dificultat']}

+ " + ?> +

Habitación 4

+

+
+
+ +
+ +
+ +
+ + + \ No newline at end of file diff --git a/practicas/practica8/rooms/room5.php b/practicas/practica8/rooms/room5.php new file mode 100644 index 00000000..1680a497 --- /dev/null +++ b/practicas/practica8/rooms/room5.php @@ -0,0 +1,48 @@ + + + + + + + + + + Habitación 5 + + + +
+ Hola, {$_SESSION['username']} +

Nivel de dificultad: {$_SESSION['dificultat']}

+ " + ?> +

Habitación 5

+

+
+
+ +
+ +
+ +
+ + + \ No newline at end of file diff --git a/practicas/practica9/ logout.php b/practicas/practica9/ logout.php new file mode 100644 index 00000000..e69de29b diff --git a/practicas/practica9/add_edit_book.php b/practicas/practica9/add_edit_book.php new file mode 100644 index 00000000..c0e90c02 --- /dev/null +++ b/practicas/practica9/add_edit_book.php @@ -0,0 +1,88 @@ + $_POST['titulo'], + "autor" => $_POST['autor'], + "url_imagen" => $_POST['url_imagen'], + "descripcion" => $_POST['descripcion'], + ]); + + header("Location: home.php"); + exit; +} + + + +?> + + + + + + Biblioteca Virtual + + + + + + +
+
+
+

👋 Bienvenido,

+ Admin ✏️

+ '; + } else { + echo ' +

Lector 📚

+ '; + } + ?> +
+ + Volver a la Biblioteca + +
+
+ +
+
+

+

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ +
+
+
+ + + + + \ No newline at end of file diff --git a/practicas/practica9/css/style.css b/practicas/practica9/css/style.css new file mode 100644 index 00000000..53bba403 --- /dev/null +++ b/practicas/practica9/css/style.css @@ -0,0 +1,189 @@ +@import url('https://fonts.googleapis.com/css2?family=Quicksand:wght@300;400;500;600;700&display=swap'); +* +{ + margin: 0; + padding: 0; + box-sizing: border-box; + +} +body +{ + display: flex; + justify-content: center; + align-items: center; + min-height: 100vh; + background: #000; +} +section +{ + position: absolute; + width: 100vw; + height: 100vh; + display: flex; + justify-content: center; + align-items: center; + gap: 2px; + flex-wrap: wrap; + overflow: hidden; +} +section::before +{ + content: ''; + position: absolute; + width: 100%; + height: 100%; + background: linear-gradient(#000,#daa520,#000); + animation: animate 5s linear infinite; +} +@keyframes animate +{ + 0% + { + transform: translateY(-100%); + } + 100% + { + transform: translateY(100%); + } +} +section span +{ + position: relative; + display: block; + width: calc(6.25vw - 2px); + height: calc(6.25vw - 2px); + background: #181818; + z-index: 2; + transition: 1.5s; +} +section span:hover +{ + background: #daa520; + transition: 0s; +} + +section .signin +{ + position: absolute; + width: 400px; + background: #222; + z-index: 1000; + display: flex; + justify-content: center; + align-items: center; + padding: 40px; + border-radius: 4px; + box-shadow: 0 15px 35px rgba(0,0,0,9); +} +section .signin .content +{ + position: relative; + width: 100%; + display: flex; + justify-content: center; + align-items: center; + flex-direction: column; + gap: 40px; +} +section .signin .content h2 +{ + font-size: 2em; + color: #daa520; + text-transform: uppercase; +} +section .signin .content .form +{ + width: 100%; + display: flex; + flex-direction: column; + gap: 25px; +} +section .signin .content .form .inputBox +{ + position: relative; + width: 100%; +} +section .signin .content .form .inputBox input +{ + position: relative; + width: 100%; + background: #333; + border: none; + outline: none; + padding: 25px 10px 7.5px; + border-radius: 10px; + color: #fff; + font-weight: 500; + font-size: 1em; +} +.inputBox input { + + border: none; + border-radius: 8px; + background: #333; +} +section .signin .content .form .inputBox i +{ + position: absolute; + left: 0; + padding: 15px 10px; + font-style: normal; + color: #aaa; + transition: 0.5s; + pointer-events: none; +} +.signin .content .form .inputBox input:focus ~ i, +.signin .content .form .inputBox input:valid ~ i +{ + transform: translateY(-7.5px); + font-size: 0.8em; + color: #fff; +} +.signin .content .form .links +{ + position: relative; + width: 100%; + display: flex; + justify-content: space-between; +} +.signin .content .form .links a +{ + color: #fff; + text-decoration: none; +} +.signin .content .form .links a:nth-child(2) +{ + color: #daa520; + font-weight: 600; +} +.signin .content .form .inputBox input[type="submit"] +{ + padding: 10px; + background: #daa520; + color: #000; + font-weight: 600; + font-size: 1.35em; + letter-spacing: 0.05em; + cursor: pointer; +} +input[type="submit"]:active +{ + opacity: 0.6; +} +@media (max-width: 900px) +{ + section span + { + width: calc(10vw - 2px); + height: calc(10vw - 2px); + } +} +@media (max-width: 600px) +{ + section span + { + width: calc(20vw - 2px); + height: calc(20vw - 2px); + } +} + \ No newline at end of file diff --git a/practicas/practica9/delete_book.php b/practicas/practica9/delete_book.php new file mode 100644 index 00000000..e69de29b diff --git a/practicas/practica9/functions.php b/practicas/practica9/functions.php new file mode 100644 index 00000000..78f27b62 --- /dev/null +++ b/practicas/practica9/functions.php @@ -0,0 +1,41 @@ + "Don Quijote de la Mancha", + "autor" => "Miguel de Cervantes", + "url_imagen" => "https://m.media-amazon.com/images/I/91CIwR3QU1L._UF1000,1000_QL80_.jpg", + "descripcion" => "Una novela clásica que narra las aventuras del caballero Don Quijote y su fiel escudero Sancho Panza." + ], + [ + "titulo" => "Cien años de soledad", + "autor" => "Gabriel García Márquez", + "url_imagen" => "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTwSsR0pOIFUZYQivZGvfV1a74s4Khz8GrbjA&s", + "descripcion" => "La obra maestra del realismo mágico que sigue la historia de la familia Buendía en el pueblo ficticio de Macondo." + ], + [ + "titulo" => "1984", + "autor" => "George Orwell", + "url_imagen" => "https://cdn.prod.website-files.com/6034d7d1f3e0f52c50b2adee/6254291caac6d1e42e8986df_62023ceb41cd1c2807b2841a_9788418933011.jpeg", + "descripcion" => "Una distopía que explora la opresión, el control gubernamental y la vigilancia en un futuro sombrío." + ], + [ + "titulo" => "Orgullo y prejuicio", + "autor" => "Jane Austen", + "url_imagen" => "https://m.media-amazon.com/images/I/81RBELGte5L._AC_UF894,1000_QL80_.jpg", + "descripcion" => "Una novela clásica que explora temas de amor, clase social y malentendidos en la Inglaterra del siglo XIX." + ], + [ + "titulo" => "El principito", + "autor" => "Antoine de Saint-Exupéry", + "url_imagen" => "https://m.media-amazon.com/images/I/714Hvb52n-L._AC_UF894,1000_QL80_.jpg", + "descripcion" => "Un cuento poético y filosófico que aborda el amor, la amistad y el sentido de la vida a través de los ojos de un niño." + ] +]; + +//generar una copia del array para tranajar sobre el +if (!isset($_SESSION["libross"])) { + $_SESSION["libross"] = $libros; +} diff --git a/practicas/practica9/home.php b/practicas/practica9/home.php new file mode 100644 index 00000000..a103f422 --- /dev/null +++ b/practicas/practica9/home.php @@ -0,0 +1,97 @@ + + + + + + + + Biblioteca Virtual - Home + + + + + + +
+
+
+ Foto de perfil +
+

👋 Bienvenido,

+ Admin ✏️

+ '; + } else { + echo ' +

Lector 📚

+ '; + } + ?> +
+
+ + Cerrar sesión ❌ + +
+
+ +
+
+

Biblioteca Virtual

+

Disfruta explorando nuestra colección de libros

+
+ + + + Agregar Nuevo Libro + +
+ '; + } ?> + + +
+ +
+ ' . $libro['titulo'] . ' +
+
' . $libro['titulo'] . '
+

Autor: ' . $libro['autor'] . '

+

' . $libro['descripcion'] . '

+
'; + + if ($_SESSION['role'] === 'admin') { + echo ' +
+ + Editar + + + Eliminar + +
+ '; + } + echo ' +
+
+ '; + } ?> + + + + + + + \ No newline at end of file diff --git a/practicas/practica9/index.php b/practicas/practica9/index.php new file mode 100644 index 00000000..31a02a2c --- /dev/null +++ b/practicas/practica9/index.php @@ -0,0 +1,34 @@ + + + + + + + Biblioteca Virtual + + + + + +
+

Bienvenido a la Biblioteca Virtual

+

Explora, administra y accede a tus libros favoritos con facilidad.

+ Ir a Iniciar Sesión +
+ + + \ No newline at end of file diff --git a/practicas/practica9/login.php b/practicas/practica9/login.php new file mode 100644 index 00000000..86aa59c2 --- /dev/null +++ b/practicas/practica9/login.php @@ -0,0 +1,90 @@ + "admin", "password" => "adminpass", "role" => "admin"], + ["username" => "reader", "password" => "readerpass", "role" => "lector"], + ["username" => "alumno", "password" => "alumnopass", "role" => "lector"], + ["username" => "yehor", "password" => "yehorpass", "role" => "admin"] +]; + +// Procesamiento del formulario. + +if ($_SERVER['REQUEST_METHOD'] == 'POST') { + $_SESSION['username'] = $_POST['username']; + $_SESSION['password'] = $_POST['password']; + $_SESSION['photo'] = $_POST['photo']; + + if (isset($_POST['username']) && isset($_POST['password'])) { + foreach ($usuarios as $usuario) { + if ($usuario['username'] == $_POST['username'] && $usuario['password'] == $_POST['password']) { + $_SESSION['username'] = $_POST['username']; + $_SESSION['role'] = $usuario['role']; + $_SESSION['photo'] = $_POST['photo']; + header('Location:home.php'); + exit; + } else { + $credIncorrecto = 'Usuario o contraseña son incorrectos'; + } + } + } +} + + + +?> + + + + + + + + Biblioteca Virtual - Login + + + + + +
+ + + + + + +
+
+

Inicia sesión

+
+
+ + +
+
+ + +
+
+ + +
+ +
+ + +
+ +
+
+ +
+
+
+ + + + + + \ No newline at end of file diff --git a/prueba de mejora/add_edit_question.php b/prueba de mejora/add_edit_question.php new file mode 100644 index 00000000..5174c58b --- /dev/null +++ b/prueba de mejora/add_edit_question.php @@ -0,0 +1,63 @@ + count($_SESSION['preguntas']) + 1, + 'question' => $_POST['questionmas'], + 'options' => [ + $_POST['option1mas'], + $_POST['option2mas'], + $_POST['option3mas'] + ], + 'answer' => $_POST['answermas'] + ]; + + $_SESSION['preguntas'] . array_push($preguntas, $nuevaPregunta); + } else { + echo 'Completa todos los campos!!!!'; + } +} +?> + + + + + + + + Añadir pregunta + + + +

Añadir una nueva pregunta

+
+ +

+ + +

+ + +

+ + +

+ + +

+ + +
+ + Regresar al index.php + + + \ No newline at end of file diff --git a/prueba de mejora/data.php b/prueba de mejora/data.php new file mode 100644 index 00000000..e07ec57a --- /dev/null +++ b/prueba de mejora/data.php @@ -0,0 +1,41 @@ + 1, +'question' => '¿Cuál es el océano más grande del mundo?', +'options' => ['Atlántico', 'Pacífico', 'Índico'], +'answer' => 'Pacífico' +], +[ +'id' => 2, +'question' => '¿En qué continente se encuentra Egipto?', +'options' => ['Asia', 'África', 'Europa'], +'answer' => 'África' +], +[ +'id' => 3, +'question' => '¿Cuántos días tiene un año bisiesto?', +'options' => ['365', '366', '367'], +'answer' => '366' +], +[ +'id' => 4, +'question' => '¿Cuál es el metal más usado en la industria?', +'options' => ['Hierro', 'Cobre', 'Aluminio'], +'answer' => 'Hierro' +], +[ +'id' => 5, +'question' => '¿Qué planeta es conocido como el planeta rojo?', +'options' => ['Venus', 'Marte', 'Júpiter'], +'answer' => 'Marte' +] +]; + +if (!isset($_SESSION["preguntas"])) { +$_SESSION["preguntas"] = $preguntas; +} + +?> \ No newline at end of file diff --git a/prueba de mejora/delete_question.php b/prueba de mejora/delete_question.php new file mode 100644 index 00000000..e69de29b diff --git a/prueba de mejora/index.php b/prueba de mejora/index.php new file mode 100644 index 00000000..c8307a57 --- /dev/null +++ b/prueba de mejora/index.php @@ -0,0 +1,40 @@ + + + + + + + + + + Inicio + + + +
+
+

+

Hola, . Clica aquí para

+ empezar el trivial'; + } else { + echo 'empezar el trivial'; + } + ?> + + ⚙️'; + } else { + echo '⚙️'; + } + ?> + +
+
+ + + \ No newline at end of file diff --git a/prueba de mejora/login.php b/prueba de mejora/login.php new file mode 100644 index 00000000..67a87ce6 --- /dev/null +++ b/prueba de mejora/login.php @@ -0,0 +1,64 @@ + "admin", "password" => "1234", "role" => "admin"], + ["usuario" => "player", "password" => "5678", "role" => "player"] +]; + +if ($_SERVER['REQUEST_METHOD'] == 'POST') { + $_SESSION['usuario'] = $_POST['usuario']; + $_SESSION['password'] = $_POST['password']; + if (isset($_POST['usuario']) && isset($_POST['password'])) { + foreach ($usuarios as $usuario) { + if ($usuario['usuario'] == $_POST['usuario'] && $usuario['password'] == $_POST['password']) { + $_SESSION['usuario'] = $_POST['usuario']; + $_SESSION['role'] = $usuario['role']; + header('Location:index.php'); + exit; + } else { + $credIncorrecto = 'Usuario o contraseña son incorrectos'; + } + } + } +} + +?> + + + + + + + + Login + + + +
+

Página de login, inicia tu sesión

+
+
+
+
+
+
+ +
+
+ +
+ +
+ +
+ +
+
+ +
+
+
+ + + \ No newline at end of file diff --git a/prueba de mejora/logout.php b/prueba de mejora/logout.php new file mode 100644 index 00000000..e4bc3fac --- /dev/null +++ b/prueba de mejora/logout.php @@ -0,0 +1,6 @@ + + + + + + + + + Document + + + +
+ +
+ + Añadir una pregunta nueva + + + \ No newline at end of file diff --git a/prueba de mejora/styles.css b/prueba de mejora/styles.css new file mode 100644 index 00000000..e69de29b diff --git a/prueba de mejora/trivial.php b/prueba de mejora/trivial.php new file mode 100644 index 00000000..56c02f85 --- /dev/null +++ b/prueba de mejora/trivial.php @@ -0,0 +1,67 @@ + $correctas, + 'incorrectas' => $incorrectas, + ]; +} +?> + + + + + + + + Trivial + + + +
+ Resultados: +

Respuestas correctas: '.$_SESSION['resultado']['correctas'].'

+

Respuestas incorrectas: '.$_SESSION['resultado']['incorrectas'].'

+
+ +
+ '; + } else { + echo '
'; + foreach ($preguntas as $pregunta) { + echo '

Pregunta #'.$pregunta['id'].':'.$pregunta['question'].'

'; + foreach ($pregunta['options'] as $opcion) { + echo ''.$opcion.'
'; + } + } + + echo ' +
+ +
+
'; + } + ?> +
+ + + \ No newline at end of file diff --git a/.devcontainer/Dockerfile b/sample/.devcontainer/Dockerfile similarity index 100% rename from .devcontainer/Dockerfile rename to sample/.devcontainer/Dockerfile diff --git a/.devcontainer/devcontainer.json b/sample/.devcontainer/devcontainer.json similarity index 100% rename from .devcontainer/devcontainer.json rename to sample/.devcontainer/devcontainer.json diff --git a/.gitattributes b/sample/.gitattributes similarity index 100% rename from .gitattributes rename to sample/.gitattributes diff --git a/.gitignore b/sample/.gitignore similarity index 100% rename from .gitignore rename to sample/.gitignore diff --git a/.vscode/launch.json b/sample/.vscode/launch.json similarity index 100% rename from .vscode/launch.json rename to sample/.vscode/launch.json diff --git a/LICENSE b/sample/LICENSE similarity index 98% rename from LICENSE rename to sample/LICENSE index 4b1ad51b..21071075 100644 --- a/LICENSE +++ b/sample/LICENSE @@ -1,21 +1,21 @@ - MIT License - - Copyright (c) Microsoft Corporation. All rights reserved. - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in all - copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - SOFTWARE + MIT License + + Copyright (c) Microsoft Corporation. All rights reserved. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/README.md b/sample/README.md similarity index 98% rename from README.md rename to sample/README.md index 46e2e3c5..b5ef47bb 100644 --- a/README.md +++ b/sample/README.md @@ -1,91 +1,91 @@ -# Try Out Development Containers: PHP - -[![Open in Remote - Containers](https://img.shields.io/static/v1?label=Remote%20-%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode-remote-try-php) - -A **development container** is a running [Docker](https://www.docker.com) container with a well-defined tool/runtime stack and its prerequisites. You can try out development containers with **[GitHub Codespaces](https://github.com/features/codespaces)** or **[Visual Studio Code Remote - Containers](https://aka.ms/vscode-remote/containers)**. - -This is a sample project that lets you try out either option in a few easy steps. We have a variety of other [vscode-remote-try-*](https://github.com/search?q=org%3Amicrosoft+vscode-remote-try-&type=Repositories) sample projects, too. - -> **Note:** If you already have a Codespace or dev container, you can jump to the [Things to try](#things-to-try) section. - -## Setting up the development container - -### GitHub Codespaces -Follow these steps to open this sample in a Codespace: -1. Click the Code drop-down menu and select the **Open with Codespaces** option. -1. Select **+ New codespace** at the bottom on the pane. - -For more info, check out the [GitHub documentation](https://docs.github.com/en/free-pro-team@latest/github/developing-online-with-codespaces/creating-a-codespace#creating-a-codespace). - -### VS Code Remote - Containers - -If you already have VS Code and Docker installed, you can click the badge above or [here](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode-remote-try-php) to get started. Clicking these links will cause VS Code to automatically install the Remote - Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use. - -Follow these steps to open this sample in a container using the VS Code Remote - Containers extension: - -1. If this is your first time using a development container, please ensure your system meets the pre-reqs (i.e. have Docker installed) in the [getting started steps](https://aka.ms/vscode-remote/containers/getting-started). - -2. To use this repository, you can either open the repository in an isolated Docker volume: - - - Press F1 and select the **Remote-Containers: Try a Sample...** command. - - Choose the "PHP" sample, wait for the container to start, and try things out! - > **Note:** Under the hood, this will use the **Remote-Containers: Clone Repository in Container Volume...** command to clone the source code in a Docker volume instead of the local filesystem. [Volumes](https://docs.docker.com/storage/volumes/) are the preferred mechanism for persisting container data. - - Or open a locally cloned copy of the code: - - - Clone this repository to your local filesystem. - - Press F1 and select the **Remote-Containers: Open Folder in Container...** command. - - Select the cloned copy of this folder, wait for the container to start, and try things out! - -## Things to try - -Once you have this sample opened, you'll be able to work with it like you would locally. - -> **Note:** This container runs as a non-root user with sudo access by default. Comment out `"remoteUser": "vscode"` in `.devcontainer/devcontainer.json` if you'd prefer to run as root. - -Some things to try: - -1. **Edit:** - - Open `index.php` - - Try adding some code and check out the language features. - - Notice that PHP debugging and IntelliSense are already included in the container since the `.devcontainer/devcontainer.json` lists `"felixfbecker.php-debug"`, `"bmewburn.vscode-intelephense-client"`, and `"mrmlnc.vscode-apache"` as extensions to install automatically when the container is created. -1. **Terminal:** Press ctrl+shift+\` and type `uname` and other Linux commands from the terminal window. -1. **Run and Debug:** - - Open `index.php` - - Add a breakpoint (e.g. on line 4). - - Press F5 to launch the app in the container. - - Once the breakpoint is hit, try hovering over variables, examining locals, and more. -1. **Running a server:** - - From the terminal, run `php -S 0.0.0.0:8000` - - Click "Open in Browser" in the notification that appears to access the web app on this new port. - - You can view an organized table of your forwarded ports in the 'Ports' view, which can be accessed with the command **Ports: Focus on Ports View**. - - Notice port 8000 in the 'Ports' view is labeled "Hello Remote World." In `devcontainer.json`, you can set `"portsAttributes"`, such as a label for your forwarded ports and the action to be taken when the port is autoforwarded. - - Look back at the terminal, and you should see the output from your site navigations. - - Edit the text on line 21 in `index.php` and refresh the page to see the changes immediately take effect. -1. **Attach debugger to the server:** - - Follow the previous steps to start up a PHP server and open a browser on port `8000` - - Press F1 and select the **View: Show Debug** command. - - Pick "Listen for XDebug" from the dropdown. - - Press F5 to attach the debugger. - - Add a breakpoint to `index.php` if you haven't already. - - Reload your browser window. - - Once the breakpoint is hit, try hovering over variables, examining locals, and more. - -## Contributing - -This project welcomes contributions and suggestions. Most contributions require you to agree to a -Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us -the rights to use your contribution. For details, visit https://cla.microsoft.com. - -When you submit a pull request, a CLA-bot will automatically determine whether you need to provide -a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions -provided by the bot. You will only need to do this once across all repos using our CLA. - -This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). -For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or -contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. - -## License - -Copyright © Microsoft Corporation All rights reserved.
-Licensed under the MIT License. See LICENSE in the project root for license information. +# Try Out Development Containers: PHP + +[![Open in Remote - Containers](https://img.shields.io/static/v1?label=Remote%20-%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode-remote-try-php) + +A **development container** is a running [Docker](https://www.docker.com) container with a well-defined tool/runtime stack and its prerequisites. You can try out development containers with **[GitHub Codespaces](https://github.com/features/codespaces)** or **[Visual Studio Code Remote - Containers](https://aka.ms/vscode-remote/containers)**. + +This is a sample project that lets you try out either option in a few easy steps. We have a variety of other [vscode-remote-try-*](https://github.com/search?q=org%3Amicrosoft+vscode-remote-try-&type=Repositories) sample projects, too. + +> **Note:** If you already have a Codespace or dev container, you can jump to the [Things to try](#things-to-try) section. + +## Setting up the development container + +### GitHub Codespaces aa +Follow these steps to open this sample in a Codespace: +1. Click the Code drop-down menu and select the **Open with Codespaces** option. +1. Select **+ New codespace** at the bottom on the pane. + +For more info, check out the [GitHub documentation](https://docs.github.com/en/free-pro-team@latest/github/developing-online-with-codespaces/creating-a-codespace#creating-a-codespace). + +### VS Code Remote - Containers + +If you already have VS Code and Docker installed, you can click the badge above or [here](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode-remote-try-php) to get started. Clicking these links will cause VS Code to automatically install the Remote - Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use. + +Follow these steps to open this sample in a container using the VS Code Remote - Containers extension: + +1. If this is your first time using a development container, please ensure your system meets the pre-reqs (i.e. have Docker installed) in the [getting started steps](https://aka.ms/vscode-remote/containers/getting-started). + +2. To use this repository, you can either open the repository in an isolated Docker volume: + + - Press F1 and select the **Remote-Containers: Try a Sample...** command. + - Choose the "PHP" sample, wait for the container to start, and try things out! + > **Note:** Under the hood, this will use the **Remote-Containers: Clone Repository in Container Volume...** command to clone the source code in a Docker volume instead of the local filesystem. [Volumes](https://docs.docker.com/storage/volumes/) are the preferred mechanism for persisting container data. + + Or open a locally cloned copy of the code: + + - Clone this repository to your local filesystem. + - Press F1 and select the **Remote-Containers: Open Folder in Container...** command. + - Select the cloned copy of this folder, wait for the container to start, and try things out! + +## Things to try + +Once you have this sample opened, you'll be able to work with it like you would locally. + +> **Note:** This container runs as a non-root user with sudo access by default. Comment out `"remoteUser": "vscode"` in `.devcontainer/devcontainer.json` if you'd prefer to run as root. + +Some things to try: + +1. **Edit:** + - Open `index.php` + - Try adding some code and check out the language features. + - Notice that PHP debugging and IntelliSense are already included in the container since the `.devcontainer/devcontainer.json` lists `"felixfbecker.php-debug"`, `"bmewburn.vscode-intelephense-client"`, and `"mrmlnc.vscode-apache"` as extensions to install automatically when the container is created. +1. **Terminal:** Press ctrl+shift+\` and type `uname` and other Linux commands from the terminal window. +1. **Run and Debug:** + - Open `index.php` + - Add a breakpoint (e.g. on line 4). + - Press F5 to launch the app in the container. + - Once the breakpoint is hit, try hovering over variables, examining locals, and more. +1. **Running a server:** + - From the terminal, run `php -S 0.0.0.0:8000` + - Click "Open in Browser" in the notification that appears to access the web app on this new port. + - You can view an organized table of your forwarded ports in the 'Ports' view, which can be accessed with the command **Ports: Focus on Ports View**. + - Notice port 8000 in the 'Ports' view is labeled "Hello Remote World." In `devcontainer.json`, you can set `"portsAttributes"`, such as a label for your forwarded ports and the action to be taken when the port is autoforwarded. + - Look back at the terminal, and you should see the output from your site navigations. + - Edit the text on line 21 in `index.php` and refresh the page to see the changes immediately take effect. +1. **Attach debugger to the server:** + - Follow the previous steps to start up a PHP server and open a browser on port `8000` + - Press F1 and select the **View: Show Debug** command. + - Pick "Listen for XDebug" from the dropdown. + - Press F5 to attach the debugger. + - Add a breakpoint to `index.php` if you haven't already. + - Reload your browser window. + - Once the breakpoint is hit, try hovering over variables, examining locals, and more. + +## Contributing + +This project welcomes contributions and suggestions. Most contributions require you to agree to a +Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us +the rights to use your contribution. For details, visit https://cla.microsoft.com. + +When you submit a pull request, a CLA-bot will automatically determine whether you need to provide +a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions +provided by the bot. You will only need to do this once across all repos using our CLA. + +This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). +For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or +contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. + +## License + +Copyright © Microsoft Corporation All rights reserved.
+Licensed under the MIT License. See LICENSE in the project root for license information. diff --git a/index.php b/sample/index.php similarity index 100% rename from index.php rename to sample/index.php diff --git a/sample/llefia.PNG b/sample/llefia.PNG new file mode 100644 index 00000000..0f46d53e Binary files /dev/null and b/sample/llefia.PNG differ diff --git a/sesions/bienvenida.php b/sesions/bienvenida.php new file mode 100644 index 00000000..60fe4779 --- /dev/null +++ b/sesions/bienvenida.php @@ -0,0 +1,26 @@ + + + + + + + + + Document + + + +

datos enviados

+ Hola, " . ($_SESSION['name']) . ".

"; + echo "

Tu apellido es " . ($_SESSION['ap']) . ".

"; + echo "

Tu edad es " . ($_SESSION['edad']) . ".

"; + + ?> + + + + \ No newline at end of file diff --git a/sesions/index.php b/sesions/index.php new file mode 100644 index 00000000..b38c10e7 --- /dev/null +++ b/sesions/index.php @@ -0,0 +1,38 @@ + + + + + + + + Document + + + +
+ + +

+ + + +

+ + + +

+ + +
+ + + \ No newline at end of file diff --git a/teoria/components/footer.php b/teoria/components/footer.php new file mode 100644 index 00000000..ab00ed8e --- /dev/null +++ b/teoria/components/footer.php @@ -0,0 +1,11 @@ + + + + + + Document + + + + + \ No newline at end of file diff --git a/teoria/components/header.php b/teoria/components/header.php new file mode 100644 index 00000000..0ab9959c --- /dev/null +++ b/teoria/components/header.php @@ -0,0 +1,11 @@ + + + + + + Document + + +

header

+ + \ No newline at end of file diff --git a/teoria/concatenacion.php b/teoria/concatenacion.php new file mode 100644 index 00000000..1339453d --- /dev/null +++ b/teoria/concatenacion.php @@ -0,0 +1,13 @@ + \ No newline at end of file diff --git a/teoria/condicional.php b/teoria/condicional.php new file mode 100644 index 00000000..1985c449 --- /dev/null +++ b/teoria/condicional.php @@ -0,0 +1,16 @@ +=18){ + $soyMayor = "soy mayor de edad"; +}else{ + +$soyMayor = "soy menor de edad"; + +} + +?> \ No newline at end of file diff --git a/teoria/funciones-string.php b/teoria/funciones-string.php new file mode 100644 index 00000000..fc407463 --- /dev/null +++ b/teoria/funciones-string.php @@ -0,0 +1,94 @@ + strlen() + + $cadena = 'Hola mundo'; + + echo($cadena); + + echo strlen($cadena); + + //2. strpos + + echo strpos($cadena, 'mundo'); + + //3. str_replace + + echo str_replace("mundo", "Barcelona", $cadena); + + //4. strtolower + + echo strtolower($cadena); + + //5. strtoupper + + echo strtoupper($cadena); + + //6. ucfirst + + echo ucfirst($cadena); + + //7. ucwords + + echo ucwords($cadena); + + //8. trim (elimina los espacio en blanco al principio y final) + + $cadena2 = ' leo messi '; + echo '
'; + echo trim($cadena2); + + //9. substr() + //obtiene una parte de una cadena + + echo substr($cadena2, 4, 4); + + //10. implode + //separa una lista con el limitador que tu pongas + + $array = ["hola", "mundo", "php"]; + echo implode("", $array); + + //11. explode + //transforma una cadena en un array + + $cadena3 = "hola,mundo,php"; + $array2 = explode(",", $cadena3); + print_r($array2); + echo'
'; + + foreach($array2 as $a){ + echo $a; + }; + + //12. in_array + //mira si existe o no en un array + + $os = ["Mac", "Linux", "Windows", "Irix"]; + if(in_array("Irix", $os)){ + echo("Existe Irix"); + } + + //13. array_search + //busca valor en el array y devuelve el correspondiente + + $array3 = ["manzana", "pera", "naranja"]; + echo array_search("naranja", $array3); + + //14. array_map + + $arraymap = [1,2,3,4]; + $resultado = array_map(function($numero){ + return $numero * 2; + }, $arraymap); + print_r($resultado); // resultado array : ( [0] => 2 [1] => 4 [2] => 6 [3] => 8) + + //15. array_filter() + + $arrayfilter = [1,2,3,4,5,6,7,8,9]; + $resultado2 = array_filter($arrayfilter, function($n){ + return $n % 2 == 0; + }); + + print_r($resultado2); +?> \ No newline at end of file diff --git a/teoria/funciones.php b/teoria/funciones.php new file mode 100644 index 00000000..c45605a9 --- /dev/null +++ b/teoria/funciones.php @@ -0,0 +1,13 @@ + \ No newline at end of file diff --git a/teoria/include.php b/teoria/include.php new file mode 100644 index 00000000..e2816bf9 --- /dev/null +++ b/teoria/include.php @@ -0,0 +1,10 @@ + \ No newline at end of file diff --git a/teoria/index1-includes.php b/teoria/index1-includes.php new file mode 100644 index 00000000..3dec8e32 --- /dev/null +++ b/teoria/index1-includes.php @@ -0,0 +1,23 @@ + + + + + + Peliculas 1 + + + + +
+ +
+ + + + \ No newline at end of file diff --git a/teoria/index2-includes.php b/teoria/index2-includes.php new file mode 100644 index 00000000..d4dc5f5d --- /dev/null +++ b/teoria/index2-includes.php @@ -0,0 +1,23 @@ + + + + + + Peliculas 2 + + + + +
+ +
+ + + + \ No newline at end of file diff --git a/teoria/listas.php b/teoria/listas.php new file mode 100644 index 00000000..2dea0760 --- /dev/null +++ b/teoria/listas.php @@ -0,0 +1,73 @@ + "Albert", + "apellidos" => "Arrebola Sans", + "edad" => 36 +]; + +echo $tutor["apellidos"]; +$tutor["edad"] = 18; + +// print_r( array_keys($tutor)); + +$numeros = [1,2,3,4,5]; + +//recorrer un array con FOR + +for($i = 0; $i < count($numeros); $i++){ + echo $numeros[$i] . "
"; +} + +//recorrer un array con FOREACH + +$numeros2 = [1,2,3,4,5]; + +foreach($numeros2 as $num){ + echo $numero . ' '; +} + + +$ciudades = [ + "París" => "Francia", + "Barcelona" => "Espanya", + "Londres" => "Reino Unido" +]; + + + +foreach ($ciudades as $ciudad => $pais) { + if($ciudad == 'Barcelona'){ + echo "La ciudad de $ciudad está en $pais"; + } +} + + + +?> \ No newline at end of file diff --git a/teoria/op_asignacion.php b/teoria/op_asignacion.php new file mode 100644 index 00000000..86eef6fe --- /dev/null +++ b/teoria/op_asignacion.php @@ -0,0 +1,14 @@ + \ No newline at end of file diff --git a/teoria/p1.php b/teoria/p1.php new file mode 100644 index 00000000..5956f828 --- /dev/null +++ b/teoria/p1.php @@ -0,0 +1,11 @@ +

Hola soy p1

+ + + \ No newline at end of file diff --git a/teoria/p2.php b/teoria/p2.php new file mode 100644 index 00000000..263af444 --- /dev/null +++ b/teoria/p2.php @@ -0,0 +1,11 @@ + +
+ + + + + + + +
+ diff --git a/teoria/parametros.php b/teoria/parametros.php new file mode 100644 index 00000000..3f3177d7 --- /dev/null +++ b/teoria/parametros.php @@ -0,0 +1,13 @@ + + + + + + Document + + +

Página para enviar datos

+ + + + \ No newline at end of file diff --git a/teoria/teoria POO/index.php b/teoria/teoria POO/index.php new file mode 100644 index 00000000..005b0d29 --- /dev/null +++ b/teoria/teoria POO/index.php @@ -0,0 +1,30 @@ +nombre; + } + public function NivelDePelea() + { + return $this->nombre . "tiene un nivel de pelea de " . $this->nivel_pelea; + } +} +$objeto1 = new Saiyajin(); +var_dump($objeto1); +$objeto2 = new Saiyajin(); +var_dump($objeto2); +echo "
"; +echo $objeto1->Saludar(); +echo '
'; +echo "Mi nivel de pelea es: " . $objeto1->NivelDePelea(); diff --git a/teoria/tipos_datos.php b/teoria/tipos_datos.php new file mode 100644 index 00000000..b26b2af6 --- /dev/null +++ b/teoria/tipos_datos.php @@ -0,0 +1,31 @@ +"; +echo -72; + +// números decimales +echo 45.78; +echo -72.122290; + +echo "
"; +// datos tipo texto +echo 'HOLA MUNDO'; + +echo "
"; + +var_dump('hola mundo'); + +// función PHP VAR_DUMP +var_dump(0); +var_dump(true); +var_dump(false); + +?> \ No newline at end of file diff --git a/teoria/variables.php b/teoria/variables.php new file mode 100644 index 00000000..e9e25855 --- /dev/null +++ b/teoria/variables.php @@ -0,0 +1,20 @@ +"; +const edad = 21; +echo edad; + +?> \ No newline at end of file