Contenido del curso
Lucas Alejandro Nasich
student•
hace 6 años
Jhon Edward Bedoya
student•
hace 6 años
Sergio Rubiano
student•
hace 6 años
Contenido del curso
Lucas Alejandro Nasich
Jhon Edward Bedoya
Sergio Rubiano
María Sierra
Rolando Mamani Salas
Lucas Frezzini
Luis Eduardo Rodríguez Ramírez
Jaime Frank Villanueva Oré
Angel Javier Sanchez Tenjo
Bernardo Aguayo Ortega
Edwar Enrique Vilchez Serrano
Jhonathan Alfonso
Christian David Sánchez
Carlos Eduardo Gomez García
Alex Maldonado
Luis Suárez
Luis Suárez
Kenet Andrés Chungandro Montenegro
Dual.victoria.solis
Adrian Mansilla Salas
Claudio Pedalino
José Gregorio Block
Jimmy Buriticá Londoño
SEBASTIAN SALAZAR
José Luis Caicedo Lara
GARCIA CAMARENA EZEQUIEL
Efraín Hernández García
Bernardo Aguayo Ortega
Moisés Cedeño
Alejandro Silva Berbesi
Guillermo García López
Andre Huaman Yovera
Juan Pablo Campuzano Monsalve
Lisandro Caballero
Algo me dice que nos quedamos re cortos con solo estos tres patrones de diseño.
Fuck! 🤦🏼♂️
Mauro explico los patrones muy por encima, seria bueno un curso de solo patrones de diseño
Command
Se trata de un patrón de comportamiento, y este se utiliza cuando existe alguna operación especialmente compleja que debe ser realizada desde diferentes puntos de entrada.
¿Qué es una interfaz y qué son las clases abstractas?
La siguiente explicación menciona a Java pero se puede aplicar a muchos lenguajes de programación las misma definiciones:
🙀
Las clases abstractas cuando tienen métodos define lo que tienen qué hacer pero no cómo se debe de hacer. Estas clases pueden ser heredadas por X clases que necesitemos pero no pueden ser instanciadas.
En Java no se puede heredar de más de una clase, para esto utilizamos las interfaces. Aquí igual se especifica qué se debe de hacer pero no el cómo.
A diferencia de una clase abstracta una interfaz no puede hacer nada por si sola, o sea, que las clases hijas están encargadas de definir el comportamiento de todos los métodos abstractos de forma obligatoria.
En otra palabras, las interfaces serán contratos que indicarán que es lo que se debe de hacer sin proveer ninguna funcionalidad.
Muchas Gracias
Como estamos dentro de la carrera de PHP y como solo vimos tres Patrones de diseño de los tantos que hay, dejo un repositorio donde aplican la mayoria, desconozco si existen más (seguramente), en PHP y estan super explicados y con ejemplos. Link a GitHub DesignPatternsPHP
Está genial el repositorio! gracias!
un poco mas de lectura sobre este patron de diseño
https://www.oscarblancarteblog.com/2014/11/19/patron-de-diseno-command/
Bro Muchas Gracias, muy completo la explicación del patron command
Gracias Jaime!!
El mejor recurso que pueden encontrar para patrones de diseño: DESIGN PATTERNS
Command: Convierte una solicitud en un objeto independiente que contiene toda la información sobre la solicitud. Esta transformación permite parametrizar métodos con diferentes solicitudes, retrasar o poner en cola la ejecución de una solicitud y respaldar operaciones que no se pueden deshacer.
Prácticamente se refiere a unificar las tareas en una sola clase, que será la encargada de uinificar esos puntos de entrada ejecutar todos los procesos necesarios.
Para más info sobre patrones de diseño:
Singleton en una conexion a Base de Datos
class Conexion{ public $con = NULL; protected function obj_db(){ // Poner en forma externa la conexion de base de datos. $driver = "mysql"; $servername = "localhost"; $username = "name"; $password = "password"; $charset= "SET NAMES utf8"; $dbname = "zulibans_msg"; try { $this->con = new \PDO("$driver:host=$servername;dbname=$dbname;$charset", $username, $password); // set the PDO error mode to exception $this->con->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION); return $this->con; }catch(PDOException $e){ echo "Ya se rompió => " . $e->getMessage(); } } }
Por cierto para poder usar esto es necesario usarla como herencia y ahí generar la conexion por ejemplo un execute() Ejemplo
class execute extends Conexion { private $ctr; // Private para ayudar a la seguridad. // Instanciamos el metodo que contiene la conexion en el padre function __construct(){ $this->ctr = parent::obj_db(); }
No olvides agregar un método para ejecutar query y cerrar la conexion dentro de este mismo método.
Saludos.
¿Dónde haces tus apuntes? Se ven muy limpios y claros
Ustedes creen que algunos patrones son conclusiones logicas a las que se llega con la practica? es decir que empiezas a solucionar problemas de manera muy similar a un patron, pero no sabias que ese era un patron, o para que sirve
He aqui el Santo Grial para la introduccion a los patrones de diseño => https://sourcemaking.com/design_patterns
#Excelente
Deberían crear un curso de patrones de diseño, o ya existe?
Aquí hay uno enfocado en android https://platzi.com/clases/patrones-android/
cuando utilizamos en la consola el comando echo, no conocemos el contenido solo esperamos a que imprima en pantalla
Resumen. Se trata de un patrón de comportamiento y se utiliza usualmente cuando existe una operación compleja y debe de ser realizada desde diferentes puntos de entrada, típicamente cuando desarrollamos una aplicación web y debes realizar la misma operación desde la web ósea responder a una consulta a un visitante como a través de la línea de comandos. Entonces ahí tal vez conviene agrupar esta funcionalidad en una clase que sea capaz de llevar esta tarea.
Es un excelente resumen de esta clase!
bro no entendía bien, gracias por ayudar!!
¿Libros en dónde se detallen estos principios?
Este sitio web me parece muy bueno:
Un ejemplo que combina los tres patrones en un sistema simple de gestión de notificaciones:
\<?php // ===================================== // SINGLETON - Gestor de Configuración // ===================================== class ConfigurationManager {   private static $instance = null;   private $configs = \[];       private function \_\_construct() {   $this->configs = \[   'email' => 'notifications@empresa.com',   'sms\_api\_key' => 'abc123',   'push\_server' => 'https://push.empresa.com'   ];   }       public static function getInstance() {   if (self::$instance === null) {   self::$instance = new self();   }   return self::$instance;   }       public function getConfig($key) {   return $this->configs\[$key] ?? null;   } } // ===================================== // FACTORY - Creación de Notificaciones // ===================================== interface INotification {   public function send($message); } class EmailNotification implements INotification {   public function send($message) {   $config = ConfigurationManager::getInstance();   echo "Enviando email desde: " . $config->getConfig('email') . "\n";   echo "Mensaje: $message\n";   } } class SMSNotification implements INotification {   public function send($message) {   $config = ConfigurationManager::getInstance();   echo "Enviando SMS usando API key: " . $config->getConfig('sms\_api\_key') . "\n";   echo "Mensaje: $message\n";   } } class PushNotification implements INotification {   public function send($message) {   $config = ConfigurationManager::getInstance();   echo "Enviando Push desde: " . $config->getConfig('push\_server') . "\n";   echo "Mensaje: $message\n";   } } class NotificationFactory {   public function createNotification($type): INotification {   switch ($type) {   case 'email':   return new EmailNotification();   case 'sms':   return new SMSNotification();   case 'push':   return new PushNotification();   default:   throw new Exception("Tipo de notificación no válido");   }   } } // ===================================== // COMMAND - Comandos de Notificación // ===================================== interface Command {   public function execute();   public function undo(); } class SendNotificationCommand implements Command {   private $notification;   private $message;   private $log = \[];       public function \_\_construct(INotification $notification, $message) {   $this->notification = $notification;   $this->message = $message;   }       public function execute() {   $this->notification->send($this->message);   $this->log\[] = "Enviado: " . $this->message;   }       public function undo() {   if (!empty($this->log)) {   $lastMessage = array\_pop($this->log);   echo "Cancelando notificación: $lastMessage\n";   }   } } class NotificationInvoker {   private $history = \[];       public function executeCommand(Command $command) {   $command->execute();   $this->history\[] = $command;   }       public function undoLastCommand() {   if (!empty($this->history)) {   $command = array\_pop($this->history);   $command->undo();   }   } }
**Uso del sistema combinado:**
// Cliente que usa los tres patrones try {   // Crear el factory   $factory = new NotificationFactory();       // Crear el invocador   $invoker = new NotificationInvoker();       // Crear y ejecutar comando de email   $emailNotification = $factory->createNotification('email');   $emailCommand = new SendNotificationCommand($emailNotification, "¡Importante! Reunión mañana");   $invoker->executeCommand($emailCommand);       // Crear y ejecutar comando de SMS   $smsNotification = $factory->createNotification('sms');   $smsCommand = new SendNotificationCommand($smsNotification, "Recordatorio: Entrega pendiente");   $invoker->executeCommand($smsCommand);       // Crear y ejecutar comando de Push   $pushNotification = $factory->createNotification('push');   $pushCommand = new SendNotificationCommand($pushNotification, "Nueva actualización disponible");   $invoker->executeCommand($pushCommand);       // Deshacer última notificación   echo "\nDeshaciendo última notificación:\n";   $invoker->undoLastCommand();     } catch (Exception $e) {   echo "Error: " . $e->getMessage(); }
**Explicación de cómo trabajan juntos los patrones:**
1. **Singleton (ConfigurationManager)**:
- Mantiene una única instancia de la configuración del sistema
- Es utilizado por las diferentes notificaciones para obtener sus configuraciones
2. **Factory (NotificationFactory)**:
- Crea los diferentes tipos de notificaciones
- Oculta la lógica de creación de los objetos de notificación
3. **Command (SendNotificationCommand)**:
- Encapsula la operación de envío de notificaciones
- Permite deshacer operaciones
- Mantiene un historial de las notificaciones enviadas
**Salida esperada:**
Enviando email desde: <notifications@empresa.com> Mensaje: ¡Importante! Reunión mañana Enviando SMS usando API key: abc123 Mensaje: Recordatorio: Entrega pendiente Enviando Push desde: Mensaje: Nueva actualización disponible Deshaciendo última notificación: Cancelando notificación: Enviado: Nueva actualización disponible
Este ejemplo muestra cómo los tres patrones pueden trabajar juntos:
- **Singleton** gestiona la configuración global
- **Factory** crea los diferentes tipos de notificaciones
- **Command** maneja la ejecución y el control de las notificaciones
Es un sistema extensible que permite:
- Agregar nuevos tipos de notificaciones
- Mantener un historial de notificaciones
- Deshacer operaciones
- Gestionar la configuración de manera centralizada
Realicé una calculadora utilizando el patrón de diseños Singleton:
<?php class Calculator { // Propiedad estática privada que almacena la única instancia de la clase private static $instance = null; // Constructor privado para prevenir la creación de instancias directas private function __construct() { } // Método estático público para acceder a la instancia public static function getInstance() { if (self::$instance === null) { self::$instance = new Calculator(); } return self::$instance; } // Método para sumar dos números public function add($a, $b) { return $a + $b; } // Método para restar dos números public function subtract($a, $b) { return $a - $b; } // Método para multiplicar dos números public function multiply($a, $b) { return $a * $b; } // Método para dividir dos números public function divide($a, $b) { if ($b == 0) { throw new Exception("Division by zero."); } return $a / $b; } } // Usando la calculadora try { // Obtiene la única instancia de Calculator $calc = Calculator::getInstance(); // Realiza operaciones $sum = $calc->add(10, 5); $sub = $calc->subtract(10, 5); $mul = $calc->multiply(10, 5); $div = $calc->divide(10, 5); echo "Sum: $sum\n"; echo "Subtract: $sub\n"; echo "Multiply: $mul\n"; echo "Divide: $div\n"; } catch (Exception $e) { echo "Error: " . $e->getMessage(); } ```\<?php class Calculator { *// Propiedad estática privada que almacena la única instancia de la clase* *private* *static* $instance = null; *// Constructor privado para prevenir la creación de instancias directas* *private* function \_\_construct() { } *// Método estático público para acceder a la instancia* *public* *static* function getInstance() { if (self::$instance === null) { self::$instance = new Calculator(); } *return* self::$instance; } *// Método para sumar dos números* *public* function add($a, $b) { *return* $a + $b; } *// Método para restar dos números* *public* function subtract($a, $b) { *return* $a - $b; } *// Método para multiplicar dos números* *public* function multiply($a, $b) { *return* $a \* $b; } *// Método para dividir dos números* *public* function divide($a, $b) { if ($b == 0) { throw new Exception("Division by zero."); } *return* $a / $b; }} *// Usando la calculadora* try { *// Obtiene la única instancia de Calculator* $calc = Calculator::getInstance(); *// Realiza operaciones* $sum = $calc->add(10, 5); $sub = $calc->subtract(10, 5); $mul = $calc->multiply(10, 5); $div = $calc->divide(10, 5); echo "Sum: $sum\n"; echo "Subtract: $sub\n"; echo "Multiply: $mul\n"; echo "Divide: $div\n";} catch (Exception $e) { echo "Error: " . $e->getMessage();}
https://refactoring.guru/es/design-patterns
Les recomiendo este link con ejemplos practicos