diff --git a/Basic/.vscode/settings.json b/Basic/.vscode/settings.json new file mode 100644 index 00000000..54e8e490 --- /dev/null +++ b/Basic/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "CodeGPT.apiKey": "Ollama" +} diff --git a/Basic/propios/00-helloworld.js b/Basic/propios/00-helloworld.js new file mode 100644 index 00000000..c024b831 --- /dev/null +++ b/Basic/propios/00-helloworld.js @@ -0,0 +1,11 @@ +/* + let nombre = "Exe"; + + let edad = 10; + + let direccion = "Ituzaingo 250"; +*/ + +// console.log(nombre); + +// console.log(edad); diff --git a/Basic/propios/01-variables.js b/Basic/propios/01-variables.js new file mode 100644 index 00000000..e0599725 --- /dev/null +++ b/Basic/propios/01-variables.js @@ -0,0 +1,26 @@ +// var + +var helloWorld = "¡Hola, JavaScript!"; +console.log(helloWorld); + +helloWorld = "¡Hola de nuevo, JavaScript!"; +console.log(helloWorld); + +// let + +let helloWorld2 = "¡Hola, JavaScript 2!"; +console.log(helloWorld2); + +helloWorld2 = "¡Hola de nuevo, JavaScript 2!"; +console.log(helloWorld2); + +// const + +const helloWorld3 = "¡Hola, JavaScript 3!"; +console.log(helloWorld3); + +// Error +helloWorld3 = "¡Hola de nuevo, JavaScript 3!"; +console.log(helloWorld3); + +console.log(nombre1); diff --git a/Basic/propios/02-dataTypes.js b/Basic/propios/02-dataTypes.js new file mode 100644 index 00000000..551ffe1d --- /dev/null +++ b/Basic/propios/02-dataTypes.js @@ -0,0 +1,49 @@ +// TIPOS DE DATOS PRIMITIVOS + +// string +let name = "Exequiel"; +let apellido = "Guiñazu"; +let saludo = `Hola!!! bienvenido ${name} ${apellido}`; + +// number +let age = 30; // entero +let height = 1.77; // decimal +let random = Math.floor(Math.random() * 10); // del 0 al 9 (porque floor redondea hacia abajo) +// let random = Math.floor(Math.random() * 10); // del 0 al 99 +console.log("RANDOM: ", random); + +// boolean +let isStudent = false; +let isDeveloper = true; + +// undefined +let undefinedValue; +// console.log(undefinedValue); + +// null +let nullValue = null; +// console.log(nullValue); + +// symbol +let mySymbol = Symbol("mysymbol"); // no se puede comparar, son valores unicos +// console.log(mySymbol); + +// bigInt +let myBigInt = BigInt(12309871209837219783612873621362387); +let myBigInt2 = 12309871209837219783612873621362387n; + +let type = typeof 15.5; +// console.log(myBigInt); +// console.log(myBigInt2); + +// Mostrar los tipos de datos +console.log(typeof name); +console.log(typeof age); +console.log(typeof height); +console.log(typeof isStudent); +console.log(typeof isDeveloper); +console.log(typeof undefinedValue); +console.log(typeof nullValue); +console.log(typeof mySymbol); +console.log(typeof myBigInt); +console.log(typeof myBigInt2); diff --git a/Basic/propios/03-beginner-exercises.js b/Basic/propios/03-beginner-exercises.js new file mode 100644 index 00000000..32cf73e9 --- /dev/null +++ b/Basic/propios/03-beginner-exercises.js @@ -0,0 +1,79 @@ +// 1. Escribe un comentario en una línea +// comentario en una sola linea + +// 2. Escribe un comentario en varias líneas +/* + En varias lineas +*/ + +// 3. Declara variables con valores asociados a todos los datos de tipo primitivos +let name = "Exe"; +let age = 30; +let height = 1.77; +let isDeveloper = true; +let undefinedValue; +let nullValue = null; +let mySymbol = Symbol("nuevoSymbol"); +let myBigInt = BigInt(12309871209837219783612873621362387); + +// 4. Imprime por consola el valor de todas las variables +console.log("name: ", name); +console.log("age: ", age); +console.log("height: ", height); +console.log("isDeveloper: ", isDeveloper); +console.log("undefinedValue: ", undefinedValue); +console.log("nullValue: ", nullValue); +console.log("mySymbol: ", mySymbol); +console.log("myBigInt: ", myBigInt); + +// 5. Imprime por consola el tipo de todas las variables +console.log("name: ", typeof name); +console.log("age: ", typeof age); +console.log("height: ", typeof height); +console.log("isDeveloper: ", typeof isDeveloper); +console.log("undefinedValue: ", typeof undefinedValue); +console.log("nullValue: ", typeof nullValue); +console.log("mySymbol: ", typeof mySymbol); +console.log("myBigInt: ", typeof myBigInt); + +// 6. A continuación, modifica los valores de las variables por otros del mismo tipo +name = "Cristian"; +age = 25; +height = 1.7; +isDeveloper = false; +undefinedValue = undefined; +nullValue = null; +mySymbol = Symbol("nuevoSymbol"); +myBigInt = BigInt(12309871209837219783612873621362387); + +// 7. A continuación, modifica los valores de las variables por otros de distinto tipo +name = 5; +age = "Cristian"; +height = true; +isDeveloper = 1.7; +undefinedValue = null; +nullValue = undefined; +mySymbol = 123; +myBigInt = "Numero"; + +// 8. Declara constantes con valores asociados a todos los tipos de datos primitivos +const NAME = "Exequiel"; +const AGE = 30; +const HEIGHT = 1.77; +const IS_DEVELOPER = true; +// const UNDEFINED_VALUE +const NULL_VALUE = null; +const MY_SYMBOL = Symbol("nuevoSymbol"); +const MY_BIG_INT = BigInt(12309871209837219783612873621362387); + +// 9. A continuación, modifica los valores de las constantes +// NAME = "Cristian" +// AGE = 25 +// HEIGHT = 1.70 +// IS_DEVELOPER = false +// UNDEFINED_VALUE = undefined +// NULL_VALUE = null +// MY_SYMBOL = Symbol("nuevoSymbol") +// MY_BIG_INT = BigInt(12309871209837219783612873621362387) + +// 10. Comenta las líneas que produzcan algún tipo de error al ejecutarse diff --git a/Basic/propios/04-operators.js b/Basic/propios/04-operators.js new file mode 100644 index 00000000..c6af2cda --- /dev/null +++ b/Basic/propios/04-operators.js @@ -0,0 +1,121 @@ +// Los operadores se utilizan para relacionar los datos, operar e interactuar con los datos + +// operadores aritmeticos (son las operaciones de aritmetica que YA sabemos hacer) + +let valorA = 5; +let valorB = 3; + +// comunes +console.log(5 + 10); // suma +console.log(5 - 10); // resta +console.log(5 * 10); // multiplicación +console.log(5 / 10); // división +// ------------------------------------------------------------------------- +// ------------------------------------------------------------------------- + +// otros +console.log(113 % 100); //módulo o resto de una división +console.log(valorA ** valorB); // exponente (potencia A por el valor de B) + +valorA++; //Incremento (es lo mismo que decir valorA +1) +console.log(valorA); + +valorB--; //Decremento (es lo mismo que decir valorB -1) +console.log(valorB); + +// ------------------------------------------------------------------------- +// ------------------------------------------------------------------------- + +// Operadores de asignación +let myVariable = 2; //le asignamos a la variable un valor +console.log("myVariable: ", myVariable); + +myVariable += 2; // al valor actual de la variable, le sumamos dos. Es lo mismo que decir (myVariable = myVariable + 2) +console.log("myVariable: ", myVariable); + +myVariable -= 2; // igual que en ej anterior, son variaciones de las op aritmeticas +myVariable *= 2; // igual que en ej anterior, son variaciones de las op aritmeticas +myVariable /= 2; // igual que en ej anterior, son variaciones de las op aritmeticas +myVariable %= 2; // igual que en ej anterior, son variaciones de las op aritmeticas +myVariable **= 2; // igual que en ej anterior, son variaciones de las op aritmeticas + +// ------------------------------------------------------------------------- +// ------------------------------------------------------------------------- + +// operadores de comparación +/* + Nos van a servir para comparar variables o acciones en general, que el resultado de esa comparacion nos va + a devolver un boolean + */ + +let comparacionA = 10; +let comparacionB = 5; + +console.log(comparacionA > comparacionB); // mayor que +console.log(comparacionA < comparacionB); // menor que + +console.log(10 >= 10); // mayor o igual que +console.log(11 <= 10); // menor o igual que + +console.log(comparacionA == comparacionB); // igual que (NO distingue entre types de datos) +console.log(comparacionA === comparacionB); // igual que (SI distingue entre types de datos) +console.log(comparacionA != 10); // es distinto que +console.log(comparacionA !== "10"); // es distinto que X y su tipo tambien es distinto? + +// ------------------------------------------------------------------------- +// ------------------------------------------------------------------------- + +// cosas extrañas del lenguaje +console.log(0 == false); // el 0 en JS equivale a falso +console.log(0 === false); // el 0 en JS equivale a falso pero no es del tipo boolean +console.log(1 == false); +console.log(0 == ""); +console.log(0 == ""); +console.log(0 == "E"); + +console.log(undefined == null); // -> true +console.log(undefined === null); // -> false + +// TRUTHY VALUES (VALORES VERDADEROS porque sí) +// todos: los numeros positivos y negativos menos el cero +// todos: las cadenas de texto menos las vacias +// todo: el boolean true + +// FALSY VALUES (VALORES FALSOS porque sí) +// todos los 0 +// todos los 0n +// todos los undefined +// todos los NaN +// todo: el boolean false + +// ------------------------------------------------------------------------- +// ------------------------------------------------------------------------- + +// operadores lógicos +// and (&&) AMBAS TIENEN QUE SER VERDADERA PARA QUE LA COMPARACION SEA TRUE +console.log("AND"); +console.log(15 > 10 && 15 > 12); +console.log(15 > 10 && 15 > 22); +console.log(15 > 10 && 15 > 12 && 10 == 10); + +// or (||) SOLO BASTA CON QUE UNA DE LAS COMPARACIONES SEA VÁLIDA PARA QUE SEA TRUE +console.log(15 > 10 || 15 > 22); +console.log(15 > 100 || 15 > 22); + +// not (!) para dar vuelta el resultado de una comparacion, de true a false y viceversa +console.log(!!(15 > 10 && 15 > 12)); +console.log(15 > 10 && !(15 > 22)); +console.log(!true); + +// ------------------------------------------------------------------------- +// ------------------------------------------------------------------------- + +// operadores ternarios +/* + Es otra forma de escribir un condicional en una sola linea, si se cumple algo hacemos A cosa, si no se + cumple hacemos B cosa. +*/ + +const isRaining = false; +let message = isRaining ? "Esta lloviendo" : "No esta lloviendo"; +console.log("TERNARIO: ", message); diff --git a/Basic/propios/05-operators-exercises.js b/Basic/propios/05-operators-exercises.js new file mode 100644 index 00000000..e6de7c74 --- /dev/null +++ b/Basic/propios/05-operators-exercises.js @@ -0,0 +1,57 @@ +// 1. Crea una variable para cada operación aritmética +let suma = 5 + 5; +let resta = 5 - 5; +let multi = 5 * 5; +let div = 5 / 5; +let residuo = 16 % 5; + +let potencia = 5 ** 3; +let masUno = suma++; +let menosUno = resta--; + +// 2. Crea una variable para cada tipo de operación de asignación, +// que haga uso de las variables utilizadas para las operaciones aritméticas +suma = 10; +suma += 2; +suma -= 2; +suma /= 2; +suma *= 2; +suma %= 2; +suma **= 2; + +// 3. Imprime 5 comparaciones verdaderas con diferentes operadores de comparación +console.log(5 === 5); // true +console.log(5 == "5"); // true +console.log(10 !== 9); // true +console.log(7 <= 10); // true +console.log("hello" >= "hi"); // true (comparación lexicográfica) + +// 4. Imprime 5 comparaciones falsas con diferentes operadores de comparación +console.log(6 === "6"); // false +console.log(6 == 10); // false +console.log(6 >= 10); // false +console.log(6 > 7); // false +console.log(6 !== 6); // false + +// 5. Utiliza el operador lógico and +console.log(100 === 10 * 10 && 15 > 14); + +// 6. Utiliza el operador lógico or +console.log(100 === 10 * 10 || 10 === 9); + +// 7. Combina ambos operadores lógicos +console.log((5 == 5 && 10 > 8) || 20 < 5); + +// 8. Añade alguna negación +console.log((5 == 5 && 10 > 10) || !(20 < 5)); + +// 9. Utiliza el operador ternario +let isSaturday = true; +let message = isSaturday ? "Vamo pal baile" : "A la chamba"; + +// 10. Combina operadores aritméticos, de comparáción y lógicas + +let num1 = 5 + 5; +let num2 = 8 + 5; + +console.log(num1 > num2 || (num2 === 13 && !false)); diff --git a/Basic/propios/06-string.js b/Basic/propios/06-string.js new file mode 100644 index 00000000..e2090190 --- /dev/null +++ b/Basic/propios/06-string.js @@ -0,0 +1,39 @@ +// strings + +// CONCATENACIÓN +let myName = "Exequiel"; +let greeting = "hola, " + myName; // concatenar cadenas de texto +console.log(greeting); + +// LONGITUD +console.log(greeting.length); // -> 14 + +// ACCESO A CARACTERES +console.log(greeting[3]); // -> a +console.log(greeting[15]); // -> undefined + +// MÉTODOS MAS USADOS +console.log(greeting.toUpperCase()); // -> HOLA, EXEQUIEL +console.log(greeting.toLocaleLowerCase()); // -> hola, exequiel +console.log(greeting.indexOf("Exequiel")); // -> 6 devuelve el indice donde comienza X palabra +console.log(greeting.indexOf("Lionel")); // -> -1 cuando no lo encuentra +console.log(greeting.includes("Exe")); // -> true +console.log(greeting.includes("Fran")); // -> false +console.log(greeting.slice(0, 4)); // -> hola (retorna un pedazo, desde el indice 0 al indice 4) +console.log(greeting.replace("Exequiel", "Franco")); // -> Reemplaza el primer fragmento por el segundo +console.log(greeting.replaceAll(" ", "-")); // -> Reemplaza todos los valores, no solo el primero +console.log(greeting.replace("Franco", "Franco")); // -> Si no lo encuentra, devuelve el string sin modificar + +// Template literals (plantillas literales) +let message = "Esto es un mensaje"; +let message2 = "interpolado"; +let interpolacion = `${message} ${message2}`; +let interpolacionError = "${message} ${message2}"; + +let stringVariasLineas = `Una linea, +Dos Lineas, +Tres Lineas`; // con template literals respeta los saltos de linea, de lo contrario, ("") da error + +console.log(stringVariasLineas); +console.log(interpolacion); +console.log(interpolacionError); diff --git a/Basic/propios/07-strings-exercises.js b/Basic/propios/07-strings-exercises.js new file mode 100644 index 00000000..87a56382 --- /dev/null +++ b/Basic/propios/07-strings-exercises.js @@ -0,0 +1,42 @@ +// 1. Concatena dos cadenas de texto +let concat1 = "Hola, " + "Como estas?"; + +// 2. Muestra la longitud de una cadena de texto +console.log(concat1.length); // -> 17 + +// 3. Muestra el primer y último carácter de un string +console.log(concat1[0]); // -> H +console.log(concat1[concat1.length - 1]); // -> ? + +// 4. Convierte a mayúsculas y minúsculas un string +console.log(concat1.toLocaleLowerCase()); // -> hola, como estas? +console.log(concat1.toUpperCase()); // -> HOLA, COMO ESTAS? + +// 5. Crea una cadena de texto en varias líneas +let variasLineas = ` + Una linea, + Dos lineas, + Tres lineas +`; +console.log(variasLineas); + +// 6. Interpola el valor de una variable en un string +let apodo = "Chicho"; +let nombreDelSitio = "CodexIA"; + +let saludoCompleto = `Hola ${apodo}, bienvenido a ${nombreDelSitio}`; +console.log(saludoCompleto); + +// 7. Reemplaza todos los espacios en blanco de un string por guiones +console.log(saludoCompleto.replace(" ", "-")); +console.log(saludoCompleto.replaceAll(" ", "-")); + +// 8. Comprueba si una cadena de texto contiene una palabra concreta +console.log(saludoCompleto.toLowerCase().includes("codexia")); // se hace asi para no tener conflicto entre min y may. + +// 9. Comprueba si dos strings son iguales +let copiaSaludoCompleto = "Hola Chicho, bienvenido a CodexIA"; +console.log(saludoCompleto === copiaSaludoCompleto); + +// 10. Comprueba si dos strings tienen la misma longitud +console.log(saludoCompleto.length === copiaSaludoCompleto.length); diff --git a/Basic/propios/08-conditionals.js b/Basic/propios/08-conditionals.js new file mode 100644 index 00000000..420eb623 --- /dev/null +++ b/Basic/propios/08-conditionals.js @@ -0,0 +1,80 @@ +// Condicionales o estructuras de control +// Los condicionales sirven para tomar algun camino u otro, en función a la condición que le demos. + +// if, else if, else + +// if (si..) +// else (sino..) +let age = 20; + +if (age == 37) { + console.log(`Tienes ${age} edad`); // Se ejecuta esto si la condición es verdadera +} else { + console.log("No tienes 37 años"); // Se ejecuta esto si la condición es falsa +} + +// else if (sino, si..) +if (age == 37) { + console.log(`Tienes ${age} edad`); // Se ejecuta esto si la condición es verdadera +} else if (age < 18) { + console.log("Es menor de edad"); // Se ejecuta esto si la segunda condición es verdadera +} else { + console.log("No tienes 37 años"); // Se ejecuta esto si NINGUNA condición es verdadera +} + +// Operador ternario (forma mas compacta de escribir un condicional simple) +let message = age == 37 ? "Tienes 37 años" : "No tienes 37 años"; // Se guarda el resultado del ternario en una variable +console.log(message); + +// switch (Es una alternativa de anidar if else..) compara una UNICA variable que puede tener varios valores posibles. + +let day = 0; +let dayName; + +// SIEMPRE EVALUAMOS LA MISMA VARIABLE +// if (day == 0) { +// dayName = "Lunes"; +// } else if (day == 1) { +// dayName = "Martes"; +// } else if (day == 2) { +// dayName = "Miercoles"; +// } else if (day == 3) { +// dayName = "Jueves"; +// } else if (day == 4) { +// dayName = "Viernes"; +// } else if (day == 5) { +// dayName = "Sábado"; +// } else { +// dayName = "Domingo"; +// } + +// ALTERNATIVA A LO ANTERIOR: + +// el valor que vamos a evaluar +switch (day) { + case 0: + dayName = "Lunes"; + break; // Para finalizar o romper la ejecución del switch + case 1: + dayName = "Martes"; + break; + case 2: + dayName = "Miercoles"; + break; + case 3: + dayName = "Jueves"; + break; + case 4: + dayName = "Viernes"; + break; + case 5: + dayName = "Sábado"; + break; + case 6: + dayName = "Domingo"; + break; + default: // seria similar al else + dayName = "El día no existe"; +} + +console.log(dayName); diff --git a/Basic/propios/09-conditionals-exercises.js b/Basic/propios/09-conditionals-exercises.js new file mode 100644 index 00000000..4190e8e4 --- /dev/null +++ b/Basic/propios/09-conditionals-exercises.js @@ -0,0 +1,239 @@ +// if/else/else if/ternaria + +// 1. Imprime por consola tu nombre si una variable toma su valor +let myName = "Exequiel"; +if (myName == "Exequiel") { + console.log(`Tu nombre es ${myName}`); +} + +// 2. Imprime por consola un mensaje si el usuario y contraseña concide con unos establecidos +let user = "chicho"; +let password = 123456; + +if (user == "chicho" && password == 123456) { + console.log("Usuario logueado"); +} else { + console.log("¡Tu usuario o contraseña son incorrectos!"); +} + +// 3. Verifica si un número es positivo, negativo o cero e imprime un mensaje +let num = 0; + +if (num > 0) { + console.log("Número positivo"); +} else if (num < 0) { + console.log("Número negativo"); +} else { + console.log("El número es un 0"); +} + +// 4. Verifica si una persona puede votar o no (mayor o igual a 18) e indica cuántos años le faltan +let age = 12; + +if (age >= 18) { + console.log("Usted puede votar"); +} else if (age < 0) { + console.log("La edad ingresada es incorrecta"); +} else { + console.log( + `No puedes votar aún, te faltan ${18 - age} años para cumplir tus 18` + ); +} + +// 5. Usa el operador ternario para asignar el valor "adulto" o "menor" a una variable +// dependiendo de la edad + +let messageAge = age >= 18 ? "adulto" : "menor"; +console.log(`Usted es un ${messageAge}`); + +// 6. Muestra en que estación del año nos encontramos dependiendo del valor de una variable "mes" +let actualMonth = "Enero"; +let season; +let count; + +if ( + actualMonth == "Enero" || + actualMonth == "Febrero" || + actualMonth == "marzo" +) { + season = "Verano"; +} else if ( + actualMonth == "Abril" || + actualMonth == "Mayo" || + actualMonth == "Junio" +) { + season = "Otoño"; +} else if ( + actualMonth == "Julio" || + actualMonth == "Agosto" || + actualMonth == "Septiembre" +) { + season = "Invierno"; +} else if ( + actualMonth == "Octubre" || + actualMonth == "Noviembre" || + actualMonth == "Diciembre" +) { + season = "Primavera"; +} else { + season = "El mes ingresado NO es correcto"; +} + +console.log(`Estación actual: ${season}`); + +// 7. Muestra el número de días que tiene un mes dependiendo de la variable del ejercicio anterior +if ( + actualMonth == "Enero" || + actualMonth == "Marzo" || + actualMonth == "Mayo" || + actualMonth == "Julio" || + actualMonth == "Agosto" || + actualMonth == "Octubre" || + actualMonth == "Diciembre" +) { + count = 31; +} else if ( + actualMonth == "Abril" || + actualMonth == "junio" || + actualMonth == "Septiembre" || + actualMonth == "Noviembre" +) { + count = 30; +} else { + console.log("El mes ingresado NO es correcto"); +} + +console.log(`El mes de ${actualMonth} tiene ${count} días`); + +// switch + +// 8. Usa un switch para imprimir un mensaje de saludo diferente dependiendo del idioma + +let language = "Spanish"; +let translatedMessage; + +switch (language) { + case "English": + translatedMessage = "Hello world!"; + break; + case "Spanish": + translatedMessage = "Hola Mundo!"; + break; + case "French": + translatedMessage = "Bonjour le monde"; + break; + default: + translatedMessage = "Lenguaje no encontrado"; + break; +} + +console.log(`${language}: ${translatedMessage}`); + +// 9. Usa un switch para hacer de nuevo el ejercicio 6 +switch (actualMonth) { + case "Enero": + season = "Verano"; + break; + case "Febrero": + season = "Verano"; + break; + case "Marzo": + season = "Verano"; + break; + case "Abril": + season = "Otoño"; + break; + case "Mayo": + season = "Otoño"; + break; + case "Junio": + season = "Otoño"; + break; + case "Julio": + season = "Invierno"; + break; + case "Agosto": + season = "Invierno"; + break; + case "Septiembre": + season = "Invierno"; + break; + case "Octubre": + season = "Primavera"; + break; + case "Noviembre": + season = "Primavera"; + break; + case "Diciembre": + season = "Primavera"; + break; + + default: + season = "El mes es incorrecto"; + break; +} + +// 10. Usa un switch para hacer de nuevo el ejercicio 7 +if ( + actualMonth == "Enero" || + actualMonth == "Marzo" || + actualMonth == "Mayo" || + actualMonth == "Julio" || + actualMonth == "Agosto" || + actualMonth == "Octubre" || + actualMonth == "Diciembre" +) { + count = 31; +} else if ( + actualMonth == "Abril" || + actualMonth == "junio" || + actualMonth == "Septiembre" || + actualMonth == "Noviembre" +) { + count = 30; +} else { + console.log("El mes ingresado NO es correcto"); +} + +switch (actualMonth) { + case "Enero": + count = 31; + break; + case "Febrero": + count = 28; + break; + case "Marzo": + count = 31; + break; + case "Abril": + count = 30; + break; + case "Mayo": + count = 31; + break; + case "Junio": + count = 30; + break; + case "Julio": + count = 31; + break; + case "Agosto": + count = 31; + break; + case "Septiembre": + count = 30; + break; + case "Octubre": + count = 31; + break; + case "Noviembre": + count = 30; + break; + case "Diciembre": + count = 31; + break; + + default: + season = "El mes es incorrecto"; + break; +} diff --git a/Basic/propios/10-array.js b/Basic/propios/10-array.js new file mode 100644 index 00000000..f0084bfd --- /dev/null +++ b/Basic/propios/10-array.js @@ -0,0 +1,96 @@ +// array (estructuras de datos) en otros lenguajes se interpreta como lista tambien + +// Declaración +let myArray = []; // SE RECOMIENDA ESTA SINTAXIS +let myArray2 = new Array(); + +console.log(myArray); +console.log(myArray2); + +// Inicialización + +myArray = [1]; + +// Definición de array mas puro, donde nosotros reservamos las casillas o espacios +// que necesitemos, en cambio de la otra manera "[]" va tomando los espacios que el +// propio array necesita +myArray2 = new Array(1); // Reserva 1 espacio, NO asigna valor + +console.log(myArray); +console.log(myArray2); + +myArray = [1, 2, 3, 4]; +myArray2 = new Array(1, 2, 3, 4); + +console.log(myArray); +console.log(myArray2); + +myArray = ["Exequiel", "Cristian", 30, false, undefined]; +myArray2 = new Array("Exequiel", "Cristian", 30, false, undefined); + +console.log(myArray); +console.log(myArray2); + +myArray2 = new Array(3); +myArray2[0] = "Exequiel"; +myArray2[1] = "Cristian"; +myArray2[2] = "Alexander"; +myArray2[3] = "Alexander"; + +console.log(myArray2); + +myArray = []; +myArray[2] = "Alexander"; +// myArray[0] = "Exequiel"; +myArray[1] = "Cristian"; + +console.log(myArray); + +// MÉTODOS COMUNES +myArray = []; + +// push y pop +myArray.push("Push-1"); // -> agrega uno o varios elementos al final del array +myArray.push("Push-2"); +myArray.push("Push-3"); +console.log(myArray); + +// myArray.pop(); // -> Elimina el ÚLTIMO elemento del array +console.log("ELIMINADO: ", myArray.pop()); // -> Devuelve el elemento que elimina +console.log(myArray); + +// shift y unshift +myArray.shift(); // -> Elimina el primer elemento del array y lo devuelve +console.log(myArray); + +myArray.unshift("UNSHIFT-1", "UNSHIFT-1"); // -> Agrega en el principio del array uno o mas elementos +console.log(myArray); + +// length +console.log("Cantidad: ", myArray.length); // -> propiedad que devuelve la cantidad de elementos + +// clear +myArray = []; // -> De esta manera borramos todo del array, lo inicializamos nuevamente VACIO + +myArray.unshift("Elemento1", "Elemento2", "Elemento3"); + +myArray.length = 0; // -> Otra manera de borrar todo un array (NO SE USA) + +// slice +myArray.unshift("Primero", "Segundo", "Tercero"); +let newMyArray = myArray.slice(1, 2); // -> Los elementos que empiezan en el primer indice +// y terminan en el segundo indice (en este caso no se cuenta el 2) +console.log(newMyArray); + +// splice +myArray = []; +myArray.unshift("Primero", "Segundo", "Tercero", 22, 11, true); + +// -> Elimina los elementos que le pasemos por argumento +// 0 = desde donde quieres empezar a eliminar? +// 2 = cuantos elementos quieres eliminar? +let myNewArray2 = myArray.splice(0, 3); // -> Devuelve los elementos borrados +// let myNewArray3 = myArray.splice(0, 3, "Nuevo elemento"); // -> El tercer parametro sirve para +// agregar un nuevo elemento en el lugar de los elementos borrados. +console.log("BORRADOS splice:", myNewArray2); +console.log(myArray); // -> Array modificado diff --git a/Basic/propios/11-set.js b/Basic/propios/11-set.js new file mode 100644 index 00000000..e7280751 --- /dev/null +++ b/Basic/propios/11-set.js @@ -0,0 +1,63 @@ +// console.error("^"); + +// set + +// Declaracion +let mySet = new Set(); + +// Inicislización +// mySet = new Set("Exe", "Cristian", "Alex", 33, false); //-> Forma incorrecta +mySet = new Set(["Exe", "Cristian", 33, false]); + +console.log(mySet); + +// Métodos comúnes + +// add y delete +mySet.add("Nuevo dato"); + +console.log(mySet); + +// DELETE: debemos indicar que elemento queremos borrar (Indicar el valor exacto) +// Esto es porque SET no indexa sus valores como una lista (array), sino que los indexa +// con un hash unico para cada valor. + +// el metodo delete ademas nos va a retornar un boolean +mySet.delete("33"); // no funciona, respetar el tipo de datos + +if (mySet.delete("33")) { + // se borro +} else { + // no se borro +} + +mySet.delete(33); +console.log(mySet); + +// has (comprobar si existe un elemento) devuelve un boolean +console.log(mySet.has("Exe")); +console.log(mySet.has("exe")); + +// size (tamaño) +console.log(mySet.size); + +// Convertir un SET a ARRAY +// Usamos la operacion "from" de ARRAY para decirle desde donde queremos crear el array +let myArray = Array.from(mySet); +console.log(myArray); + +// Convertir un ARRAY a SET +let arrayPrueba = [1, 2, 3, 4]; +let myArray2 = new Set(arrayPrueba); + +console.log(myArray2); + +// El Array permite duplicados, pero los set NO admiten duplicados +// Es por eso que no accedemos por indice, sino que accedemos por el valor (que sera unico) + +mySet.add("egc.criss@gmail.com"); +mySet.add("egc.criss@gmail.com"); +mySet.add("egc.criss@gmail.com"); +mySet.add("egc.criss@gmail.com"); + +console.log(mySet); diff --git a/Basic/propios/12-map.js b/Basic/propios/12-map.js new file mode 100644 index 00000000..9d39a922 --- /dev/null +++ b/Basic/propios/12-map.js @@ -0,0 +1,61 @@ +// Map (o diccionario en otros lenguajes) + +// DEclaración +let myMap = new Map(); +console.log(myMap); + +// Inicialización +myMap = new Map([ + ["name", "Exequiel"], + ["email", "egc.criss@gmail.com"], + ["edad", 30], +]); + +console.log(myMap); + +// Metodos y propiedades + +// set (sirve para actualizar o agregar un nuevo elemento) +myMap.set("Alias", "Chicho"); +console.log(myMap); + +// No pueden haber claves repetidas, en este caso se modifica la existente +myMap.set("name", "Exe"); +console.log(myMap); + +// get (para recuperar un valor por su clave) +console.log(myMap.get("name")); +console.log(myMap.get("surename")); + +// has (comprobar si una clave existe o no) y devuelve un boolean +console.log(myMap.has("name")); +console.log(myMap.has("surename")); + +// delete (elimina basado en la clave que le pasemos) +myMap.delete("email"); +console.log(myMap); + +// clear +myMap.clear(); +console.log(myMap); + +// propiedades + +// keys (retorna un listado de las claves) + +myMap = new Map([ + ["name", "Exequiel"], + ["email", "egc.criss@gmail.com"], + ["edad", 30], +]); + +console.log(myMap.keys()); + +// values (retorna un listado de los values) +console.log(myMap.values()); + +// size (devuelve el tamaño del map) +console.log(myMap.size); + +// entries (una forma de iterar o recorrer todas las claves y valor del map) +console.log(myMap.entries()); diff --git a/Basic/propios/13-structures-exercises.js b/Basic/propios/13-structures-exercises.js new file mode 100644 index 00000000..1a98e779 --- /dev/null +++ b/Basic/propios/13-structures-exercises.js @@ -0,0 +1,68 @@ +// 1. Crea un array que almacene cinco animales +let animales = ["Perro", "Gato", "Jirafa", "Oso", "León"]; + +// 2. Añade dos más. Uno al principio y otro al final +animales.unshift("Paloma"); // principio +animales.push("Pez"); // final +console.log(animales); + +// 3. Elimina el que se encuentra en tercera posición +animales.splice(2, 1); // desde el indice 2 borra 1 elemento a la derecha +console.log(animales); + +// 4. Crea un set que almacene cinco libros +let mySet = new Set([ + "Código sostenible", + "Clean code", + "Eloquent", + "Git-Flows", + "Test DDD", +]); + +// 5. Añade dos más. Uno de ellos repetido +mySet.add("Lógica programática"); +mySet.add("CleanCode 2"); +mySet.add("CleanCode 2"); +console.log(mySet); + +// 6. Elimina uno concreto a tu elección +mySet.delete("Clean code"); +console.log(mySet); + +// 7. Crea un mapa que asocie el número del mes a su nombre +let meses = new Map([ + [0, "Enero"], + [1, "Febrero"], + [2, "Marzo"], + [3, "Abril"], + [4, "Mayo"], + [5, "Junio"], + [6, "Julio"], + [7, "Agosto"], + [8, "Septiembre"], + [9, "Octubre"], + [10, "Noviembre"], + [11, "Diciembre"], +]); + +console.log(meses); + +// 8. Comprueba si el mes número 5 existe en el map e imprime su valor +if (meses.has(5)) { + console.log(meses.get(5)); +} else { + console.log("Elemento NO encontrado"); +} + +// 9. Añade al mapa una clave con un array que almacene los meses de verano +meses.set("Verano", ["Diciembre", "Enero", "Febrero"]); +console.log(meses); + +// 10. Crea un Array, transfórmalo a un Set y almacénalo en un Map +let arrayTest = [1, 2, 3, 4]; +let arrayToSet = new Set(arrayTest); +let setToMap = new Map([["set", arrayToSet]]); + +console.log(arrayTest); +console.log(arrayToSet); +console.log(setToMap); diff --git a/Basic/propios/14-loops.js b/Basic/propios/14-loops.js new file mode 100644 index 00000000..9883ef6d --- /dev/null +++ b/Basic/propios/14-loops.js @@ -0,0 +1,92 @@ +// Loops o Bucles (Se entiende como una estructura de control, repite un +// bloque de codigo mientras una condicion sea verdadera) + +// for (Se evalua una condición cada vez que se realiza una iteración) + +for (let i = 0; i < 10; i++) { + // aca va el código que vamos a repetir + console.log(`Hello World! ${i + 1}`); +} + +const numbers = [1, 2, 3, 4, 5]; +for (let index = 0; index < numbers.length; index++) { + const singleNumber = numbers[index]; + console.log(`Elemento - FOR: ${singleNumber}`); +} + +// while (Lo que hace es evaluarse antes de cada iteración.) + +let i = 0; + +while (i < 5) { + console.log(`Elemento - WHILE: ${numbers[i]}`); + i++; +} + +// CUIDADO!!! BUCLE INFINITO +// while (true) { +// // si la condición siempre es TRUE, el bucle sera infinito +// } + +// do while (Muy parecido al while, pero este ejecuta al menos 1 vez el código antes de evaluar la condición) + +let contador = 0; +do { + console.log(`Elemento - DO WHILE: ${numbers[contador]}`); + contador++; +} while (contador < numbers.length); + +// for of (Sirve para recorrer los VALORES de algo que sea iterable) +// Algo iterable: es una estructura de datos con mas de un dato + +let myArray = ["a", "b", "c", "d", "e", "f"]; +let mySet = new Set(["Exequiel", "Cristian", "Alexander"]); +let myMap = new Map([ + ["Ocupación", "Programador"], + ["Altura", "174-cm"], +]); + +// Podemos revisar uno a uno los valores que tenemos dentro de la estructura de datos +console.log("----ARRAY----"); +for (let valor of myArray) { + console.log(valor); +} + +console.log("----SET----"); +for (let valor of mySet) { + console.log(valor); +} + +console.log("----MAP----"); +for (let valor of myMap) { + console.log(valor); +} +console.log("--------"); + +// Un string tambien es iterable + +let string = "Javascript"; +for (let valor of string) { + console.log(valor); +} +console.log("--------"); + +// BUENAS PRÁCTICAS: +/* + 1- Asegurarse que la condición del bucle en algun momento sea falsel, sino sera un bucle infinito! + 2- Utilizar breack y continue +*/ + +for (let i = 1; i <= 10; i++) { + // podemos usar condiciones dentro de bucles, en este ejemplo ignoraremos el num 5 + if (i === 5) { + // Saltar la presente iteración (salta directamente a la inspección de la condición) + continue; + } + + if (i === 7) { + // Con esta sentencia detenemos por completo el bucle + break; + } + console.log(`Ronda: ${i}`); +} diff --git a/Basic/propios/15-loops-exercises.js b/Basic/propios/15-loops-exercises.js new file mode 100644 index 00000000..19f776e1 --- /dev/null +++ b/Basic/propios/15-loops-exercises.js @@ -0,0 +1,96 @@ +// 1. Crea un bucle que imprima los números del 1 al 20 +console.log(".............1..............."); +for (let i = 1; i <= 10; i++) { + console.log(`Número - ${i}`); +} + +// 2. Crea un bucle que sume todos los números del 1 al 100 y muestre el resultado +console.log("..............2.............."); +let suma = 0; +for (let i = 1; i <= 100; i++) { + suma += i; +} +console.log("Suma total: ", suma); + +// 3. Crea un bucle que imprima todos los números pares entre 1 y 50 +console.log("..............3.............."); +for (let i = 1; i <= 50; i++) { + if (i % 2 === 0) { + console.log(`Número PAR: ${i}`); + } +} + +// 4. Dado un array de nombres, usa un bucle para imprimir cada nombre en la consola +console.log("..............4.............."); +let names = ["Exequiel", "Cristian", "Alexander"]; +for (let value of names) { + console.log(value); +} + +// 5. Escribe un bucle que cuente el número de vocales en una cadena de texto +console.log("..............5.............."); +let countVocales = 0; +let stringVocales = "Vocales"; + +for (let i = 0; i < stringVocales.length; i++) { + let letra = stringVocales[i].toLowerCase(); + if ("aeiou".includes(letra)) { + // Verificamos si la letra está en el string "aeiou" + countVocales++; + } +} +console.log(`Contamos ${countVocales} en el string "${stringVocales}"`); + +// 6. Dado un array de números, usa un bucle para multiplicar todos los números y mostrar el producto +console.log("..............6.............."); +let numbers = [1, 2, 3, 4, 5]; +let countNumbers = 1; + +for (let number of numbers) { + countNumbers *= number; +} + +console.log(countNumbers); + +// 7. Escribe un bucle que imprima la tabla de multiplicar del 5 +console.log("..............7.............."); +for (let i = 1; i <= 10; i++) { + console.log(`TABLA DEL 5: 5 X ${i}= ${i * 5}`); +} + +// 8. Usa un bucle para invertir una cadena de texto +console.log("..............8.............."); +let stringInvertir = "casa"; +let nuevoTexto = ""; + +// Recorremos desde el último índice hasta el primero. +for (let i = stringInvertir.length - 1; i >= 0; i--) { + nuevoTexto += stringInvertir[i]; +} + +console.log("Nuevo Texto: ", nuevoTexto); + +// 9. Usa un bucle para generar los primeros 10 números impares y guárdalos en un array. Luego, muestra ese array +console.log("..............9.............."); +let numerosImpares = []; + +for (let i = 0; numerosImpares.length < 10; i++) { + if (i % 2 !== 0) { + numerosImpares.push(i); + } +} + +console.log(`Números impares: ${numerosImpares}`); + +// 10. Dado un array de números, usa un bucle para crear un nuevo array que contenga solo los números mayores a 10 +console.log("..............10.............."); +let variosNumeros = [11, 2, 5, 6, 33, 654, 9, 45, 22, 36]; +let mayores = []; + +for (let num of variosNumeros) { + if (num > 10) { + mayores.push(num); + } +} + +console.log("MAYORES: ", mayores); diff --git a/Basic/propios/16-functions.js b/Basic/propios/16-functions.js new file mode 100644 index 00000000..87ec957f --- /dev/null +++ b/Basic/propios/16-functions.js @@ -0,0 +1,131 @@ +// FUNCIONES (bloque de código diseñado para una tarea específica, para que haga su trabajo tenemos que invocarla) + +function myFunction() { + console.log("Esto es una función"); +} + +// Se invoca 1 vez +// myFunction() + +// Se invoca X veces +for(let i = 0; i < 5; i++){ + myFunction() +} + +console.log("............................"); +// CON PARAMETROS (Estos parametros se los enviamos a la funcion cuando la invocamos, y nos sirven para usarlos dentro) +function myFunctionWithParams(name) { + console.log(`Hola ${name}`); +} + +myFunctionWithParams("Exequiel") +myFunctionWithParams() +myFunctionWithParams("Franco") + +console.log("............................"); +// FUNCIONES ANÓNIMAS (Son funciones que no tienen un nombre definido) +// para poder invocarla la tenemos que asignar a una variable o constante +const myFunc2 = function(name){ + console.log(`Hola ${name} anónimo`); +} + +myFunc2("Cristian") + +console.log("............................"); +// ARROW FUNCTION (o funciones flechas, es una manera moderna o concisa de crear una función) +const arrowFunction = (text) => { + console.log(text); +} + +// Si tenemos solo un parametro, no hace falta envolverlo en () +// Si retornamos solo una cosa, no hace falta envolverlo en {} +const arrowFuntionMini = text => console.log(text) + +arrowFunction("Texto parámetro") +arrowFunction("Texto parámetro funcion mini") + +console.log("............................"); +// PARÁMETROS +// para ingresar mas de un parámetro, se separan con "," + +function sum(a, b) { + console.log(a + b); +} + +sum(18, 2) +sum(6) // Devuelve Nan, porque intenta sumar un 5 con NADA. + +// Para agregar valores por default al parámetro, se hace dentro de los parentesis asi: a = x, b = y +function sumWhitDefault(a = 0, b = 0) { + console.log(a + b); +} + +sumWhitDefault() + +console.log("............................"); +// RETORNO DE VALORES +// Podemos retornar lo que queramos, por ej, tengo una función que hace cierta operacion y me retorna +// el resultado de esa operación + +function mult(a, b) { + let resultado = a * b; + + return resultado +} + +let resOperacion = mult(3, 5); + +console.log('RESULTADO FINAL: ', resOperacion); + +console.log("............................"); +// FUNCIONES ANIDADAS + +function extern(){ + console.log("Función externa"); + function intern() { + console.log("Función interna"); + } + intern() +} + +extern() +// Error: Asi NO la podemos llamar, porque esta solo dentro del scope de extern() +// intern() +// intern().intern() -> Tampoco funciona + + +console.log("............................"); +// FUNCIONES DE ORDEN SUPERIOR +// Son funciones que reciben otras funciones como argumento + +function applyFunc (func, param){ + func(param) +} + +let funcExample = (text) => { + console.log(text); +} + +// llamamos a applyFunction y le pasamos como param funcExample. +applyFunc(funcExample, "Parametro de la funcion example") + + +console.log("............................"); +// forEach -> Aplica para los ARRAYS de JavaScript +// Es una funcion que nos sirve para ejecutar bucles asociados a elementos iterables + +/* + DESVENTAJAS DEL FOREACH A COMPARACION DEL FOR OF + - No podemos usar brack o continue + - No retornamos un nuevo array como en el otro caso, solo itera. +*/ + + +let myArray = [1,2,3,4] +myArray.forEach((value) => console.log(value)) // Es una función que ejecuta otra función iteradora + +// O se puede hacer con function tradicionales +console.log("......"); +myArray.forEach(function(value){ + console.log(value) +}) diff --git a/Basic/propios/17-functions-exercises.js b/Basic/propios/17-functions-exercises.js new file mode 100644 index 00000000..9413a987 --- /dev/null +++ b/Basic/propios/17-functions-exercises.js @@ -0,0 +1,172 @@ + + +// NOTA: Explora diferentes sintaxis de funciones para resolver los ejercicios (hacerlo con function y arrowFunction) + +// 1. Crea una función que reciba dos números y devuelva su suma +const sum = (a, b) => { + return a + b +} + +console.log(sum(10, 6)); +console.log('---------------------------'); + +// 2. Crea una función que reciba un array de números y devuelva el mayor de ellos +const maxNum = (array) => { + return Math.max(...array) +} + +let arrayNumbers = [1,3,23,44,54,52,2,7,8,98,9] + +console.log(`${maxNum(arrayNumbers)}`); + +console.log('---------------------------'); +// 3. Crea una función que reciba un string y devuelva el número de vocales que contiene +function countVocales(string) { + let vocales = "aeiou"; // String con las vocales en minúscula + let count = 0; + + for (let i = 0; i < string.length; i++) { + if (vocales.includes(string[i].toLowerCase())) { // Convertimos a minúscula y verificamos si está en "aeiou" + count++; + } + } + + return count; +} + +console.log(countVocales("casa")); // 2 +console.log(countVocales("Escuela")); // 4 +console.log(countVocales("HELLO")); // 2 + +console.log('---------------------------'); +// 4. Crea una función que reciba un array de strings y devuelva un nuevo array con las strings en mayúsculas +const upperCase = (array) => { + let newArray = []; + for (let i = 0; i < array.length; i++) { + newArray.push(array[i].toUpperCase()) + } + return newArray; +} + +let arrayMin = ["casa", "rojo", "verde"] + +console.log(upperCase(arrayMin)); + +// USANDO METODO MAP: +// const upperCase = (array) => array.map(str => str.toUpperCase()); + +// let arrayMin = ["casa", "rojo", "verde"]; + +// console.log(upperCase(arrayMin)); // ["CASA", "ROJO", "VERDE"] + +console.log('---------------------------'); +// 5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario +const esPrimo = (num) => { + + if(num < 2) return false + + for (let i = 2; i < num; i++) { + if (num % i === 0) { // Si encuentra un divisor, NO ES PRIMO + return false; + } + } + + return true; // Si no tuvo divisores, ES PRIMO +} + +console.log(esPrimo(2)); // true +console.log(esPrimo(7)); // true +console.log(esPrimo(10)); // false +console.log(esPrimo(1)); // false +console.log(esPrimo(97)); // true + +console.log('---------------------------'); + +// 6. Crea una función que reciba dos arrays y devuelva un nuevo array que contenga los elementos comunes entre ambos +const mezclarArrays = function(array1, array2) { + let newArray = []; + + array1.forEach((element) => { + if (array2.includes(element)) { + newArray.push(element) + } + }) + + return newArray; +} + +let primerArray = [2,3,4,5,6,7,8,9]; +let segundoArray = [9,88,867,5,34,2,33,4] + +console.log(mezclarArrays(primerArray, segundoArray)); + +console.log('---------------------------'); + +// 7. Crea una función que reciba un array de números y devuelva la suma de todos los números pares +const sumPares = (array) => { + let sumaTotal = 0; + + for (let i = 0; i < array.length; i++) { + if (array[i] % 2 === 0) { + sumaTotal += array[i] + } + } + + return sumaTotal; +} + +let numbers1 = [2, 6, 7, 9, 13, 10] + +console.log(sumPares(numbers1)); + +console.log('---------------------------'); + +// 8. Crea una función que reciba un array de números y devuelva un nuevo array con cada número elevado al cuadrado +function cuadrado(array){ + let newArray = [] + + array.forEach((elemento) => newArray.push(elemento *= elemento)) + + return newArray; +} + +let arrayCuadrado = [2, 5, 9] + +console.log(cuadrado(arrayCuadrado)); + +console.log('---------------------------'); + +// 9. Crea una función que reciba una cadena de texto y devuelva la misma cadena con las palabras en orden inverso +const stringInverso = (string) => { + let newString = ""; + let palabra = ""; + + for (let i = 0; i < string.length; i++) { + if (string[i] === " ") { + newString = " " + palabra + newString; + palabra = ""; + } else { + palabra += string[i]; // Construimos la palabra + } + } + + return palabra + newString; // Agregamos la última palabra +}; + +console.log(stringInverso("La casa es de color verde")); + + +console.log('---------------------------'); + +// 10. Crea una función que calcule el factorial de un número dado +const factorial = (num) => { + let result = 1; + + for (let i = 1; i <= num; i++) { + result *= i; // Multiplicamos el resultado por el número actual + } + + return result; +}; + +console.log(factorial(5)); // 120 \ No newline at end of file diff --git a/Basic/propios/18-objects.js b/Basic/propios/18-objects.js new file mode 100644 index 00000000..3672bf90 --- /dev/null +++ b/Basic/propios/18-objects.js @@ -0,0 +1,145 @@ +// Objects +// Todo aquello que no sea un dato primitivo, es un OBJECT en JS +// Un Objeto tiene dos elementos, una CLAVE y un VALOR que pertenece a dicha clave. + +// SINTAXIS +// Estamos modelando una entidad con una personalidad. Con esto empezamos a relacionar la programación +// con la realidad. + +let person = { + name: "Exequiel", + "name person": "Cristian", + edad: 30, + alias: "Chicho" +} +console.log(person); +console.log("--------------------"); + + +// ACCESO A LAS PROPS + +// Notación por punto -> Ponemos el nombre del objeto, y seguido un punto para ver las props internas. +console.log(person.name); +console.log("--------------------"); + +// Notación de corchetes -> accedemos con el nombre de la clave que estamos buscando, esto es ÚTIL +// los casos en donde la clave tenga espacios. +console.log(person["name person"]); +console.log("--------------------"); + +// MODIFICACIÓN DE PROPIEDADES +/* + Se llama a la prop que queremos modificar, y le pasamos el nuevo valor, si existe la modifica y si NO + existe la va a crear. +*/ + +person.edad = 31; +person["name person"] = "Alexander" +console.log(person); +console.log(typeof person); // Object + +console.log("--------------------"); + +// ELIMINACIÓN DE PROPIEDADES + +delete person.alias // Elimina por completo la propiedad del object +console.log(person); +console.log("--------------------"); + +// NUEVA PROPIEDAD + +person.email = "egc.criss@gmail.com" +person["cel"] = 271778899 + +console.log(person); +console.log("--------------------"); + +// MÉTODOS O TAMBIÉN CONOCIDOS COMO FUNCIONES EN EL OBJECT + +let person2 = { + name: "Exequiel", + edad: 30, + alias: "Chicho", + walk: function(){ + console.log("Caminando...") + } +} +// Para invocar un metodo//funcion lo llamamos asi: +person2.walk() + +console.log("--------------------"); + +// Anidación de objetos -> Podemos anidar un objeto dentro de otro + +let person3 = { + name: "Exequiel", + edad: 30, + alias: "Chicho", + walk: function(){ + console.log("Caminando...") + }, + job: { + name: "Programador", + exp: "4" + } +} + +console.log(person3); + +// Acceso anidado +console.log(person3.job.name); +console.log("--------------------"); + +// IGUALDAD DE OBJECTS + +let person4 = { + name: 'Exequiel', + 'name person': 'Alexander', + edad: 31, + email: 'egc.criss@gmail.com', + cel: 271778899 +} + +console.log(person); +console.log(person4); + +// Cuando compara no lo hace a los valores, lo hace a la referencia. Y son dos direcciones distintas. +console.log(person == person4); // false +console.log(person === person4); // false + +console.log(person.name === person4.name); // false + +/* + CONCEPTO IMPORTANTE: Representación de variables por valor o por referencia + Objetos: La forma en la que estos objetos se guardan en memoria ya NO es con un valor asociado. Es con + una REFERENCIA. Osea una dirección a memoria. +*/ +console.log("--------------------"); + +// Iteración + +// for (let item of person4) { +// console.log("ITEM: ", item); // NO funciona como en los arrays +// } + +for (let key in person4) { // accedemos a la CLAVE o KEY del objeto. + console.log("ITEM: ", key); + console.log("ITEM: ", person4[key]); // si lo hacemos person4.key daria error, porque no existe la prop key como tal. +} +console.log("--------------------"); + +let person5 = { + name: "Exequiel", + edad: 30, + alias: "Chicho", + walk: function(){ + console.log(`Caminando hacen ${this.edad} años...`) // Con this hacemos referencia a una prop dentro de este bloque + }, + job: { + name: "Programador", + exp: "4" + } +} + +console.log(person5.walk()); +console.log("--------------------"); diff --git a/Basic/propios/18.2-integrador-homework-resueltos.js b/Basic/propios/18.2-integrador-homework-resueltos.js new file mode 100644 index 00000000..a46079c2 --- /dev/null +++ b/Basic/propios/18.2-integrador-homework-resueltos.js @@ -0,0 +1,134 @@ +// 1. Dado un array de números, mostrar solo los impares +function obtenerImpares(arr) { + return arr.filter((num) => num % 2 !== 0); +} +// obtenerImpares([1, 2, 3, 4, 5]) -> [1, 3, 5] + +// 2. Función que devuelve el mayor de dos números +function mayorDeDos(a, b) { + return a > b ? `${a} es mayor` : `${b} es mayor`; +} +// mayorDeDos(10, 5) -> "10 es mayor" + +// 3. Devolver longitud de cada palabra en un array +function longitudes(arr) { + return arr.map((palabra) => palabra.length); +} +// longitudes(["hola", "perro", "sol"]) -> [4, 5, 3] + +// 4. Identificar si un número es positivo, negativo o cero +function tipoNumero(n) { + if (n > 0) return "Es positivo"; + if (n < 0) return "Es negativo"; + return "Es cero"; +} +// tipoNumero(-5) -> "Es negativo" + +// 5. Contar nombres que empiezan con una letra +function contarPorLetra(arr, letra) { + return arr.filter((nombre) => nombre.startsWith(letra)).length; +} +// contarPorLetra(["Pedro", "Pablo", "Ana"], "P") -> 2 + +// 6. Reemplazar espacios por guiones en un string +function reemplazarEspacios(texto) { + return texto.replace(/ /g, "-"); +} +// reemplazarEspacios("Hola mundo js") -> "Hola-mundo-js" + +// 7. Verificar si un string es un palíndromo +function esPalindromo(str) { + const limpio = str.toLowerCase().replace(/ /g, ""); + return limpio === [...limpio].reverse().join(""); +} +// esPalindromo("oso") -> true + +// 8. Devolver el número mayor de un array +function maximo(arr) { + return Math.max(...arr); +} +// maximo([3, 8, 2, 10, 5]) -> 10 + +// 9. Mostrar los primeros N números pares +function pares(n) { + const resultado = []; + for (let i = 0; resultado.length < n; i++) { + if (i % 2 === 0) resultado.push(i); + } + return resultado; +} +// pares(5) -> [0, 2, 4, 6, 8] + +// 10. Calcular promedio de edades +function promedio(arr) { + const suma = arr.reduce((acc, n) => acc + n, 0); + return suma / arr.length; +} +// promedio([20, 30, 40]) -> 30 + +// 11. Devolver solo las vocales de un string +function soloVocales(str) { + return [...str].filter((l) => "aeiouAEIOU".includes(l)).join(""); +} +// soloVocales("Hola mundo") -> "Oaouo" + +// 12. Calcular total y cantidad de productos +function resumenCarrito(carrito) { + const total = carrito.reduce((acc, p) => acc + p.precio, 0); + return `Total: $${total}, Productos: ${carrito.length}`; +} +// resumenCarrito([{ nombre: "Silla", precio: 500 }, { nombre: "Mesa", precio: 1000 }]) -> "Total: $1500, Productos: 2" + +// 13. Tabla de multiplicar de un número +function tablaMultiplicar(n) { + const resultado = []; + for (let i = 1; i <= 10; i++) { + resultado.push(`${n} x ${i} = ${n * i}`); + } + return resultado; +} +// tablaMultiplicar(3) + +// 14. Eliminar valores nulos o undefined de un array +function limpiarArray(arr) { + return arr.filter((e) => e !== null && e !== undefined); +} +// limpiarArray([1, null, 3, undefined, 5]) -> [1, 3, 5] + +// 15. Producto más caro +function productoMasCaro(productos) { + return productos.reduce((max, p) => (p.precio > max.precio ? p : max)).nombre; +} +// productoMasCaro([{nombre:"a", precio:10}, {nombre:"b", precio:30}]) -> "b" + +// 16. Contar letras sin espacios +function contarLetras(str) { + return str.replace(/ /g, "").length; +} +// contarLetras("Hola mundo") -> 9 + +// 17. Repetir palabra N veces +function repetirPalabra(palabra, n) { + return palabra.repeat(n); +} +// repetirPalabra("Hola", 3) -> "HolaHolaHola" + +// 18. Verificar si usuario existe +function usuarioExiste(nombre, usuarios) { + return usuarios.includes(nombre) + ? "El usuario ya existe" + : "Usuario disponible"; +} +// usuarioExiste("pepe", ["juan", "pepe"]) -> "El usuario ya existe" + +// 19. Mostrar quién aprobó +function quienesAprobaron(alumnos) { + return alumnos.filter((a) => a.nota >= 6).map((a) => `${a.nombre} aprobó`); +} +// quienesAprobaron([{nombre:"Luis", nota:7}, {nombre:"Ana", nota:4}]) -> ["Luis aprobó"] + +// 20. Cambiar nombre a mayúsculas en array de objetos +function nombresAMayusculas(usuarios) { + return usuarios.map((u) => ({ nombre: u.nombre.toUpperCase() })); +} +// nombresAMayusculas([{nombre:"juan"}, {nombre:"pepe"}]) -> [{nombre:"JUAN"}, {nombre:"PEPE"}] diff --git a/Basic/propios/18.2-integrador-homework.js b/Basic/propios/18.2-integrador-homework.js new file mode 100644 index 00000000..e0a7edba --- /dev/null +++ b/Basic/propios/18.2-integrador-homework.js @@ -0,0 +1,104 @@ +// 1. Dado un array de números, mostrar solo los impares +// Input: [1, 2, 3, 4, 5] +// Output: [1, 3, 5] + +/////////////////////////////////////////////////////// +// 2. Crear una función que reciba dos números y devuelva cuál es mayor +// Input: 10, 5 +// Output: "10 es mayor" + +/////////////////////////////////////////////////////// +// 3. Dado un array de strings, devolver uno nuevo con la longitud de cada palabra +// Input: ["hola", "perro", "sol"] +// Output: [4, 5, 3] + +/////////////////////////////////////////////////////// +// 4. Crear una función que reciba un número y diga si es positivo, negativo o cero +// Input: -5 +// Output: "Es negativo" + +/////////////////////////////////////////////////////// +// 5. Contar cuántos nombres empiezan con una letra determinada +// Input: ["Pedro", "Pablo", "Ana"], letra = "P" +// Output: 2 + +/////////////////////////////////////////////////////// +// 6. Dado un string, reemplazar los espacios por guiones +// Input: "Hola mundo js" +// Output: "Hola-mundo-js" + +/////////////////////////////////////////////////////// +// 7. Verificar si un string es un palíndromo +// Input: "oso" +// Output: true + +/////////////////////////////////////////////////////// +// 8. Devolver el número mayor de un array +// Input: [3, 8, 2, 10, 5] +// Output: 10 + +/////////////////////////////////////////////////////// +// 9. Mostrar los primeros N números pares +// Input: 5 +// Output: [0, 2, 4, 6, 8] + +/////////////////////////////////////////////////////// +// 10. Dado un array de edades, calcular el promedio +// Input: [20, 30, 40] +// Output: 30 + +/////////////////////////////////////////////////////// +// 11. Dado un string, devolver solo las vocales +// Input: "Hola mundo" +// Output: "Oaouo" + +/////////////////////////////////////////////////////// +// 12. Simular un carrito de compras que calcule el total y la cantidad de productos +const carrito = [ + { nombre: "Silla", precio: 500 }, + { nombre: "Mesa", precio: 1000 }, +]; +// Output: "Total: $1500, Productos: 2" + +/////////////////////////////////////////////////////// +// 13. Recibir un número y devolver su tabla de multiplicar del 1 al 10 +// Input: 3 +// Output: "3 x 1 = 3", ..., "3 x 10 = 30" + +/////////////////////////////////////////////////////// +//14. Eliminar los valores nulos o undefined de un array +// Input: [1, null, 3, undefined, 5] +// Output: [1, 3, 5] + +/////////////////////////////////////////////////////// +// 15. Buscar el producto más caro de una lista +// Input: productos con nombre y precio +// Output: nombre del más caro + +/////////////////////////////////////////////////////// +// 16. Contar cuántas letras tiene un texto sin contar los espacios +// Input: "Hola mundo" +// Output: 9 + +/////////////////////////////////////////////////////// +// 17. Repetir una palabra N veces y devolver un solo string +// Input: "Hola", 3 +// Output: "HolaHolaHola" + +/////////////////////////////////////////////////////// +//18. Simular un registro de usuario: verificar si el nombre de usuario ya existe +// Input: nombre = "pepe", usuarios = ["juan", "pepe"] +// Output: "El usuario ya existe" + +/////////////////////////////////////////////////////// +// 19. Recorrer un array de objetos de alumnos y mostrar quién aprobó (nota >= 6) +const alumnos = [ + { nombre: "Luis", nota: 7 }, + { nombre: "Ana", nota: 4 }, +]; +// Output: "Luis aprobó" + +/////////////////////////////////////////////////////// +// 20. Cambiar el nombre de todos los objetos en un array a mayúsculas +const usuarios = [{ nombre: "juan" }, { nombre: "pepe" }]; +// Output: [{ nombre: "JUAN" }, { nombre: "PEPE" }] diff --git a/Basic/propios/18.2-integrador-resueltos.js b/Basic/propios/18.2-integrador-resueltos.js new file mode 100644 index 00000000..2e6f82e9 --- /dev/null +++ b/Basic/propios/18.2-integrador-resueltos.js @@ -0,0 +1,197 @@ +// 1. Contar cuántos números pares hay en un array +// Input: [1, 2, 3, 4, 5, 6] +// Output: 3 +function contarPares(arr) { + let contador = 0; + for (let num of arr) { + if (num % 2 === 0) { + contador++; + } + } + return contador; +} + +console.log(contarPares([1, 2, 3, 4, 5, 6])); // 3 + +/////////////////////////////////////////////////////// +// 2. Crear una función que reciba un nombre y edad, y retorne un mensaje +// Input: "Juan", 15 +// Output: "Hola Juan, tenés 15 años." +function saludar(nombre, edad) { + return `Hola ${nombre}, tenés ${edad} años.`; +} + +console.log(saludar("Juan", 15)); + +/////////////////////////////////////////////////////// +// 3. Recorrer un array de nombres y saludar a cada uno +// Input: ["Ana", "Luis", "Pepe"] +// Output: "Hola Ana" "Hola Luis" "Hola Pepe" +const nombres = ["Ana", "Luis", "Pepe"]; + +for (let nombre of nombres) { + console.log(`Hola ${nombre}`); +} + +/////////////////////////////////////////////////////// +// 4. Buscar si un número existe en un array y en qué posición está +// Input: ([3, 7, 1, 9], 1) +// Output: "El número 1 está en la posición 2" +function buscarNumero(arr, numero) { + const index = arr.indexOf(numero); + if (index !== -1) { + return `El número ${numero} está en la posición ${index}`; + } else { + return "No se encontró el número."; + } +} + +console.log(buscarNumero([3, 7, 1, 9], 1)); // Posición 2 + +/////////////////////////////////////////////////////// +// 5. Dado un objeto de usuario, mostrar su información +const user = { + nombre: "Lucía", + edad: 23, + esAdmin: false, +}; +// Output: "Lucía tiene 23 años y no es admin" +const adminTexto = user.esAdmin ? "es admin" : "no es admin"; +console.log(`${user.nombre} tiene ${user.edad} años y ${adminTexto}`); + +/////////////////////////////////////////////////////// +// 6. Contar cuántos elementos mayores a 10 hay en un array +// Input: [5, 12, 8, 20, 30] +// Output: "Hay 3 números mayores a 10" +function contarMayores(arr) { + let contador = 0; + for (let num of arr) { + if (num > 10) { + contador++; + } + } + return `Hay ${contador} números mayores a 10`; +} + +console.log(contarMayores([5, 12, 8, 20, 30])); + +/////////////////////////////////////////////////////// +// 7. Crear una función que reciba un array de strings y devuelva uno nuevo con los strings en mayúsculas +// Input: ["perro", "gato"] +// Output: ["PERRO", "GATO"] +function aMayusculas(arr) { + const nuevoArray = []; + for (let palabra of arr) { + nuevoArray.push(palabra.toUpperCase()); + } + return nuevoArray; +} + +console.log(aMayusculas(["perro", "gato"])); + +/////////////////////////////////////////////////////// +// 8. Crear una función que reciba un string y lo devuelva al revés +// Input: "hola" +// Output: "aloh" +function invertirTexto(texto) { + return texto.split("").reverse().join(""); +} + +console.log(invertirTexto("hola")); // "aloh" + +/////////////////////////////////////////////////////// +// 9. Simular una pequeña agenda de contactos con un array de objetos +const contactos = [ + { nombre: "Juan", telefono: "1234" }, + { nombre: "Ana", telefono: "5678" }, +]; +// Función que busque un contacto por nombre y retorne el teléfono + +function buscarContacto(nombre) { + for (let contacto of contactos) { + if (contacto.nombre === nombre) { + return `Teléfono de ${nombre}: ${contacto.telefono}`; + } + } + return "Contacto no encontrado."; +} + +console.log(buscarContacto("Ana")); + +/////////////////////////////////////////////////////// +// 10. Crear una función que reciba un array de objetos con productos y calcule el total +const productos = [ + { nombre: "Pan", precio: 100 }, + { nombre: "Leche", precio: 200 }, +]; +// Output: 300 + +function calcularTotal(arr) { + let total = 0; + for (let item of arr) { + total += item.precio; + } + return total; +} + +console.log(calcularTotal(productos)); // 300 + +/////////////////////////////////////////////////////// +// 11. Filtrar solo los objetos de una lista que cumplan cierta condición +// Por ejemplo, productos cuyo precio sea mayor a 150 +const productos2 = [ + { nombre: "Pan", precio: 100 }, + { nombre: "Leche", precio: 200 }, + { nombre: "Queso", precio: 180 }, +]; + +function filtrarCaros(arr) { + const resultado = []; + for (let prod of arr) { + if (prod.precio > 150) { + resultado.push(prod); + } + } + return resultado; +} + +console.log(filtrarCaros(productos2)); + +/////////////////////////////////////////////////////// +// 12. Contador de vocales en un string +// Input: "Hola mundo" +// Output: 4 +function contarVocales(texto) { + let contador = 0; + const vocales = "aeiouAEIOU"; + + for (let letra of texto) { + if (vocales.includes(letra)) { + contador++; + } + } + return contador; +} + +console.log(contarVocales("Hola mundo")); // 4 + +/////////////////////////////////////////////////////// +// 13. Simular una mini base de datos de usuarios con login +const usuarios = [ + { username: "pepe", password: "123" }, + { username: "lola", password: "abc" }, +]; +// Función que reciba username y password, y diga si puede loguearse o no +function login(user, pass) { + for (let u of usuarios) { + if (u.username === user && u.password === pass) { + return "Login exitoso"; + } + } + return "Usuario o contraseña incorrectos"; +} + +console.log(login("pepe", "123")); // Login exitoso +console.log(login("lola", "000")); // Incorrecto + +/////////////////////////////////////////////////////// diff --git a/Basic/propios/18.2-integrador.js b/Basic/propios/18.2-integrador.js new file mode 100644 index 00000000..6c9f41ac --- /dev/null +++ b/Basic/propios/18.2-integrador.js @@ -0,0 +1,77 @@ +// 1. Contar cuántos números pares hay en un array +// Input: [1, 2, 3, 4, 5, 6] +// Output: 3 + +/////////////////////////////////////////////////////////// +// 2. Crear una función que reciba un nombre y edad, y retorne un mensaje +// Input: "Juan", 15 +// Output: "Hola Juan, tenés 15 años." + +/////////////////////////////////////////////////////// +// 3. Recorrer un array de nombres y saludar a cada uno +// Input: ["Ana", "Luis", "Pepe"] +// Output: "Hola Ana" "Hola Luis" "Hola Pepe" + +/////////////////////////////////////////////////////// +// 4. Buscar si un número existe en un array y en qué posición está +// Input: ([3, 7, 1, 9], 1) +// Output: "El número 1 está en la posición 2" + +/////////////////////////////////////////////////////// +// 5. Dado un objeto de usuario, mostrar su información +const user = { + nombre: "Lucía", + edad: 23, + esAdmin: false, +}; +// Output: "Lucía tiene 23 años y no es admin" + +/////////////////////////////////////////////////////// +// 6. Contar cuántos elementos mayores a 10 hay en un array +// Input: [5, 12, 8, 20, 30] +// Output: "Hay 3 números mayores a 10" + +/////////////////////////////////////////////////////// +// 7. Crear una función que reciba un array de strings y devuelva uno nuevo con los strings en mayúsculas +// Input: ["perro", "gato"] +// Output: ["PERRO", "GATO"] + +/////////////////////////////////////////////////////// +// 8. Crear una función que reciba un string y lo devuelva al revés +// Input: "hola" +// Output: "aloh" + +/////////////////////////////////////////////////////// +// 9. Simular una pequeña agenda de contactos con un array de objetos +const contactos = [ + { nombre: "Juan", telefono: "1234" }, + { nombre: "Ana", telefono: "5678" }, +]; +// Función que busque un contacto por nombre y retorne el teléfono + +/////////////////////////////////////////////////////// +// 10. Crear una función que reciba un array de objetos con productos y calcule el total +const productos = [ + { nombre: "Pan", precio: 100 }, + { nombre: "Leche", precio: 200 }, +]; +// Output: 300 + +/////////////////////////////////////////////////////// +// 11. Filtrar solo los objetos de una lista que cumplan cierta condición +// Por ejemplo, productos cuyo precio sea mayor a 150 + +/////////////////////////////////////////////////////// +// 12. Contador de vocales en un string +// Input: "Hola mundo" +// Output: 4 + +/////////////////////////////////////////////////////// +// 13. Simular una mini base de datos de usuarios con login +const usuarios = [ + { username: "pepe", password: "123" }, + { username: "lola", password: "abc" }, +]; +// Función que reciba username y password, y diga si puede loguearse o no + +/////////////////////////////////////////////////////// diff --git a/Basic/propios/19-objects-exercises.js b/Basic/propios/19-objects-exercises.js new file mode 100644 index 00000000..bdbf6d89 --- /dev/null +++ b/Basic/propios/19-objects-exercises.js @@ -0,0 +1,83 @@ + + +// 1. Crea un objeto con 3 propiedades +console.log("------------------------"); + +let object1 = { + name: "Exequiel", + age: 30, + work: "Programador" +} +console.log(object1); + +console.log("------------------------"); + + +// 2. Accede y muestra su valor +console.log(`Nombre: `, object1.name); +console.log(`Edad: `, object1.age); +console.log(`Ocupación: `, object1.work); + +console.log("------------------------"); + +// 3. Agrega una nueva propiedad +object1.hoby = "Mecánica" +console.log(object1); + +console.log("------------------------"); + +// 4. Elimina una de las 3 primeras propiedades +delete object1.age +console.log(object1); + +console.log("------------------------"); + +// 5. Agrega una función e invócala +object1.greet = function(moment){ + console.log(`Hola! ${moment}`); +} +object1.greet("buenos dias") + +console.log("------------------------"); +// 6. Itera las propiedades del objeto +for (let item in object1){ + console.log(object1[item]); +} + +console.log("------------------------"); +// 7. Crea un objeto anidado +let object2 = { + name: "Exequiel", + age: 30, + exp: { + first: "1 año en DR comex", + second: "3 año en Nubceo", + third: "6 meses en Mercado Libre" + } +} + +// 8. Accede y muestra el valor de las propiedades anidadas +console.log("Exp 1 - ", object2.exp.first); +console.log("Exp 2 - ", object2.exp.second); +console.log("Exp 3 - ", object2.exp.third); + + +console.log("------------------------"); + +// 9. Comprueba si los dos objetos creados son iguales +if (object1 == object2) { + console.log("Los objetos son iguales"); +} else { + console.log("Los objetos NO son iguales"); +} + +console.log("------------------------"); + +// 10. Comprueba si dos propiedades diferentes son iguales +if (object1.age == object2.exp) { + console.log("Las propiedades son iguales"); +} else { + console.log("Las propiedades NO son iguales"); +} + +console.log("------------------------"); diff --git a/Basic/propios/20-destructuring-spreading.js b/Basic/propios/20-destructuring-spreading.js new file mode 100644 index 00000000..eab3be05 --- /dev/null +++ b/Basic/propios/20-destructuring-spreading.js @@ -0,0 +1,119 @@ +// COMO LO HACEMOS NORMALMENTE: + +let myArray = [1, 2, 3, 4]; +let myObject = { + name: "Exequiel", + age: 30, + alias: "Chicho" +} + +let myValueOfArray = [1] +console.log(myValueOfArray); + +let myValueOfObject = myObject.name +console.log(myValueOfObject); +console.log("------------------------"); + + +// Destructuring (Desestructuración) + +/* + - Destructuring: Nos permite extraer valores de arrays u objetos, y asignarlos a variables. +*/ + + +// Sintaxis en Array: Para desestructurar se hace con [] en los array +let [firstValue, secondValue] = myArray; // No importa el nombre que le pongamos, respeta el orden. +// [llamaAlPimerValor, segundoValor, etc] = array +console.log(firstValue, secondValue); +console.log("------------------------"); + +// Sintaxis en Array con valores predeterminados +let [primerValor, segundoValor, tercerValor, cuartoValor, quintoValor = "default"] = myArray +console.log(primerValor); +console.log(segundoValor); +console.log(tercerValor); +console.log(cuartoValor); +console.log(quintoValor); // Si NO asignamos valor por default, esto seria undefined. +console.log("------------------------"); + +// Ignorar elementos del array (supongamos que queremos solo el indice 0 y 3) +let [primerValue, , , cuartoValue] = myArray +console.log(primerValue); +console.log(cuartoValue); +console.log("------------------------"); + +// ---------------------------------------------------------------------------------- + +// Sintaxis en Objects: Para desestructurar se hace con {} en los Objects +let { nombre, age, alias } = myObject; +// aca SI hay que respetar el nombre de la PROP, ya que los objetos manejan claves específicas +// para cada valor.. +console.log(nombre); +console.log(age); +console.log(alias); +console.log("------------------------"); + +// Sintaxis en Objects con valores predeterminados +let { nombre2, email = "Email@gmail.com"} = myObject; +console.log(nombre2); // Aca vemos el porque SI hay que respetar el nombre, sino es undefined.! +console.log(email); // Se muestra el valor por default. +console.log("------------------------"); + +// Sintaxis objects con nuevos nombres de variables +let { name: newName, age: newAge, alias: newAlias } = myObject; +// let {nombreOriginal: nombreInventado, edadOriginal: edadInventada} +console.log(newName); +console.log(newAge); +console.log(newAlias); +console.log("------------------------"); + +// Objetos anidados +let person = { + name: "Exequiel", + edad: 30, + alias: "Chicho", + job: { + name: "Programador", + exp: "4" + } +} + +let { name: nombrePersona, job: {exp, name: nombreJob} } = person +// hacemos destructuring de una prop, igual que lo hacemos con el objeto entero +// Tambien podemos ponerle el nombre que querramos {job: {original: nuevoNombre}} +console.log(nombrePersona); +console.log(nombreJob); +console.log(exp); +console.log("------------------------"); + +// Spreading (Propagación) (...) + +/* + - Spreading: Nos sirve para expandir elementos de un array o un objeto a otro nuevo. +*/ + +// Sintaxis Array +let myArray2 = [...myArray] // Nos traemos los elementos del array anterior al actual. +let myArray3 = [...myArray, 8, 9] // ahora le sumamos tambien nuestros propios valores + +console.log(myArray2); +console.log(myArray3); +console.log("------------------------"); + +// Combinación de Arrays +let myArray4 = [...myArray2, ...myArray3] + +console.log(myArray4); +console.log("------------------------"); + +// Sintaxis Objects +let person4 = {...myObject, provincia: "Mendoza", departamento: "Lujan"} +// Traemos los valores de myObject, y ademas sumamos los que querramos, respetando clave -> valor +console.log(person4); + +console.log("------------------------"); + + +// Tanto destructuring como spreading se usa mucho en el día a día, sobre todo para +// trabajar de una manera mas eficiente. \ No newline at end of file diff --git a/Basic/propios/21-destructuring-spreading-exercises.js b/Basic/propios/21-destructuring-spreading-exercises.js new file mode 100644 index 00000000..34898624 --- /dev/null +++ b/Basic/propios/21-destructuring-spreading-exercises.js @@ -0,0 +1,107 @@ +// 1. Usa desestructuración para extraer los dos primeros elementos de un array +let myArray = ["Elem1", "Elem2", "Elem3"]; +let [primerElemento, segundoElemento] = myArray; + +console.log(primerElemento); +console.log(segundoElemento); +console.log("...................................."); + +// 2. Usa desestructuración en un array y asigna un valor predeterminado a una variable +let myArray2 = ["Casa", "Dpto"] +let [home1 = "vacío", home2 = "vacío", home3 = "vacío"] = myArray2 + +console.log(home1); +console.log(home2); +console.log(home3); + +console.log("...................................."); + +// 3. Usa desestructuración para extraer dos propiedades de un objeto +let person = { + name: "Exequiel", + age: 26, + work: "Programing" +} +let { name, age } = person + +console.log(name); +console.log(age); + +console.log("...................................."); + +// 4. Usa desestructuración para extraer dos propiedades de un objeto y asígnalas +// a nuevas variables con nombres diferentes +let { name: nuevoNombre, age: nuevaEdad } = person + +console.log(nuevoNombre); +console.log(nuevaEdad); + +console.log("...................................."); + +// 5. Usa desestructuración para extraer dos propiedades de un objeto anidado +let person2 = { + name: "Exequiel", + age: 26, + work: "Programing", + games: { + auto: "F1", + shooter: "CS2" + } +} +let { games: {auto, shooter} } = person2; + +console.log(auto); +console.log(shooter); + +console.log("...................................."); + +// 6. Usa propagación para combinar dos arrays en uno nuevo +let myArray3 = [1,2,3] +let myArray4 = [4,5,6] +let myArray5 = [...myArray3, ...myArray4] + +console.log(myArray5); + +console.log("...................................."); + +// 7. Usa propagación para crear una copia de un array +let myArray6 = [...myArray5] + +console.log(myArray6); + +console.log("...................................."); + +// 8. Usa propagación para combinar dos objetos en uno nuevo +let myObject2 = { + prop1: "Prop-1", + prop2: "Prop-2" +} + +let myObject3 = { + prop3: "Prop-3", + prop4: "Prop-4" +} + +let myObject4 = {...myObject2, ...myObject3} + +console.log(myObject4); + +console.log("...................................."); + +// 9. Usa propagación para crear una copia de un objeto +let myObject5 = {...myObject4} + +console.log(myObject5); + +console.log("...................................."); + +// 10. Combina desestructuración y propagación +let nuevoArray = [5,4,3,2,1] +let nuevoArray2 = ["a", "b", "c", "d"] + +let [primerLetra, segundaLetra] = nuevoArray2 +let nuevoArray3 = [...nuevoArray, primerLetra, segundaLetra] + +console.log(nuevoArray3); + +console.log("...................................."); diff --git a/Basic/propios/22-classes.js b/Basic/propios/22-classes.js new file mode 100644 index 00000000..9e76de44 --- /dev/null +++ b/Basic/propios/22-classes.js @@ -0,0 +1,216 @@ +// Clases +/* + Nos sirve para crear plantillas de objetos, creamos una plantilla con propiedades + y metodos, pero NO le damos valores. Los valores se los damos al momento de instanciar + una clase y crear un nuevo objeto. +*/ + +let person = { + name: "Exequiel", + age: 30, + alias: "Chicho", +}; + +console.log("----------------------------"); +class Person { + constructor(name, age, alias) { + // constructor: es una especie de funcion especial que nos permite definir cual es la + // estructura de propiedades inicial de la clase (name, age, alias) + this.name = name; + this.age = age; + this.alias = alias; + // this sirve para hacer referencia a una propiedad que pertenece a la clase (NO al param) + } +} + +// Para instanciar la clase usamos "new" y el nombre de la clase. Nos devolvera un objeto +let personToClass = new Person("Exe", 35, "El mejor"); +let personToClass2 = new Person("Franco", 25, "Pibin"); + +// La plantilla o clase nos sirve para crear multiples objetos distintos +console.log(personToClass); +console.log(personToClass2); + +console.log("----------------------------"); + +// Valores por defecto + +class DefaultPerson { + // Similar a como lo hacemos en un destructuring + constructor(name = "Vacio1", age = "Vacio2", alias = "Vacio3") { + this.name = name; + this.age = age; + this.alias = alias; + } +} + +let defaultPerson = new DefaultPerson("Cristian"); + +console.log(defaultPerson); +console.log("----------------------------"); + +// Acceso a propiedades +/* + (igual que con los objetos, con un punto y el nombre de la prop) + (igual que con los objetos, con los ["nombrePropiedad"]) +*/ + +let personToClass3 = new Person("Alexander", 45, "Alex"); + +console.log(personToClass3.alias); +console.log(personToClass3["age"]); +console.log("----------------------------"); + +// Modificación de valores + +personToClass3.alias = "nuevo alias"; + +console.log(personToClass3); +console.log("----------------------------"); + +// Funciones en clases + +class PersonWithMethod { + constructor(name = "Vacio1", age = "Vacio2", alias = "Vacio3") { + this.name = name; + this.age = age; + this.alias = alias; + } + + // Las funciones, getters y setters van FUERA del constructor + walk() { + console.log("Caminando....."); + } +} + +let newPersonWithMethod = new PersonWithMethod("Nico", 56, "Nik"); + +console.log(newPersonWithMethod); + +newPersonWithMethod.walk(); // Asi hacemos uso de la funcion dentro del objeto creado por la clase +console.log("----------------------------"); + +// Propiedades privadas (podemos crear propiedades que NO se puedan acceder, osea que sean privadas) + +class PrivatePerson { + #bank; // Con esta sintaxis definimos a bank como propiedad privada + + constructor(name = "Vacio1", age = "Vacio2", alias = "Vacio3", bank) { + this.name = name; + this.age = age; + this.alias = alias; + this.#bank = bank; // Aca tambien se agrega el "#" + } + pay() { + if (this.bank !== null) { + console.log("Pago exitoso"); + } + } +} + +let privatePersonInstance = new PrivatePerson("Edu", 18, "cuca", 4564564564564); + +console.log(privatePersonInstance); // NO se muestra la prop privada +privatePersonInstance.pay(); +console.log("----------------------------"); + +// Getters y Setters + +class GetSetPerson { + #name; + #age; + #alias; + #bank; + + constructor(name, age, alias, bank) { + this.#name = name; // Podemos leerla si el get la retorna. :) + this.#age = age; // Sigue siendo privada + this.#alias = alias; // Sigue siendo privada + this.#bank = bank; // Sigue siendo privada + } + + // Con el método get podemos disponibilizar la propiedad que tenemos como privada, pero + // solo para leerla, no nos permite modificarla. + get name() { + return this.#name; + } + + set bank(newBank) { + this.#bank = newBank; + } +} + +let getPersonInstance = new GetSetPerson("Andres", 26, "Andy", "12313545454"); +let readOnlyGetPerson = getPersonInstance.name; + +console.log(getPersonInstance); // Aca lo sigue estando oculto name +console.log(readOnlyGetPerson); // Aca sí lo podemos acceder + +// seteamos el valor de bank +getPersonInstance.bank = "New bank 123123132"; +console.log("----------------------------"); + +// ----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +console.log("-------------HERENCIA---------------"); + +// HERENCIA -> Sirve para heredar las propiedades y el comportamiento de una clase existente + +class Animal { + constructor(name) { + this.name = name; + } + + sound() { + console.log("Emite un sonido"); + } +} + +// Con la palabra extends + la clase que queremos heredar. +class Perro extends Animal { + run() { + console.log("Perro corriendo"); + } + + // Sobreescribimos la funcion de la clase padre, pero solo para la clase Perro + sound() { + console.log("Perro ladrando"); + } +} + +class Fish extends Animal { + constructor(name, size) { + // Con super accedemos a propiedades de la clase SUPERIOR, sirve para seguir heredando el + // comportamiento del padre, y ademas sumar nuevas propiedades. + super(name); + this.size = size; + } +} + +let dog = new Perro("Tuqui"); // Nos pide name porque en la clase padre esta definido +dog.run(); // Este metodo es de la clase Perro +dog.sound(); // Este metodo es de la clase Animal + +console.log(dog); +console.log("----------------------------"); + +let fish = new Fish("Nemo", 123); +// Nos pide agregar el name porque usamos super() para traerlo de la clase superior. + +console.log(fish); +console.log("----------------------------"); + +// Métodos estáticos +class MathOperations { + // static nos sirve para acceder a la funcion SIN necesidad de instanciar la clase + static sum(a, b) { + return a + b; + } + + // Aca debajo podemos crear mas fuinciones estaticas o no... +} + +// Sin usar new ni instanciar la clase podemos llamar a estas funciones estaticas. +let operations = MathOperations.sum(10, 5); +console.log(operations); +console.log("----------------------------"); diff --git a/Basic/propios/23-classes-exercises.js b/Basic/propios/23-classes-exercises.js new file mode 100644 index 00000000..dea03f60 --- /dev/null +++ b/Basic/propios/23-classes-exercises.js @@ -0,0 +1,138 @@ +// 1. Crea una clase que reciba dos propiedades +console.log("............................"); + +class Auto { + constructor(year, model) { + this.year = year; + this.model = model; + } +} + +let newAuto = new Auto("2004", "Ford Ka"); +console.log(newAuto); + +console.log("............................"); + +// 2. Añade un método a la clase que utilice las propiedades +class Auto2 { + constructor(year, model) { + this.year = year; + this.model = model; + } + + infoCar() { + console.log(`El auto ${this.model} es del año ${this.year}`); + } +} + +let newAuto2 = new Auto2(2013, "Chevrolet corsa"); +console.log(newAuto2); + +console.log("............................"); + +// 3. Muestra los valores de las propiedades e invoca a la función +class Auto3 { + constructor(year, model) { + this.year = year; + this.model = model; + } + + infoCar() { + console.log(`El auto ${this.model} es del año ${this.year}`); + } +} + +let newAuto3 = new Auto3(2010, "Chevrolet Onix"); +console.log(newAuto3); + +console.log("............................"); + +// 4. Añade un método estático a la primera clase +class Auto4 { + constructor(year, model) { + this.year = year; + this.model = model; + } + + static run() { + console.log("Vehiculo en marcha"); + } +} + +console.log("............................"); + +// 5. Haz uso del método estático + +Auto4.run(); + +// 6. Crea una clase que haga uso de herencia +class Camioneta extends Auto { + constructor(year, model, marca, origen) { + super(year, model); + + this.marca = marca; + this.origen = origen; + } +} + +let newCamioneta = new Camioneta(2015, "S-10", "Chevrolet", "Brasil"); + +console.log(newCamioneta); + +console.log("............................"); + +// 7. Crea una clase que haga uso de getters y setters + +class Person { + #cvu; + constructor(name, surename, cvu) { + this.name = name; + this.surename = surename; + this.#cvu = cvu; + } + + get cvu() { + return this.#cvu; + } + + set cvu(newCvu) { + this.#cvu = newCvu; + } +} + +console.log("............................"); + +// 8. Modifica la clase con getters y setters para que use propiedades privadas + +let newPerson = new Person("Exequiel", "Guiñazú", 123456789); +let cvuPerson = newPerson.cvu; // USO DEL GET + +console.log(newPerson); +console.log(cvuPerson); + +newPerson.cvu = 99999999999; // USO DEL SET + +let cvuPerson2 = newPerson.cvu; // USO DEL GET +console.log(cvuPerson2); + +console.log("............................"); + +// 9. Utiliza los get y set y muestra sus valores +// -> SE HIZO EN EL EJERCICIO DE ARRIBA + +// 10. Sobrescribe un método de una clase que utilice herencia + +class Auto5 extends Auto4 { + constructor(year, model, brand) { + super(year, model); + this.brand = brand; + } + run() { + console.log("Arrancanding"); // Pisamos el metodo original + } +} + +let ultimoAuto = new Auto5(2012, "Ford Fiesta", "Ford"); + +ultimoAuto.run(); +console.log(ultimoAuto); diff --git a/Basic/propios/24-error-handling.js b/Basic/propios/24-error-handling.js new file mode 100644 index 00000000..f916f6c3 --- /dev/null +++ b/Basic/propios/24-error-handling.js @@ -0,0 +1,154 @@ +// Manejo de errores (se conoce como excepciones también) +/* + Siempre pueden ocurrir errores, en estos casos necesitamos manejar estos errores + para saber que paso, y para que nuestra app NO crashee +*/ + +// Excepción (algo que no esperabamos que pasara en nuestro flujo) + +/* + CAPTURAMOS ERRORES CON: TRY CATCH + LANZAMOS ERRORES CON: THROW new Error() +*/ + +// let myObject; +// Como no existe email, nuestro programa se rompe +// console.log(myObject.email); + +// ---------------------------------------------------------------------------------------- +// ---------------------------------------------------------------------------------------- +// ---------------------------------------------------------------------------------------- +// ---------------------------------------------------------------------------------------- + +// TRY - CATCH + +// try: Intenta ejecutar un código que puede fallar +// catch: Captura el error que ocurrio en el try +console.log("--------------------------------"); + +try { + let myObject; + console.log(myObject.email); // -> Esta linea devuelve un error, porque email NO existe + console.log("Finaliza la ejecución sin errores"); +} catch { + console.log("Se ha producido un error"); +} +console.log("--------------------------------"); + +// Captura del error + +try { + let myObject; + console.log(myObject.email); // -> Esta linea devuelve un error, porque email NO existe + console.log("Finaliza la ejecución sin errores"); +} catch (error) { + // dentro del error tenemos propiedades utiles, como "message" + console.log("Se ha producido un error", error.message); +} +console.log("--------------------------------"); + +// Finally -> Para ejecutar algún codigo en concreto se cumpla o no el try. +// Seria una especia de ejecucion por default + +try { + let myObject; + console.log(myObject.email); // -> Esta linea devuelve un error, porque email NO existe + console.log("Finaliza la ejecución sin errores"); +} catch (error) { + console.log("Se ha producido un error", error.message); +} finally { + // Puede servir para hacer una limpieza de datos luego de que termine la ejecución, o similar. + console.log("Este código se ejecuta SIEMPRE"); +} +console.log("--------------------------------"); + +// NO SOPORTADO -> No tiene catch +// try { +// let myObject; +// console.log(myObject.email); // -> Esta linea devuelve un error, porque email NO existe +// console.log("Finaliza la ejecución sin errores"); +// } finally { +// // Puede servir para hacer una limpieza de datos luego de que termine la ejecución, o similar. +// console.log("Este código se ejecuta SIEMPRE"); +// } + +// Lanzamiento de errores (podemos lanzar errores cuando creamos necesario) + +// throw +// throw new Error("Se ha producido un error creado por nosotros"); + +function sum(a, b) { + if (typeof a !== "number" || typeof b !== "number") { + throw new Error("Esta operación es solo con numeros"); + } + return a + b; +} + +// Solo se ejecuta el try o el catch, NO ambos. +try { + console.log(sum(21, 9)); +} catch (error) { + console.log("Se ha producido un error", error.message); +} +console.log("--------------------------------"); + +// Capturar varios tipos de errores + +/* + Existen varios tipos de errores para diferenciarlos: + + Error() + TypeError() + RefererError() + SintaxError() + + Podemos elegir el mas adecuado para nuestro caso. +*/ + +function mult(a, b) { + if (a === undefined || b === undefined) { + // Lanzamos un Error + throw new Error("Falta alguno de los argumentos"); + } + if (typeof a !== "number" || typeof b !== "number") { + // Lanzamos un TypeError + throw new TypeError("Esta operación es solo con valores numéricos"); + } + if (a == 0 || b == 0) { + throw new MyCustomError("No se soporta la operación con 0", a, b); + } + return a * b; +} + +try { + console.log(mult(21, "2")); +} catch (error) { + if (error instanceof TypeError) { + console.log("Se ha producido un error de tipo: ", error.message); + } else if (error instanceof Error) { + console.log("Se ha producido un error:", error.message); + } +} +console.log("--------------------------------"); + +// Crear Excepciones personalizadas + +class MyCustomError extends Error { + constructor(message, a, b) { + super(message); + this.a = a; + this.b = b; + } + + printNumbers() { + console.log(this.a, "+", this.b); + } +} + +try { + console.log(mult(0, 0)); +} catch (error) { + console.log("Se ha producido un error: ", error.message); + error.printNumbers(); +} +console.log("--------------------------------"); diff --git a/Basic/propios/25-error-handling-exercises.js b/Basic/propios/25-error-handling-exercises.js new file mode 100644 index 00000000..e64e6248 --- /dev/null +++ b/Basic/propios/25-error-handling-exercises.js @@ -0,0 +1,219 @@ +// 1. Captura una excepción utilizando try-catch +console.log("----------------------------------------------"); + +try { + let myObject; + console.log(myObject.name); +} catch (error) { + console.log("Se ha producido un error: ", error.message); +} + +console.log("----------------------------------------------"); + +// 2. Captura una excepción utilizando try-catch y finally + +try { + let myObject; + console.log(myObject.name); +} catch (error) { + console.log("Se ha producido un error: ", error.message); +} finally { + console.log("Esto siempre se va a mostrar"); +} + +console.log("----------------------------------------------"); + +// 3. Lanza una excepción genérica +const getName = (name) => { + const person = { + nombre: "Exe", + age: 30, + }; + if (person[name] !== undefined) { + return person[name]; + } else { + throw new Error("La propiedad no existe"); + } +}; + +try { + // let name = getName("nombre"); + let name = getName("name"); + console.log(name); +} catch (error) { + console.log("Se ha producido un error: ", error.message); +} + +console.log("----------------------------------------------"); + +// 4. Crea una excepción personalizada +class CustomError extends Error { + constructor(message, contingency) { + super(message); + this.contingency = contingency; + } + + showContingency() { + console.log("CONTINGENCIA: ", this.contingency); + } +} + +const getNumber = (number) => { + const numbers = { + primero: 15, + segundo: 30, + }; + if (numbers[number] !== undefined) { + return numbers[number]; + } else { + throw new CustomError( + "El número no existe", + "Debés enviar un número correcto!!" + ); + } +}; + +try { + let number = getNumber("Tercero"); + console.log(number); +} catch (error) { + console.log("Se ha producido un error: ", error.message); + error.showContingency(); +} + +console.log("----------------------------------------------"); + +// 5. Lanza una excepción personalizada +// -> SE HIZO EN EL EJERCICIO DE ARRIBA + +// 6. Lanza varias excepciones según una lógica definida +const getValue = (value) => { + if (value === 0) { + throw new Error("El valor NO puede ser 0!"); + } + if (value === null || value === undefined) { + throw new TypeError("El valor es nulo!"); + } + return value; +}; + +try { + getValue(0); + // getValue(); +} catch (error) { + console.log("Se ha producido el siguiente error: ", error.message); +} + +console.log("----------------------------------------------"); + +// 7. Captura varias excepciones en un mismo try-catch + +const getValue2 = (value) => { + if (value === 0) { + throw new Error("El valor NO puede ser 0!"); + } + if (value === null || value === undefined) { + throw new TypeError("El valor es nulo!"); + } + return value; +}; + +try { + try { + console.log(getValue2(0)); + } catch (error) { + console.log("Se ha producido el siguiente error: ", error.message); + } + try { + console.log(getValue2(2)); + } catch (error) { + console.log("Se ha producido el siguiente error: ", error.message); + } + try { + console.log(getValue2(null)); + } catch (error) { + console.log("Se ha producido el siguiente error: ", error.message); + } +} catch (error) { + console.log("Se ha producido el siguiente error: ", error.message); +} + +console.log("----------------------------------------------"); + +// 8. Crea un bucle que intente convertir una lista de valores a float cada valor y capture y muestre los errores + +const valores = ["123.45", "abc", "78.9", null, undefined, "56.7px", {}, []]; + +valores.forEach((valor, index) => { + try { + let convertido = parseFloat(valor); + if (isNaN(convertido)) { + throw new Error(`No se puede convertir "${valor}" a float.`); + } + console.log(`Valor en índice ${index}: ${convertido}`); + } catch (error) { + console.error(`Error en índice ${index}: ${error.message}`); + } +}); + +console.log("----------------------------------------------"); + +// 9. Crea una función que verifique si un objeto tiene una propiedad específica y lance una excepción + +let myObject2 = { + name: "Exe", + surname: "Guiñazu", + age: 30, +}; + +const getValueToObject = (value) => { + let element = myObject2[value]; + if (element) { + console.log(element); + } else { + throw new Error("Elemento NO encontrado"); + } +}; + +try { + getValueToObject("casa"); + // getValueToObject("name"); +} catch (error) { + console.log("Se ha producido un error: ", error.message); +} + +// 10. Crea una función que realice reintentos en caso de error hasta un máximo de 10 + +function ejecutarConReintentos(funcion, maxReintentos = 10, espera = 1000) { + for (let intento = 1; intento <= maxReintentos; intento++) { + try { + return funcion(); // Intenta ejecutar la función + } catch (error) { + console.error(`Intento ${intento} fallido: ${error.message}`); + if (intento < maxReintentos) { + console.log(`Reintentando en ${espera / 1000} segundos...`); + const inicio = Date.now(); + while (Date.now() - inicio < espera) {} // Pausa el código por el tiempo especificado + } else { + throw new Error( + `Se ha producido un error tras ${maxReintentos} intentos.` + ); + } + } + } +} + +// Función que puede fallar +function tareaArriesgada() { + if (Math.random() < 0.7) throw new Error("Error lanzado por nosotros mismos"); // Falla el 70% de las veces + return "¡Éxito!"; +} + +try { + const resultado = ejecutarConReintentos(tareaArriesgada); + console.log("Resultado final:", resultado); +} catch (error) { + console.error("¡Error crítico!: ", error.message); +} + +console.log("--------------------------------------------"); diff --git a/Basic/propios/26-console-methods.js b/Basic/propios/26-console-methods.js new file mode 100644 index 00000000..05009031 --- /dev/null +++ b/Basic/propios/26-console-methods.js @@ -0,0 +1,68 @@ +// Console + +// log +console.log("Este metodo es muy común"); + +// error (se muestra en rojo) +console.error("Esto es un error"); +console.error("Error al conectarse a la DB: ", new Error("CONEXIÓN FALLIDA")); + +// warn (para mostrar advertencias) +console.warn("Esto es una advertencia"); + +// info (muestra info) +console.info("Este es un mensaje de información"); + +// table (muestra una estructura con formato tabla) +let data = [ + ["Exe", 37], + ["Fran", 22], +]; +console.table(data); + +// Le ponemos nombre a la columna +data = [ + { name: "Exe", age: 30 }, + { name: "Fran", age: 23 }, +]; +console.table(data); + +// group y group end +console.group("Usuario"); // Inicia el grupo + +console.log("Cosa 1"); +console.log("Cosa 2"); +console.log("Cosa 3"); +console.log("Cosa 4"); + +console.groupEnd(); // Finaliza el grupo + +// time (para evaluar el tiempo que demora en ejecutarse un bloque de codigo) +console.time("Tiempo de ejecución"); // Le ponemos nombre a esta medición +for (let i = 0; i < 10000; i++) {} +console.timeEnd("Tiempo de ejecución"); // Aca va el mismo nombre que pusimo arriba +// console.timeEnd("Finalizar"); esto es un error, porque no coincide con el primer console.time + +// assert (Muestra un mensaje de error si lo que evalua es falso) +let age = 17; +console.assert(age >= 18, "El usuario debe ser mayor de edad"); + +// count (cuenta la cantidad de veces que se ha llamado con una etiqueta específica) +console.count("Click"); +console.count("Click"); +console.count("Click"); + +console.countReset("Click"); // Para resetear el contador + +// trace (muestra el seguimiento de la pila de ejecución) +function a() { + b(); +} + +function b() { + console.trace("Seguimiento de la ejecución"); +} +a(); + +//clear (para limpiar toda la consola) +// console.clear(); diff --git a/Basic/propios/27-modules-export.js b/Basic/propios/27-modules-export.js new file mode 100644 index 00000000..169335eb --- /dev/null +++ b/Basic/propios/27-modules-export.js @@ -0,0 +1,48 @@ +// Exportación de módulos + +/* + Exportar modulos nos permite mantener de mejor manera nuestro codigo, dividirlo, reutilizarlo. + Podemos usar el codigo que creamos en este fichero, desde otro contexto de nuestra app. +*/ + +// Funciones +export function sum(a, b) { + return a + b; +} +// console.log(add(10, 15)); + +// Propiedades +export const PI = 3.1416; +export let name = "EXEQUIEL"; + +/* + En la exportación que NO es por defecto, exportamos por separado la funcion, + la variable y la constante. Y al importarlo en el otro archivo tiene que estar + dentro de {llaves} y con el nombre correcto. + */ + +// ----------------------------------------------------------- + +// Exportación por defecto +export default function substract(a, b) { + return a - b; +} + +/* + En la exportación por default, estamos exportando la lógica, pero a la hora de + importarlo en otro archivo, podemos usar cualquier nombre. y fuera de las + llaves {} + IMPORTANTE!!:: No puede hacer mas de una exportación por default en un archivo + IMPORTANTE!!:: Solo podemos exportar por default funciones, clases, pero NO variables + */ + +// Clases +export class Circle { + constructor(radius) { + this.radius = radius; + } + + area() { + return Math.PI * Math.pow(this.radius, 2); + } +} diff --git a/Basic/propios/27-modules-import.js b/Basic/propios/27-modules-import.js new file mode 100644 index 00000000..901fd349 --- /dev/null +++ b/Basic/propios/27-modules-import.js @@ -0,0 +1,28 @@ +// Importación de modulos + +/* + Usamos la palabra reservada IMPORT, nombre de lo que queremos importar, + y el from "ruta..." de donde queremos importarlo +*/ + +// Podemos usar la funcion add que definimos en el otro archivo. + +import cualquierNombre, { sum, name, PI } from "./27-modules-export"; + +// Funciones: +console.log(sum(10, 5)); +console.log(PI); +console.log(name); + +// Importación por defecto +console.log(cualquierNombre(5, 2)); + +// Clases +let circle = new Circle(10); + +console.log(circle); +console.log(circle.area().toFixed(2)); + +// Módulos externos (como importar modulos externos?) +// let os = require("os"); +// console.log(os); diff --git a/Intermediate/00-advanced-functions.js b/Intermediate/00-advanced-functions.js index a2c8d53c..14814593 100644 --- a/Intermediate/00-advanced-functions.js +++ b/Intermediate/00-advanced-functions.js @@ -1,155 +1,159 @@ -/* -Clase 1 - Funciones avanzadas (29/01/2025) -Vídeo: https://www.twitch.tv/videos/2367024319?t=00h08m45s -*/ +// Funciones avanzadas -// Ciudadanos de primera clase +// CIUDADANOS DE PRIMERA CLASE // +// 1- Podemos asignar una función a una variable o constante const greet = function (name) { - console.log(`Hola, ${name}`) -} + console.log(`Hola ${name}`); +}; -greet("Brais") +greet("Juan"); +// 2- Una función puede ser pasada como argumento de otra función function processGreeting(greetFunction, name) { - greetFunction(name) + greetFunction(name); } +processGreeting(greet, "Exequiel"); + +// 3- Una función puede retornar otra función function returnGreeting() { - return greet + return greet; } +const greet2 = returnGreeting(); -processGreeting(greet, "MoureDev") -const greet2 = returnGreeting() -greet2("Brais Moure") +greet2("Cristian"); -// Arrow functions avanzadas +// ARROW FUNCTIONS // -// - Retorno implícito -const multiply = (a, b) => a * b -console.log(multiply(2, 5)) +// 1- Retorno Implicito +const sum = (a, b) => a + b; // Retorna una expresión +console.log(sum(10, 6)); -// - this léxico +// 2- This léxico para el contexto de un objeto. const handler = { - name: "Brais", - greeting: function () { - console.log(`Hola, ${this.name}`) - }, - arrowGreeting: () => { - console.log(`Hola, ${this.name}`) - } -} + name: "Alexander", + greeting: function () { + console.log(`Hola ${this.name}`); // Hereda el this de su contexto. + }, + greeting2: () => console.log(`Hola ${this.name}`), // Es undefined porque NO hace referencia al contexto del objeto. +}; -handler.greeting() -handler.arrowGreeting(); +handler.greeting(); +handler.greeting2(); -// IIFE (Expresión de Función Invocada Inmediatamente) +// IIFE - Immediately Invoked Function Expression (Expresión de función invocada inmediatamente) // +// IIFE clásico (function () { - console.log("IIFE clásico") + console.log("IIFE clásico"); })(); +// IIFE arrow function (() => { - console.log("IIFE con arrow function") + console.log("IIFE arrow function"); })(); -// Parámetros Rest (...) +// Parámetros REST (....) // -function sum(...numbers) { - let result = 0 - for (let number of numbers) { - result += number - } - return result +function sumTotal(...numbers) { + // Pueden ser N parámetros + let result = 0; + for (const number of numbers) { + result += number; + } + + return result; } -console.log(sum(1, 2, 3, 4, 5)) -console.log(sum(10, 15)) +sumTotal(1, 2, 3, 4, 5); +sumTotal(10, 15); + +// Operador SPREAD (...) // -// Operador Spread (...) +const numbers = [6, 7, 8]; -const numbers = [1, 2, 3] function sumWithSpread(a, b, c) { - return a + b + c + return a + b + c; } -console.log(sumWithSpread(1, 2, 3)) // Sin Spread -console.log(sumWithSpread(...numbers)) // Con Spread +console.log("SUMA: ", sumWithSpread(3, 6, 9)); +console.log("SUMA: ", sumWithSpread(...numbers)); // Expandimos el array de numbers -// Closures (Clausuras) +// CLOSURES (Clausuras) // function createCounter() { - let counter = 0 - return function () { - counter++ - console.log(`Contador: ${counter}`) - } + let counter = 0; + + return function () { + // Se puede ejecutar N veces pero conservando el estado de counter, osea el scope de la function padre. + counter++; + console.log("Contador: ", counter); + }; } -const counter = createCounter() -counter() -counter() -counter() -counter() +const counter = createCounter(); // Aca instanciamos la función padre y crea el context de counter +counter(); +// Aca solamente llamamos a la función hija de createCounter(), +// NO volvemos a instanciar la función padre, y asi NO se inicializa desde 0 counter. +counter(); -// Recursividad +// RECURSIVIDAD (Es una función que se llama a si misma) // +// Siempre debemos delimitar un contexto en donde en algún momento se deje de llamar a si misma function factorial(n) { - if (n <= 1) { - return 1 - } - return n * factorial(n - 1) + if (n <= 1) { + return 1; + } + return n * factorial(n - 1); } -console.log(factorial(5)) +console.log(factorial(3)); + +// FUNCIONES PARCIALES // -// Funciones parciales +// (Es la idea de dividir una función con varios parámetros +// en funciones más pequeñas que reciben parte de los parametros, y retornan una nueva +// función que espera los siguientes parametros.) function partialSum(a) { - return function (b, c) { - return sum(a, b, c) - } + return function (b, c) { + return sumTotal(a, b, c); + }; } -const sumWith = partialSum(4) -console.log(sumWith(2, 3)) -console.log(sumWith(1, 2)) +const sumWith = partialSum(4); +sumWith(6, 6); +sumWith(1, 2); -// Currying +// Currying // (Transformar una función con múltiples parámetros en una secuencia de funciones de un parámetro) -function currySum(a) { - return function (b) { - return function (c) { - return function (d) { - return sum(a, b, c, d) - } - } - } +function curryingSum(a) { + return function (b) { + return function (c) { + return a + b + c; + }; + }; } -const sumAB = currySum(1)(2) -const sumC = sumAB(3) -console.log(sumC(3)) -console.log(sumC(4)) -console.log(sumAB(5)(7)) +const sumAB = curryingSum(4)(6); +console.log("Suma AB:", sumAB(3)); +console.log("Suma AB:", sumAB(5)); +console.log("Suma AB:", sumAB(10)); -// Callbacks +// CALLBACKS // (A una función, le pasamos otra función como argumento para personalizar su comportamiento) +// (Es como inyectar una lógica personalizada) -function processData(data, callback) { - const result = sum(...data) - callback(result) +function processData(data, callbak) { + const suma = sumTotal(...data); + callbak(suma); } function processResult(result) { - console.log(result) -} - -function processResult2(result) { - console.log(`Mi resultado es: ${result}`) + console.log("RESULTADO FINAL", result); } -processData([1, 2, 3], processResult) -processData([1, 2, 3], processResult2) -processData([1, 2, 3], (result) => { - console.log(`Mi resultado en la arrow function es: ${result}`) -}) \ No newline at end of file +processData([2, 4, 6], processResult); +processData([2, 4, 6], (result) => + console.log("Resultado con arrow function", result) +); diff --git a/Intermediate/01-advanced-functions-exercises.js b/Intermediate/01-advanced-functions-exercises.js index 26dd4c70..533a5c92 100644 --- a/Intermediate/01-advanced-functions-exercises.js +++ b/Intermediate/01-advanced-functions-exercises.js @@ -1,13 +1,37 @@ -/* -Clase 1 - Funciones avanzadas (29/01/2025) -Vídeo: https://www.twitch.tv/videos/2367024319?t=00h08m45s -*/ - // 1. Crea una función que retorne a otra función +const functionA = () => { + return () => { + console.log("Segunda función"); + }; +}; + +const callFunctionA = functionA(); +callFunctionA(); // 2. Implementa una función currificada que multiplique 3 números +const functionCurrying = (a) => { + return (b) => { + return (c) => { + return a * b * c; + }; + }; +}; + +const currying1 = functionCurrying(5)(10); // Al llamarla recibe a, pero al ejecutarla también recibe b (segundo parentesis) +const currying2 = currying1(2); // Esta sería la instancia del segundo return +console.log(currying2); // 3. Desarrolla una función recursiva que calcule la potencia de un número elevado a un exponente +function factorial(n) { + if (n <= 1) { + return 1; + } + console.log("N", n); + + return n * factorial(n - 1); +} + +console.log(factorial(4)); // 4. Crea una función createCounter() que reciba un valor inicial y retorne un objeto con métodos para increment(), decrement() y getValue(), utilizando un closure para mantener el estado @@ -21,4 +45,4 @@ Vídeo: https://www.twitch.tv/videos/2367024319?t=00h08m45s // 9. Implementa un retorno implícito -// 10. Haz uso del this léxico \ No newline at end of file +// 10. Haz uso del this léxico diff --git a/Intermediate/02-advanced-structures.js b/Intermediate/02-advanced-structures.js index ffd8bde1..7d705884 100644 --- a/Intermediate/02-advanced-structures.js +++ b/Intermediate/02-advanced-structures.js @@ -1,150 +1,75 @@ -/* -Clase 2 - Estructuras avanzadas (05/02/2025) -Vídeo: https://www.twitch.tv/videos/2373300186?t=00h15m32s -*/ +// Estructuras avanzadas // Arrays avanzados -// - Métodos funcionales +// - Métodos // -// forEach +// forEach (accede a cada uno de los elementos, pero no devuelve un array como MAP) +let numbers = [1, 2, 3, 4, 5, 6]; +let numbers2 = numbers.forEach((element) => console.log(element * 2)); +console.log(numbers2); // undefined -let numbers = [1, 2, 3, 4, 5, 6] +// map (accede a cada uno de los elementos y retorna un nuevo array transformando cada elemento) +let newNumbers = numbers.map((element) => element * 2); +console.log(newNumbers); -numbers.forEach(element => console.log(element)) +// filter (siguiendo el mandato de MAP, filter nos va a devolver un nuevo array con el filtro que apliquemos) +let evens = numbers.filter((element) => element % 2 === 0); +console.log(evens); -// map +// reduce (es una función reductora sobre cada elemento del array, devolviendo la suma del "valorPrevio" + "valorActual") +let sum = numbers.reduce( + (valorPrevio, valorActual) => valorPrevio + valorActual, // En el "valorPrevio" se va acumulando el total + 0 +); +console.log(sum); -let doubled = numbers.map(element => element * 2) -console.log(doubled) +//////////////////////////////////////////////////////////////////////////////////////////////////// +// - Manipulación // -// filter +// flat (aplana un array que tenga una profundidad específica) +let nestedArray = [1, [2, [3, [4]]]]; +let flatArray = nestedArray.flat(3); // nivel de profundidad +console.log(flatArray); // [ 1, 2, 3, 4 ] -let evens = numbers.filter(element => element % 2 === 0) -console.log(evens) +// flatMap (combina flat y map) +let phrases = ["Hola mundo", "Adios mundo"]; +let words = phrases.flatMap((phrase) => phrase.split(" ")); +console.log(words); -// reduce +//////////////////////////////////////////////////////////////////////////////////////////////////// +// - Ordenación // -let sum = numbers.reduce((result, current) => result + current, 0) -console.log(sum) +// sort (devuelve un nuevo array ordenado siguiendo un criterio que le pasemos, por defecto lo hace alfabéticamente) +// let unsorted = [3, 4, 1, 6, 10]; +let unsorted = ["b", "j", "a", "c"]; +let sorted = unsorted.sort(); +console.log(sorted); -// - Manipulación +let unsorted2 = [3, 4, 1, 6, 10]; +let sorted2 = unsorted2.sort((a, b) => a - b); // Criterio de comparación para números +console.log(sorted2); -// flat +// reverse (NO devuelve un nuevo array, muta el array original y lo da vuelta) +unsorted2.reverse(); // No necesitamos guardarlo en una variable, ya que muta al original, NO devuelve nada +console.log(unsorted2); -let nestedArray = [1, [2, [3, [4]]]] -console.log(nestedArray) -let flatArray = nestedArray.flat(1) -console.log(flatArray) -flatArray = nestedArray.flat(2) -console.log(flatArray) -flatArray = nestedArray.flat(3) -console.log(flatArray) +//////////////////////////////////////////////////////////////////////////////////////////////////// +// - Búsqueda // -// flatMap +// includes (Recibe un elemento como parámetro, y verifica si ese elemento existe en el array.) +console.log(sorted2.includes(5)); // Devuelve un boolean -let phrases = ["Hola mundo", "Adiós mundo"] -let words = phrases.flatMap(phrase => phrase.split(" ")) -console.log(words) +// find (Devuelve el primer elemento que cumpla cierta condición mas compleja que includes()) +sorted2 = [5, 8, 2, 6, 9, 8, 5, 1]; +let firstEven = sorted2.find((element) => element % 2 === 0); // si no encuentra ninguno devuelve undefined +console.log(firstEven); -// - Ordenación +// findIndex (misma lógica que el find, pero devuelve el índice del elemento, no su valor.) +let firstIndex = sorted2.findIndex((element) => element % 2 === 0); // si no encuentra ninguno devuelve -1 +console.log(firstIndex); -// sort +//////////////////////////////////////////////////////////////////////////////////////////////////// +// - Sets avanzados // -let unsorted = ["b", "a", "d", "c"] -let sorted = unsorted.sort() -console.log(sorted) - -unsorted = [3, 4, 1, 6, 10] -sorted = unsorted.sort((a, b) => a - b) - -console.log(sorted) - -// reverse - -sorted.reverse() -console.log(sorted) - -// - Búsqueda - -// includes - -console.log(sorted.includes(4)) -console.log(sorted.includes(5)) - -// find - -let firstEven = sorted.find(element => element % 2 === 0) -console.log(firstEven) - -// findIndex - -let firstEvenIndex = sorted.findIndex(element => element % 2 === 0) -console.log(firstEvenIndex) - -// Sets avanzados - -// - Operaciones - -// Eliminación de duplicados - -let numbersArray = [1, 2, 2, 3, 4, 5, 6, 6] -numbersArray = [...new Set(numbersArray)] -console.log(numbersArray) - -// Unión - -const setA = new Set([1, 2, 3]) -const setB = new Set([2, 3, 4, 5]) -const union = new Set([...setA, ...setB]) -console.log(union) - -// Intersección - -const intersection = new Set([...setA].filter(element => setB.has(element))) -console.log(intersection) - -// Diferencia - -const difference = new Set([...setA].filter(element => !setB.has(element))) -console.log(difference) - -// - Conversión - -// Set a Array - -console.log([...setA]) - -// - Iteración - -// forEach - -setA.forEach(element => console.log(element)) - -// Maps avanzados - -// - Iteración - -let myMap = new Map([ - ["name", "MoureDev"], - ["age", 37] -]) - -myMap.forEach((value, key) => console.log(`${key}: ${value}`)) - -// - Conversión - -// Map a Array - -const arrayFromMap = Array.from(myMap) -console.log(arrayFromMap) - -// Map a Objeto - -const objectFromMap = Object.fromEntries(myMap) -console.log(objectFromMap) - -// Objeto a Map - -const mapFromObject = new Map(Object.entries(objectFromMap)) -console.log(mapFromObject) \ No newline at end of file +// diff --git a/Intermediate/03-advanced-structures-exercises.js b/Intermediate/03-advanced-structures-exercises.js deleted file mode 100644 index 0539144a..00000000 --- a/Intermediate/03-advanced-structures-exercises.js +++ /dev/null @@ -1,24 +0,0 @@ -/* -Clase 2 - Estructuras avanzadas (05/02/2025) -Vídeo: https://www.twitch.tv/videos/2373300186?t=00h15m32s -*/ - -// 1. Utiliza map, filter y reduce para crear un ejemplo diferente al de la lección - -// 2. Dado un array de números, crea uno nuevo con dichos números elevados al cubo y filtra sólo los números pares - -// 3. Utiliza flat y flatMap para crear un ejemplo diferente al de la lección - -// 4. Ordena un array de números de mayor a menor - -// 5. Dados dos sets, encuentra la unión, intersección y diferencia de ellos - -// 6. Itera los resultados del ejercicio anterior - -// 7. Crea un mapa que almacene información se usuarios (nombre, edad y email) e itera los datos - -// 8. Dado el mapa anterior, crea un array con los nombres - -// 9. Dado el mapa anterior, obtén un array con los email de los usuarios mayores de edad y transfórmalo a un set - -// 10. Transforma el mapa en un objeto, a continuación, transforma el objeto en un mapa con clave el email de cada usuario y como valor todos los datos del usuario \ No newline at end of file