Merge pull request mouredev#3742 from Uyarra73/main

#2 - JavaScript

Author: kontroldev

Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript/uyarra73.js

@@ -0,0 +1,218 @@
+// Operadores aritméticos:
+
+    // Operador + (Suma)
+        let a = 10;
+        let b = 5;
+        console.log(a + b);
+
+    // Operador - (Resta)
+        console.log(a - b);
+    
+    // Operador * (Multiplicación)
+        console.log(a * b);
+    
+    // Operador / (División)
+        console.log(a / b);
+    
+    // Operador % (Módulo)
+        console.log(a % b);
+    
+    // Operador ++ (Incremento)
+        console.log(++a);
+    
+    // Operador -- (Decremento)
+        console.log(--b);
+    
+    // Operador ** (Potencia)
+        console.log(a ** b);
+
+// Operadores de asignación:
+
+    // Operador = (Asignación)
+        let numero = 5;
+        console.log(numero);
+
+    // Operador += (Asignación de suma)
+        numero += 5;
+        console.log(numero);
+    
+    // Operador -= (Asignación de resta)
+        numero -= 5;
+        console.log(numero);
+    
+    // Operador *= (Asignación de multiplicación)
+        numero *= 5;
+        console.log(numero);
+    
+    // Operador /= (Asignación de división)
+        numero /= 5;
+        console.log(numero);
+    
+    // Operador %= (Asignación de módulo)
+        numero %= 5;
+        console.log(numero);
+
+
+// Operadores de comparación:
+
+    // Operador == (Igualdad)
+        console.log(5 == '5');  // true
+    
+    // Operador === (Igualdad estricta)
+        console.log(5 === '5'); // false
+
+    // Operador Desigualdad !==
+        console.log(5!== '5'); // true
+    
+    // Operador > (Mayor que)
+        console.log(10 > 5); // true
+    
+    // Operador < (Menor que)
+        console.log(5 < 10); // true
+    
+    // Operador >= (Mayor o igual que)
+        console.log(5 >= 5); // true
+    
+    // Operador <= (Menor o igual que)
+        console.log(5 <= 5); // true
+    
+
+// Operadores lógicos:
+
+    // Operador && (AND lógico)
+        console.log(10 + 3 == 13 && 5 - 1 == 4); // true
+    
+    // Operador || (OR lógico)
+        console.log(10 + 3 == 13 || 5 - 1 == 4); // true
+    
+    // Operador NOT logico !
+        console.log(!(10 + 3 == 13)); // true
+
+
+// Operadores de bit a bit:
+
+    // Operador & (AND)
+        console.log(10 & 3); // 2
+    
+    // Operador | (OR)
+        console.log(10 | 3); // 11
+    
+    // Operador ^ (XOR)
+        console.log(10 ^ 3); // 9
+    
+    // Operador ~ (NOT)
+        console.log(~10); // -11
+    
+    // Operador << (Desplazamiento a la izquierda)
+        console.log(10 << 3); // 80
+    
+    // Operador >> (Desplazamiento a la derecha)
+        console.log(10 >> 3); // 2
+    
+    // Operador >>> (Desplazamiento a la derecha sin signo)
+        console.log(10 >>> 3); // 2
+
+
+// Operadores de cadena:
+
+    // Operador + (Concatenación de cadenas)
+        console.log('Hola' +'mundo'); // Hola mundo
+    
+    // Operador += (Asignación de concatenación)
+        let cadena = 'Hola';
+        cadena +='mundo';
+        console.log(cadena); // Hola mundo
+
+
+// Operadores de tipo:
+
+    // Operador typeof (Devuelve el tipo de una variable)
+        console.log(typeof 10); // number
+    
+    // Operador instanceof (Devuelve verdadero si un objeto es una instancia de un objeto)
+        console.log(10 instanceof Number); // true
+
+// Operadores unarios:
+
+    // Operador + (Conversión a número)
+        let str = "123";
+        let numerito = +str;
+        console.log(numerito); // 123
+        console.log(typeof numerito); // "number"
+
+   // Operador - (Negación unaria)
+        let number = -3;
+        let negatedNum = -number;
+        console.log(negatedNum); // 3
+   
+   // Operador NOT lógico ! 
+        let boolean = true;
+        let notBoolean =!boolean;
+        console.log(notBoolean); // false
+   
+   // Operador delete (Elimina una propiedad de un objeto)
+        let obj = {a: 1, b: 2};
+        delete obj.a;
+        console.log(obj); // {b: 2}
+   
+   // Operador void (Evalúa una expresión y devuelve undefined)
+        void 0; // undefined
+   
+   // Operador typeof (Devuelve el tipo de una variable)
+        console.log(typeof 10); // "number"
+
+   // Operador ~ (NOT a nivel de bits): invierte el valor binario de una variable
+
+        let num = 5;          // 5 en binario es 00000000000000000000000000000101
+        let inverted = ~num;  // ~5 en binario es 11111111111111111111111111111010
+        console.log(inverted); // -6
+   
+
+// Operadores ternarios:
+
+    let edad = 18;
+    let voto = edad >= 18 ? "Puede votar" : "No puede votar";
+    console.log(voto); // "Puede votar"
+
+
+// Operadores de coma (para evaluar multiples expresiones en una declaracion):
+
+    for (let i = 0, j = 2; i <= j; i++, j--){
+        console.log(i, j); // 0 1, 1 0, 2 1
+    }
+
+// Operadores relacional in : Verifica si una propiedad concreta existe en un objeto.
+
+    let persona = {
+        nombre: "Juan",
+        edad: 30
+    };
+
+    console.log("nombre" in persona); // true
+    console.log("edad" in persona); // true
+    console.log("direccion" in persona); // false
+
+/* Ejercicio extra:
+Crea un programa que imprima por consola todos los números comprendidos
+entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3. */
+
+let numbers = [];
+
+for (let i = 10; i <= 55; i++){
+  if (i % 3 === 0){
+    continue;
+  } else if (i % 2 !== 0){
+    continue;
+  } else if (i === 16){
+    continue;
+  } else {
+    numbers.push(i);
+  }
+}
+
+console.log(numbers);
+
+
+
+
+

