Merge pull request #7062 from victor-Casta/[email protected]

#29 - JavaScript

Author: kontroldev

Roadmap/13 - PRUEBAS UNITARIAS/typescript/victor-Casta.ts

@@ -0,0 +1,84 @@
+const assert = require('assert')
+/*
+  * EJERCICIO:
+  * Crea una función que se encargue de sumar dos números y retornar
+  * su resultado.
+  * Crea un test, utilizando las herramientas de tu lenguaje, que sea
+  * capaz de determinar si esa función se ejecuta correctamente.
+*/
+
+function addition(a: number, b: number): number {
+  return a + b
+}
+
+try {
+  assert.equal(addition(1, 2), 3)
+  console.log(`Test 1: pasó. Resultado de la suma: ${addition(1, 2)}`)
+} catch (error) {
+  console.error(`Test 1: falló. Error: ${error.message}`)
+}
+
+/*
+  * Crea un diccionario con las siguientes claves y valores:
+  * "name": "Tu nombre"
+  * "age": "Tu edad"
+  * "birth_date": "Tu fecha de nacimiento"
+  * "programming_languages": ["Listado de lenguajes de programación"]
+  * Crea dos test:
+  * - Un primero que determine que existen todos los campos.
+  * - Un segundo que determine que los datos introducidos son correctos.
+*/
+
+interface Person {
+  name: string;
+  age: number;
+  birthDate: Date;
+  programmingLanguages: string[];
+}
+
+const person: Person = {
+  name: 'Victor',
+  age: 21,
+  birthDate: new Date(2002, 11, 17),
+  programmingLanguages: ['TypeScript', 'JavaScript', 'Python']
+};
+
+function validateStructure(expected: Person, actual: Person): void {
+  const expectedKeys = Object.keys(expected);
+  const actualKeys = Object.keys(actual);
+  assert.strictEqual(expectedKeys.length, actualKeys.length, 'Las estructuras no tienen el mismo número de claves.');
+  expectedKeys.forEach(key => {
+    assert.ok(actual.hasOwnProperty(key), `La propiedad "${key}" falta en el objeto real.`);
+  });
+}
+
+function validateValues(expected: Person, actual: Person): void {
+  const expectedKeys = Object.keys(expected);
+  expectedKeys.forEach(key => {
+    assert.strictEqual(typeof actual[key], typeof expected[key], `El tipo de la propiedad "${key}" no coincide.`);
+  });
+}
+
+try {
+  validateStructure({
+    name: '',
+    age: 0,
+    birthDate: new Date(2002, 11, 17),
+    programmingLanguages: ['']
+  }, person);
+  console.log('Test 1: pasó. La estructura es correcta.');
+} catch (error) {
+  console.error('Test 1: falló. Error: ', error.message);
+}
+
+try {
+  validateValues({
+    name: '',
+    age: 0,
+    birthDate: new Date(2002, 11, 17),
+    programmingLanguages: ['']
+  }, person);
+  console.log('Test 2: pasó. Los tipos son correctos.');
+} catch (error) {
+  console.error('Test 2: falló. Error: ', error.message);
+}

Roadmap/29 - SOLID ISP/javascript/victor-Casta.js

