Merge pull request mouredev#7710 from wapastorv/main

#18 - Javascript

Author: kontroldev

Roadmap/18 - CONJUNTOS/javascript/wapastorv.js

@@ -54,36 +54,75 @@ console.log(arregloDeNumeros.includes(5)); // true
 const array1 = [1, 2, 3, 6];
 const array2 = [1, 2, 3, 4, 5];
 
+console.log("Arreglo original 1: ",array1);
+console.log("Arreglo original 2: ",array2);
+
+// Crear conjuntos a partir de arreglos
+const conjuntoA = new Set(array1);
+const conjuntoB = new Set(array2);
+
 // Operaciones de conjuntos con arreglos en JavaScript usando Set y Arreglos directamente
-// Set es una estructura de datos que no permite elementos duplicados
-const unionArraySet = new Set([...array1, ...array2]);
-console.log("Union de conjuntos con SET: ",unionArraySet); // [1, 2, 3, 1, 2, 3, 4, 5]
+// Set es una estructura de datos que no permite elementos duplicados, por lo que es ideal para trabajar con conjuntos.
+
+// Union de conjuntos
 
-// Arreglos directamente
+function unionConSet(setA, setB) {
+    return new Set([...setA, ...setB]);
+}
+
+console.log("Union de conjuntos con SET: ",unionConSet(conjuntoA,conjuntoB)); // [1, 2, 3, 1, 2, 3, 4, 5]
+
+// Union mantenimentdo la estructua de arreglo
 const unionArray = (array1, array2) => {
     return [...new Set([...array1, ...array2])];
 }
 console.log("Union de arreglos",unionArray(array1, array2)); // [1, 2, 3, 4, 5, 6]
 
 
-// Intersección de conjuntos
-// Set es una estructura de datos que no permite elementos duplicados
-const conjuntoA = new Set(array1);
-const conjuntoB = new Set(array2);
 
-const intersectionArraySet =conjuntoA.filter(x => conjuntoB.has(x));
-console.log("Intersecion de conjuntos con SET",intersectionArraySet); // [1, 2, 3]
-// Intersección de arreglos directamente
+// Intersección de conjuntos
+// La intersección contiene solo los elementos que están en ambos conjuntos.
 
+function intersectionConSet(setA, setB) {
+    return new Set([...setA].filter(x => setB.has(x)));
+}
+console.log("Intersecion de conjuntos con SET",intersectionConSet(conjuntoA,conjuntoB)); // [1, 2, 3]
 
+// Intersección mantenimentdo la estructua de arreglo
 const intersectionArray = (array1, array2) => {
     return array1.filter(value => array2.includes(value));
 }
 console.log("Intersecion de arreglos",intersectionArray(array1, array2)); // [1, 2, 3]
 
 
+// Difference de conjuntos
+// La diferencia contiene los elementos que están en el primer conjunto pero no en el segundo.
+
+// Diferencia con la estructura de set
+const differenceArraySet = (setA, setB) => {
+    return new Set([...setA].filter(x => !setB.has(x)));
+}
+console.log("Diferencia con la estrucura de set: ",differenceArraySet(conjuntoA,conjuntoB)); // [6]
+
+// Diferencia con la estructura de arreglos
+const differenceArray = (array1, array2) => {
+    return array1.filter(value => !array2.includes(value));
+}
+console.log("Diferencia con la estructura de arreglos: ",differenceArray(array1, array2)); // [6]
+
+// Diferencia simétrica de conjuntos
+// La diferencia simétrica contiene los elementos que están en uno de los conjuntos pero no en ambos.
 
+//Diferencia simétrica con la estructura de set
+const symmetricDifferenceArraySet = (setA, setB) => {
+    return new Set([...setA].filter(x => !setB.has(x)).concat([...setB].filter(x => !setA.has(x))))
+}
+console.log("Diferencia simétrica con la estructura de set: ",symmetricDifferenceArraySet(conjuntoA,conjuntoB)); // [4, 5, 6]
+
+// Diferencia simétrica con la estructura de arreglos
+const symmetricDifferenceArray = (array1, array2) => {
+    return array1.filter(value => !array2.includes(value)).concat(array2.filter(value => !array1.includes(value)));
+}
 
-const differenceArraySet = new Set(array1.filter(x => !array2.includes(x)));
-console.log(differenceArraySet); // [6]
+console.log("Diferencia simétrica con la estructura de arreglos: ",symmetricDifferenceArray(array1, array2)); // [4, 5, 6]
 

Roadmap/19 - ENUMERACIONES/javascript/wapastor.js

@@ -0,0 +1,74 @@
+// ENUMS en JavaScript
+/*
+Los enums en JavaScript son una forma de crear un conjunto de constantes que pueden ser utilizadas en cualquier parte de nuestro código.
+los enumeradores (enums) no existen como una característica nativa del lenguaje, pero podemos simularlos utilizando objetos o técnicas específicas.
+*/
+
+// Definimos un objeto con las constantes que necesitamos
+const diasDeLaSemana = {
+    LUNES: 1,
+    MARTES: 2,
+    MIERCOLES: 3,
+    JUEVES: 4,
+    VIERNES: 5,
+    SABADO: 6,
+    DOMINGO: 7
+};
+
+// Utilizamos las constantes en nuestro código, por ejemplo:
+
+let dia = diasDeLaSemana.LUNES;
+console.log(dia); // 1
+
+// Podemos utilizar un switch para hacer algo diferente dependiendo del valor de la constante:
+switch (dia) {
+    case diasDeLaSemana.LUNES:
+        console.log('Hoy es Lunes');
+        break;
+    case diasDeLaSemana.MARTES:
+        console.log('Hoy es Martes');
+        break;
+    case diasDeLaSemana.MIERCOLES:
+        console.log('Hoy es Miércoles');
+        break;
+    case diasDeLaSemana.JUEVES:
+        console.log('Hoy es Jueves');
+        break;
+    case diasDeLaSemana.VIERNES:
+        console.log('Hoy es Viernes');
+        break;
+    case diasDeLaSemana.SABADO:
+        console.log('Hoy es Sábado');
+        break;
+    case diasDeLaSemana.DOMINGO:
+        console.log('Hoy es Domingo');
+        break;
+    default:
+        console.log('Día no válido');
+}
+
+// Podemos hacer un bucle para recorrer todas las constantes:
+for (let dia in diasDeLaSemana) {
+    console.log(diasDeLaSemana[dia]);
+}
+
+// Podemos obtener el nombre de la constante a partir de su valor:
+function getDia(dia) {
+    for (let d in diasDeLaSemana) {
+        if (diasDeLaSemana[d] === dia) {
+            return d;
+        }
+    }
+    return null;
+}
+
+console.log(getDia(1)); // LUNES
+
+function obtenerNombreDelDia(valor){
+    const clave = Object.keys(diasDeLaSemana).find(key => diasDeLaSemana[key] === valor);
+    
+    return clave || 'No existe';
+}
+
+console.log(obtenerNombreDelDia(1)); // LUNES
+console.log(obtenerNombreDelDia(8)); // No existe