Roadmap/02 - FUNCIONES Y ALCANCE/javascript/uyarra73.js

@@ -0,0 +1,83 @@
+// Función sin parámetros ni retorno
+function saludo() {
+    console.log("Hola, JavaScript!");
+}
+
+// Función con un parámetro
+function saludoNombre(name) {
+    console.log("Hola, " + name + "!");
+}
+
+// Función con varios parámetros
+function suma(a, b) {
+    console.log(a + b);
+}
+
+// Función con retorno
+function producto(a, b) {
+    return a * b;
+}
+
+console.log(producto(2,3));
+
+// Funciones dentro de funciones
+function funcionExterior(x) {
+    function funcionInterior(y) {
+        return x + y;
+    }
+
+    return funcionInterior;
+}
+
+let addSix = funcionExterior(6);
+console.log(addFive(3)); // 8
+
+// Uso de funciones nativas
+let numeros = [1, 2, 3, 4, 5];
+let numerosCuadrado = numeros.map(function(number) {
+    return number * number;
+});
+
+console.log(numerosCuadrado); // [1, 4, 9, 16, 25]
+
+// Variables locales y globales
+let variableGlobal = 'Soy global';
+console.log(variableGlobal);
+function imprimirVariable() {
+    let variableLocal = "Soy local";
+    return variableGlobal + ". " + variableLocal; // "Soy global. Soy Local"
+}
+console.log(imprimirVariable());
+console.log(variableLocal);
+
+
+// Ejercicio extra
+
+/* DIFICULTAD EXTRA (opcional):
+ * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número.
+ * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que:
+ *   - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro.
+ *   - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro.
+ *   - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas.
+ *   - La función retorna el número de veces que se ha impreso el número en lugar de los textos. */
+
+
+function exercise(str1, str2) {
+    let contador = 0;
+    let arr = []
+    for (let i = 1; i <= 100; i++) {
+        if (i % 3 === 0 && i % 5 === 0) {
+            arr.push(`${str1} y ${str2}`);
+        } else if (i % 3 === 0) {
+            arr.push(str1);
+        } else if (i % 5 === 0) {
+            arr.push(str2);
+        } else {
+            arr.push(i);
+            contador++;
+        }
+    }
+    return `${arr} Se han imprimido un total de ${contador} numeros.`;
+}
+
+console.log(exercise("Multiplo de 3", "Multiplo de 5"));