@@ -0,0 +1,160 @@
+/*
+  * EJERCICIO:
+  * Explora el "Principio SOLID de Segregación de Interfaces (Interface Segregation Principle, ISP)"
+  * y crea un ejemplo simple donde se muestre su funcionamiento de forma correcta e incorrecta.
+*/
+
+// Forma incorrecta
+/*
+  class Animal {
+    fly() {
+      console.log("Volar")
+    }
+
+    swim() {
+      console.log("Nadar")
+    }
+
+    walk() {
+      console.log("Caminar")
+    }
+  }
+
+  class Bird extends Animal {
+    fly() {
+      console.log("Volar")
+    }
+  }
+
+  class Fish extends Animal {
+    swim() {
+      console.log("Nadar")
+    }
+  }
+
+  class Dog extends Animal {
+    walk() {
+      console.log("Caminar")
+    }
+    fly() {
+      throw new Error("No puede volar")
+    }
+  }
+
+  const bird = new Bird()
+  bird.fly()
+
+  const fish = new Fish()
+  fish.swim()
+
+  const dog = new Dog()
+  dog.walk()
+
+  dog.fly()
+*/
+
+// Forma correcta
+
+class AnimalCanFly {
+  fly() {
+    console.log("Volar")
+  }
+}
+
+class AnimalCanSwim {
+  swim() {
+    console.log("Nadar")
+  }
+}
+
+class AnimalCanWalk {
+  walk() {
+    console.log("Caminar")
+  }
+}
+
+class Bird extends AnimalCanFly {
+  fly() {
+    console.log("Volar")
+  }
+}
+
+class Fish extends AnimalCanSwim {
+  swim() {
+    console.log("Nadar")
+  }
+}
+
+class Dog extends AnimalCanWalk {
+  walk() {
+    console.log("Caminar")
+  }
+}
+
+const bird = new Bird()
+const fish = new Fish()
+const dog = new Dog()
+
+bird.fly()
+fish.swim()
+dog.walk()
+
+/*
+  * DIFICULTAD EXTRA (opcional):
+  * Crea un gestor de impresoras.
+  * Requisitos:
+  * 1. Algunas impresoras sólo imprimen en blanco y negro.
+  * 2. Otras sólo a color.
+  * 3. Otras son multifunción, pueden imprimir, escanear y enviar fax.
+  * Instrucciones:
+  * 1. Implementa el sistema, con los diferentes tipos de impresoras y funciones.
+  * 2. Aplica el ISP a la implementación.
+  * 3. Desarrolla un código que compruebe que se cumple el principio.
+*/
+
+class Printable {
+  print(document) {
+    console.log(`Printing ${document}`)
+  }
+}
+
+class Scannable {
+  scan(document) {
+    console.log(`Scanning ${document}`)
+  }
+}
+
+class Faxable {
+  sendFax(document) {
+    console.log(`Sending ${document}`)
+  }
+}
+
+class BlackAndWhitePrinter extends Printable {}
+class ColorPrinter extends Printable {}
+class MultifunctionalPrinter extends Printable {
+  constructor() {
+    super()
+    this.scanner = new Scannable()
+    this.fax = new Faxable()
+  }
+
+  scan(document) {
+    this.scanner.scan(document)
+  }
+
+  sendFax(document) {
+    this.fax.sendFax(document)
+  }
+}
+
+const bwPrinter = new BlackAndWhitePrinter()
+bwPrinter.print("Document1")
+
+const colorPrinter = new ColorPrinter()
+colorPrinter.print("Document2")
+
+const multiPrinter = new MultifunctionalPrinter()
+multiPrinter.print("Document3")
+multiPrinter.scan("Document3")
+multiPrinter.sendFax("Document3")

Roadmap/30 - SOLID DIP/javascript/victor-Casta.js

@@ -0,0 +1,102 @@
+/*
+  * EJERCICIO:
+  * Explora el "Principio SOLID de Inversión de Dependencias (Dependency Inversion
+  * Principle, DIP)" y crea un ejemplo simple donde se muestre su funcionamiento
+  * de forma correcta e incorrecta.
+*/
+
+// Forma incorrecta
+
+class Game {
+  start() {
+    return 'start'
+  }
+}
+
+class getTypeOfGame {
+  constructor() {
+    this.game = new Game()
+  }
+}
+
+// Forma correcta
+
+class Game {
+  start() {
+    return 'start'
+  }
+}
+
+class GameType {
+  constructor(typeOfGame) {
+    this.typeOfGame = typeOfGame
+  }
+
+  displayGame() {
+    return this.typeOfGame.start()
+  }
+}
+
+const gameInstance = new Game()
+const gameType = new GameType(gameInstance)
+console.log(gameType.displayGame())
+
+/*
+  * DIFICULTAD EXTRA (opcional):
+  * Crea un sistema de notificaciones.
+  * Requisitos:
+  * 1. El sistema puede enviar Email, PUSH y SMS (implementaciones específicas).
+  * 2. El sistema de notificaciones no puede depender de las implementaciones específicas.
+  * Instrucciones:
+  * 1. Crea la interfaz o clase abstracta.
+  * 2. Desarrolla las implementaciones específicas.
+  * 3. Crea el sistema de notificaciones usando el DIP.
+  * 4. Desarrolla un código que compruebe que se cumple el principio.
+*/
+
+class Notification {
+  send(message) {
+    throw new Error('Método send() debe ser implementado')
+  }
+}
+
+class EmailNotification extends Notification {
+  send(email) {
+    console.log(`Sending Email: ${email}`)
+  }
+}
+
+class PushNotification extends Notification {
+  send(push) {
+    console.log(`Sending Push: ${push}`)
+  }
+}
+
+class SMSNotification extends Notification {
+  send(sms) {
+    console.log(`Sending SMS: ${sms}`)
+  }
+}
+
+class NotificationSystem {
+  constructor(notificationService) {
+    this.notificationService = notificationService
+  }
+
+  sendNotification(message) {
+    this.notificationService.send(message)
+  }
+}
+
+const emailService = new EmailNotification()
+const pushService = new PushNotification()
+const smsService = new SMSNotification()
+
+const emailSystem = new NotificationSystem(emailService)
+emailSystem.sendNotification('Hello via Email')
+
+const pushSystem = new NotificationSystem(pushService)
+pushSystem.sendNotification('Hello via Push')
+
+const smsSystem = new NotificationSystem(smsService)
+smsSystem.sendNotification('Hello via SMS')