diff --git a/Basic/03-beginner-exercises.js b/Basic/03-beginner-exercises.js
index 2e7dd657..af1abe70 100644
--- a/Basic/03-beginner-exercises.js
+++ b/Basic/03-beginner-exercises.js
@@ -4,21 +4,122 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=4733
 */
 
 // 1. Escribe un comentario en una línea
-
+//mi primer comentario
 // 2. Escribe un comentario en varias líneas
-
+/**
+ * este
+ * es
+ * un
+ * comentario
+ * de
+ * varias
+ * lineas
+ */
 // 3. Declara variables con valores asociados a todos los datos de tipo primitivos
+let cadena = 'hola'
+
+let numeroEntero = 2
+
+let numeroDecimal = 3.234
+
+let numeroOctal = 7
+
+let booleano = true
+
+let indefinido = undefined
+
+let nulo = null
+
+let noEsNumero = NaN
+
+let miSimbolo = Symbol('simbolo de prueba')
+
+let EnteroGigante = 1234567890098976543265278968147387508324n
 
 // 4. Imprime por consola el valor de todas las variables
+console.log(cadena);
+console.log(numeroEntero);
+console.log(numeroDecimal);
+console.log(booleano);
+console.log(indefinido);
+console.log(nulo);
+console.log(noEsNumero);
+console.log(miSimbolo);
+console.log(EnteroGigante);
+
 
 // 5. Imprime por consola el tipo de todas las variables
+console.log(typeof cadena);
+console.log(typeof numeroEntero);
+console.log(typeof numeroDecimal);
+console.log(typeof booleano);
+console.log(typeof indefinido);
+console.log(typeof nulo);
+console.log(typeof noEsNumero);
+console.log(typeof miSimbolo);
+console.log(typeof EnteroGigante);
 
 // 6. A continuación, modifica los valores de las variables por otros del mismo tipo
 
+cadena = 'hola mundo'
+noEsNumero = 99
+numeroDecimal = 3.1416
+booleano = false
+miSimbolo = Symbol('numero simbolo')
+EnteroGigante = BigInt(12331231436456742345234537465)
+
 // 7. A continuación, modifica los valores de las variables por otros de distinto tipo
 
+cadena = 123
+noEsNumero = 'a'
+numeroDecimal = true
+booleano = Symbol('simboly123')
+miSimbolo = BigInt(12331231436456742345234537465234242)
+EnteroGigante = 23
+
 // 8. Declara constantes con valores asociados a todos los tipos de datos primitivos
+const cade2na = 'hola'
+
+const nume2roEntero = 2
+
+const nume2roDecimal = 3.234
+
+const nume2roOctal = 8
+
+const bool2eano = true
+
+const inde2finido = undefined
+
+const nulo2 = null
+
+const noEs2Numero = NaN
+
+const miSi2mbolo = Symbol('simbolo de prueba')
+
+const Ente2roGigante = 1234567890098976543265278968147387508324n
+
 
 // 9. A continuación, modifica los valores de las constantes
 
+// const cade2na = 'hola'
+
+// const nume2roEntero = 2
+
+// const nume2roDecimal = 3.234
+
+// const nume2roOctal = 7
+
+// const bool2eano = true
+
+// const inde2finido = undefined
+
+// const nulo2 = null
+
+// const noEs2Numero = NaN
+
+// const miSi2mbolo = Symbol('simbolo de prueba')
+
+// const Ente2roGigante = 1234567890098976543265278968147387508324n
+
+
 // 10. Comenta las líneas que produzcan algún tipo de error al ejecutarse
\ No newline at end of file
diff --git a/Basic/04-operators.js b/Basic/04-operators.js
index cac42886..a4f6f2d1 100644
--- a/Basic/04-operators.js
+++ b/Basic/04-operators.js
@@ -22,7 +22,7 @@ console.log(a)
 b-- // Decremento
 console.log(b)
 
-// Operadores de asignacion
+// Operadores de asignación
 
 let myVariable = 2
 console.log(myVariable)
@@ -64,7 +64,7 @@ console.log(undefined === null)
 /*
 Truthy values (valores verdaderos)
 
-- Todos los numeros positivos y negativos menos el cero
+- Todos los números positivos y negativos menos el cero
 - Todas las cadenas de texto menos las vacías
 - El boolean true
 */
diff --git a/Basic/05-operators-exercises.js b/Basic/05-operators-exercises.js
index a6265eac..ae3c3961 100644
--- a/Basic/05-operators-exercises.js
+++ b/Basic/05-operators-exercises.js
@@ -4,22 +4,54 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=6458
 */
 
 // 1. Crea una variable para cada operación aritmética
-
+let sumar = sumar + 1;
+let restar = restar - 1;
+let multiplicar = multiplicar * 1
+let dividir = dividir / 1
+let modulo = modulo % 1
+let exponente = exponente ** 1
 // 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
-
+sumar += 1
+restar -= 1
+multiplicar *= 1
+dividir /= 1
+modulo %= 1
+exponente **= 1
 // 3. Imprime 5 comparaciones verdaderas con diferentes operadores de comparación
 
+console.log(typeof 2 == 'number');
+console.log(20 < 65);
+console.log(200.94 > 65);
+console.log(sumar >= restar);
+console.log(exponente != 24);
+
+
 // 4. Imprime 5 comparaciones falsas con diferentes operadores de comparación
 
+console.log(null > undefined);
+console.log(5 < 1);
+console.log('hola' === 'prueba');
+console.log(typeof restar >= 'testing'.length);
+console.log(0 * 20 >= 38);
+
 // 5. Utiliza el operador lógico and
+console.log(restar > 1 && sumar > 1);
 
 // 6. Utiliza el operador lógico or
+console.log(exponente == 20 || 200 < 500);
 
 // 7. Combina ambos operadores lógicos
+console.log(sumar > 1 && restar == -1 || 20 === null);
 
 // 8. Añade alguna negación
+console.log(sumar !== null);
 
 // 9. Utiliza el operador ternario
+let trabajo = true;
+trabajo ? console.log('encendemos la pc y trabajamos')
+  : console.log('disfrutamos del dia');
+
+// 10. Combina operadores aritméticos, de comparación y lógicas
 
-// 10. Combina operadores aritméticos, de comparáción y lógicas
\ No newline at end of file
+console.log(15 / 24 >= 457 && typeof 'texto' != 'number' || 'random'.length === 23);
diff --git a/Basic/07-strings-exercises.js b/Basic/07-strings-exercises.js
index c08f0166..e6cf4727 100644
--- a/Basic/07-strings-exercises.js
+++ b/Basic/07-strings-exercises.js
@@ -4,21 +4,39 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=7226
 */
 
 // 1. Concatena dos cadenas de texto
+let cadena1 = 'hola'
+let cadena2 = 'mundo'
+console.log(cadena1 + cadena2);
 
 // 2. Muestra la longitud de una cadena de texto
+console.log(cadena1.length);
 
 // 3. Muestra el primer y último carácter de un string
+console.log(cadena1[1]);
+console.log(cadena1[3]);
 
 // 4. Convierte a mayúsculas y minúsculas un string
+console.log(cadena1.toLocaleLowerCase);
+console.log(cadena1.toLocaleUpperCase);
 
 // 5. Crea una cadena de texto en varias líneas
-
+let cadena3 = `hola
+esto
+es 
+una 
+cadena
+de 
+varias 
+lineas`
 // 6. Interpola el valor de una variable en un string
-
+let cadena4 = `esto contiene la variable: ${cadena1}`
 // 7. Reemplaza todos los espacios en blanco de un string por guiones
-
+let cadena5 = 'este mensaje sirve para probar funciones'
+cadena5.replaceAll(' ', '-')
 // 8. Comprueba si una cadena de texto contiene una palabra concreta
-
+console.log(cadena5.includes('mensaje'));
 // 9. Comprueba si dos strings son iguales
+console.log(cadena5 === cadena4);
 
-// 10. Comprueba si dos strings tienen la misma longitud
\ No newline at end of file
+// 10. Comprueba si dos strings tienen la misma longitud
+console.log(cadena5.length == cadena4.length);
\ No newline at end of file
diff --git a/Basic/09-conditionals-exercises.js b/Basic/09-conditionals-exercises.js
index 380e6542..d63484f8 100644
--- a/Basic/09-conditionals-exercises.js
+++ b/Basic/09-conditionals-exercises.js
@@ -6,24 +6,180 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=8652
 // if/else/else if/ternaria
 
 // 1. Imprime por consola tu nombre si una variable toma su valor
-
-// 2. Imprime por consola un mensaje si el usuario y contraseña concide con unos establecidos
-
+const nombre = "daniel"
+if (nombre === 'daniel') {
+  console.log(nombre)
+}
+// 2. Imprime por consola un mensaje si el usuario y contraseña coincide con unos establecidos
+const user = 'danv99', password = 123456;
+if (user === 'danv99' && password === 123456) {
+  console.log('usuario y contraseña correctos')
+} else {
+  console.log('usuario y contraseña incorrectos')
+}
 // 3. Verifica si un número es positivo, negativo o cero e imprime un mensaje
-
+const numero = 10;
+if (numero > 0) {
+  console.log('el numero es positivo');
+} else if (numero < 0) {
+  console.log('el numero es negativo');
+} else {
+  console.log('el numero es cero');
+}
 // 4. Verifica si una persona puede votar o no (mayor o igual a 18) e indica cuántos años le faltan
+const edad = 24;
+if (edad >= 18) {
+  console.log('puede votar');
+} else {
+  console.log(`no puede votar, le faltan ${18 - edad} años para ser mayor de edad`);
 
+}
 // 5. Usa el operador ternario para asignar el valor "adulto" o "menor" a una variable
-//    dependiendo de la edad 
-
+//    dependiendo de la edad
+const edad2 = 24;
+const etapa = edad >= 18 ? 'adulto' : 'menor';
 // 6. Muestra en que estación del año nos encontramos dependiendo del valor de una variable "mes"
+const mes = 7;
+if (mes >= 1 && mes <= 3) {
+  console.log(`la estacion del mes ${mes} es invierno`);
+
+} else if (mes >= 4 && mes <= 6) {
+  console.log(`la estacion del mes ${mes} es primavera`);
+
+} else if (mes >= 7 && mes <= 9) {
+  console.log(`la estacion del mes ${mes} es verano`);
 
+} else if (mes >= 10 && mes <= 12) {
+  console.log(`la estacion del mes ${mes} es otoño`);
+} else {
+  console.log(`El mes ${mes} no existe`);
+
+}
 // 7. Muestra el número de días que tiene un mes dependiendo de la variable del ejercicio anterior
+const lastDay = function (y, m) {
+  return `El mes ${m} tiene ${new Date(y, m + 1, 0).getDate()} Dias`
+}
+console.log(lastDay(2024, mes));
 
-// switch
 
 // 8. Usa un switch para imprimir un mensaje de saludo diferente dependiendo del idioma
+const idioma = 'español';
+
+switch (idioma) {
+  case 'español':
+    console.log('Hola mundo');
+    break;
+  case 'ingles':
+    console.log('Hello world');
+    break;
+  case 'frances':
+    console.log('Bonjour le monde');
+    break;
+  case 'italiano':
+    console.log('Ciao mondo');
+  case 'portugues':
+    console.log('olá mundo');
+
+    break;
+  default:
+    console.log(`el idioma ${idioma} no existe o no esta disponible`);
 
+    break;
+}
 // 9. Usa un switch para hacer de nuevo el ejercicio 6
+switch (mes) {
+  case 1:
+    console.log(`la estacion del mes ${mes} es invierno`);
+
+    break;
+  case 2:
+    console.log(`la estacion del mes ${mes} es invierno`);
+
+    break;
+  case 3:
+    console.log(`la estacion del mes ${mes} es invierno`);
+
+    break;
+  case 4:
+    console.log(`la estacion del mes ${mes} es primavera`);
+
+    break;
+  case 5:
+    console.log(`la estacion del mes ${mes} es primavera`);
+
+    break;
+  case 6:
+    console.log(`la estacion del mes ${mes} es primavera`);
+
+    break;
+  case 7:
+    console.log(`la estacion del mes ${mes} es verano`);
+    break;
+  case 8:
+    console.log(`la estacion del mes ${mes} es verano`);
+    break;
+  case 9:
+    console.log(`la estacion del mes ${mes} es verano`);
+    break;
+  case 10:
+    console.log(`la estacion del mes ${mes} es otoño`);
+    break;
+  case 11:
+    console.log(`la estacion del mes ${mes} es otoño`);
+    break;
+  case 12:
+    console.log(`la estacion del mes ${mes} es otoño`);
+    break;
+  default:
+    console.log(`EL mes ${mes} no existe`); break;
+
+}
+
+// 10. Usa un switch para hacer de nuevo el ejercicio 7
+switch (mes) {
+  case 1:
+    console.log(`El mes ${mes} tiene: 31 dias`);
+
+    break;
+  case 2:
+    console.log(`El mes ${mes} tiene: 29 dias`);
+
+    break;
+  case 3:
+    console.log(`El mes ${mes} tiene: 31 dias`);
+
+    break;
+  case 4:
+    console.log(`El mes ${mes} tiene: 30 dias`);
+
+    break;
+  case 5:
+    console.log(`El mes ${mes} tiene: 31 dias`);
+
+    break;
+  case 6:
+    console.log(`El mes ${mes} tiene: 30 dias`);
+
+    break;
+  case 7:
+    console.log(`El mes ${mes} tiene: 31 dias`);
+    break;
+  case 8:
+    console.log(`El mes ${mes} tiene: 31 dias`);
+    break;
+  case 9:
+    console.log(`El mes ${mes} tiene: 30 dias`);
+    break;
+  case 10:
+    console.log(`El mes ${mes} tiene: 31 dias`);
+    break;
+  case 11:
+    console.log(`El mes ${mes} tiene: 30 dias`);
+    break;
+  case 12:
+    console.log(`El mes ${mes} tiene: 31 dias`);
+    break;
+  default:
+    console.log(`EL mes ${mes} no existe`); break;
 
-// 10. Usa un switch para hacer de nuevo el ejercicio 7
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/Basic/13-structures-exercises.js b/Basic/13-structures-exercises.js
index 1b094502..8077fd6f 100644
--- a/Basic/13-structures-exercises.js
+++ b/Basic/13-structures-exercises.js
@@ -4,21 +4,46 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=11451
 */
 
 // 1. Crea un array que almacene cinco animales
-
+let animales = ['perro', 'gato', 'conejo', 'perico', 'tortuga']
 // 2. Añade dos más. Uno al principio y otro al final
-
+animales.unshift('cocodrilo')
+animales.push('caballo')
 // 3. Elimina el que se encuentra en tercera posición
-
+animales.splice(3, 1)
 // 4. Crea un set que almacene cinco libros
-
+let libros = new Set(['Las Batallas del desierto', 'La divina comedia', 'El diario de ana frank', 'El sutil arte de que te importe una m*rda', 'No me hagas pensar'])
 // 5. Añade dos más. Uno de ellos repetido
-
+libros.add('Los hornos de hitler')
+libros.add('El necronomicon')
 // 6. Elimina uno concreto a tu elección
-
+libros.delete('Las Batallas del desierto')
 // 7. Crea un mapa que asocie el número del mes a su nombre
-
+let meses = new Map(
+  [1, 'Enero'],
+  [2, 'Febrero'],
+  [3, 'Marzo'],
+  [4, 'Abril'],
+  [5, 'Mayo'],
+  [6, 'Junio'],
+  [7, 'Julio'],
+  [8, 'Agosto'],
+  [9, 'Septiembre'],
+  [10, 'Octubre'],
+  [11, 'Noviembre'],
+  [12, 'Diciembre']
+)
 // 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));
+
+}
 
 // 9. Añade al mapa una clave con un array que almacene los meses de verano
+meses.add('verano', [[7, 'Julio'], [8, 'Agosto'], [9, 'Septiembre']])
+// 10. Crea un Array, transfórmalo a un Set y almacénalo en un Map
+
+let arreglo = [[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd']]
+
+let arrayToSet = new Set(arreglo)
 
-// 10. Crea un Array, transfórmalo a un Set y almacénalo en un Map
\ No newline at end of file
+let setToMap = new Map(arrayToSet)
\ No newline at end of file
diff --git a/Basic/15-loops-exercises.js b/Basic/15-loops-exercises.js
index 2a27cdd0..8c11e685 100644
--- a/Basic/15-loops-exercises.js
+++ b/Basic/15-loops-exercises.js
@@ -6,21 +6,92 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=12732
 // NOTA: Explora diferentes sintaxis de bucles para resolver los ejercicios
 
 // 1. Crea un bucle que imprima los números del 1 al 20
-
+for (let i = 1; i <= 20; i++) {
+  console.log(i);
+}
 // 2. Crea un bucle que sume todos los números del 1 al 100 y muestre el resultado
+suma = 0;
+i = 1;
+while (i <= 100) {
+  suma += i
+  i++;
+}
+console.log('Resultado de la suma: ' + suma);
 
 // 3. Crea un bucle que imprima todos los números pares entre 1 y 50
-
+let i = 1;
+do {
+  if (i % 2 === 0) {
+    console.log(i);
+  }
+  i++
+} while (i <= 50)
 // 4. Dado un array de nombres, usa un bucle para imprimir cada nombre en la consola
+const nombres = ['juan', 'daniel', 'manuel', 'cristian', 'adrian', 'alan']
 
-// 5. Escribe un bucle que cuente el número de vocales en una cadena de texto
+for (let nombre of nombres) {
+  console.log(nombre);
 
+}
+// 5. Escribe un bucle que cuente el número de vocales en una cadena de texto
+const cadena = 'hola esto es una cadena de texto';
+let totalVocales = 0;
+for (let letra of cadena) {
+  switch (letra) {
+    case 'a':
+      totalVocales++;
+      break;
+    case 'e':
+      totalVocales++;
+      break;
+    case 'i':
+      totalVocales++;
+      break;
+    case 'o':
+      totalVocales++;
+      break;
+    case 'u':
+      totalVocales++;
+      break;
+  }
+}
+console.log('Total de vocales ' + totalVocales);
 // 6. Dado un array de números, usa un bucle para multiplicar todos los números y mostrar el producto
+const numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 4, 3, 4, 2, 1, 4, 3, 7]
+multiplicacion = 1;
+for (let numero of numeros) {
+  multiplicacion *= numero
+}
+console.log('Numeros multiplicados: ' + multiplicacion);
 
 // 7. Escribe un bucle que imprima la tabla de multiplicar del 5
-
+for (let i = 1; i <= 10; i++) {
+  console.log(`5 X ${i} = ${5 * i}`);
+}
 // 8. Usa un bucle para invertir una cadena de texto
+const cadena2 = 'hola'
+let cadenaInvertida = '';
+for (let i = 1; i <= cadena2.length; i++) {
+  cadenaInvertida += cadena2[cadena2.length - i]
+}
+console.log(cadenaInvertida);
 
 // 9. Usa un bucle para generar los primeros 10 números de la secuencia de Fibonacci
 
-// 10. Dado un array de números, usa un bucle para crear un nuevo array que contenga solo los números mayores a 10
\ No newline at end of file
+let serieFibonacci = [0, 1]
+for (let i = 2; i < 10; i++) {
+  serieFibonacci[i] = serieFibonacci[i - 2] + serieFibonacci[i - 1]
+}
+console.log(serieFibonacci);
+
+
+// 10. Dado un array de números, usa un bucle para crear un nuevo array que contenga solo los números mayores a 10
+const numeros2 = [10, 9, 3, 8, 57, 5, 3, 495, 10, 85, 37, 27, 4, 6, 7, 8, 9]
+let newArray = []
+
+for (let numero of numeros2) {
+  if (numero > 10) {
+    newArray.push(numero);
+  }
+}
+console.log(newArray);
diff --git a/Basic/17-functions-exercises.js b/Basic/17-functions-exercises.js
index fb7eb4e5..e7cc65d7 100644
--- a/Basic/17-functions-exercises.js
+++ b/Basic/17-functions-exercises.js
@@ -6,21 +6,123 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=14146
 // NOTA: Explora diferentes sintaxis de funciones para resolver los ejercicios
 
 // 1. Crea una función que reciba dos números y devuelva su suma
+function suma(a = 0, b = 0) {
+  return a + b
+}
+console.log(suma(5, 52));
 
 // 2. Crea una función que reciba un array de números y devuelva el mayor de ellos
+const numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const numMayor = function (numeross) {
+  console.log(Math.max(...numeross));
+}
+
+numMayor(numeros);
 
 // 3. Crea una función que reciba un string y devuelva el número de vocales que contiene
+let cadena = 'hola soy homero chino hola soy homero chino'
+
+function getVocales(cadena) {
+  let totalVocales = 0
+  cadena = cadena.split('')
+  cadena.forEach(element => {
+    if (element === 'a' || element === 'e' || element === 'i' || element === 'o' || element === 'u') {
+      totalVocales++;
+    }
+  });
+  console.log('Total vocales: ' + totalVocales);
+}
+getVocales(cadena)
 
 // 4. Crea una función que reciba un array de strings y devuelva un nuevo array con las strings en mayúsculas
+let strings = ['cubreme!', 'oh buena idea jefe', 'asi era cuando llegue']
+function upperCaseArray(customArray) {
+  customArray.forEach((string, index) => {
+    strings[index] = string.toUpperCase()
+  })
+}
+upperCaseArray(strings)
+console.log(strings);
 
 // 5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario
 
+function esPrimo(numero) {
+  let primo = false;
+  for (let i = 1; i <= numero; i++) {
+    let res = numero / i;
+    if (res !== 1 && res !== numero && numero % i === 0) {
+      primo = false;
+      break;
+    } else {
+      primo = true;
+    }
+  }
+  console.log('es primo: ' + primo);
+}
+
+esPrimo(6)
 // 6. Crea una función que reciba dos arrays y devuelva un nuevo array que contenga los elementos comunes entre ambos
+const array1 = [1, 2, 3, 'a', 'b', 'hola mundo', 'precious', 'little', 'diamond']
+const array2 = [9, 8, 7, 4, 2, 1, 'a', 'triste', 'prueba', 'precious', 'little', 'diamond']
+
+let finalArray = [];
+
+const elementosComunes = (array1, array2) => {
+
+  if (array1.length >= array2.length) {
+    array1.forEach(element => {
+      if (array2.includes(element)) { finalArray.push(element) }
+    });
+  } else {
+    array2.forEach(element => {
+      if (array1.includes(element)) {
+        finalArray.push(element)
+      }
+    });
+  }
+}
+elementosComunes(array1, array2)
+console.log('Elementos comunes: ' + finalArray);
 
 // 7. Crea una función que reciba un array de números y devuelva la suma de todos los números pares
+const arregloNumeros = [1, 6, 7, 9, 0, 4, 2, 57, 8, 5, 3, 2, 645, 2, 46, 7, 74];
+const arregloNumeros2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let Total = 0;
+arregloNumeros.forEach(numero => {
+  if (numero % 2 === 0) {
+    Total += numero
+  }
+});
+console.log('Suma de números pares: ' + Total);
 
 // 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 elevarNumeros(conjuntoNumeros) {
+  conjuntoNumeros.forEach((numero, index) => {
+    conjuntoNumeros[index] = numero ** 2
+  })
+  console.log('Numeros elevados al cuadrado:' + conjuntoNumeros);
+}
+let = conjuntoNumeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+elevarNumeros(conjuntoNumeros)
+
 
 // 9. Crea una función que reciba una cadena de texto y devuelva la misma cadena con las palabras en orden inverso
+let cadenaDeTexto = 'Anita Lava la Tina'
+function reverseString(cadenaDeTexto) {
+  cadenaDeTexto = cadenaDeTexto.toLowerCase().split(' ').reverse().join(' ')
+  console.log(cadenaDeTexto);
+
+}
+reverseString(cadenaDeTexto)
+
+// 10. Crea una función que calcule el factorial de un número dado
+
+function factorial(numero) {
+  let res = numero;
+  for (let i = numero - 1; i > 0; i--) {
+    res *= i
+  }
+  console.log(`Factorial de ${numero} es: ${res}`);
 
-// 10. Crea una función que calcule el factorial de un número dado
\ No newline at end of file
+}
+factorial(3);
\ No newline at end of file
diff --git a/Basic/19-objects-exercises.js b/Basic/19-objects-exercises.js
index 5dbbd628..6399e8a6 100644
--- a/Basic/19-objects-exercises.js
+++ b/Basic/19-objects-exercises.js
@@ -4,21 +4,59 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=15675
 */
 
 // 1. Crea un objeto con 3 propiedades
-
+let auto = {
+  color: 'negro',
+  marca: 'F1',
+  año: 2012
+}
 // 2. Accede y muestra su valor
+console.log(auto.marca);
 
 // 3. Agrega una nueva propiedad
-
+auto.modelo = 'F1234'
 // 4. Elimina una de las 3 primeras propiedades
-
+delete auto.color
 // 5. Agrega una función e invócala
+auto.run = function (velocity) {
+  console.log('el auto esta corriendo a ' + velocity);
 
+}
 // 6. Itera las propiedades del objeto
+for (let key in auto) {
+  console.log(`${key}: ${auto[key]}`);
 
+}
 // 7. Crea un objeto anidado
 
-// 8. Accede y muestra el valor de las propiedades anidadas
+let computadora = {
+  motherboard: 'ASUS ROG STRIX',
+  CPU: 'AMD RYZEN 5 5500X',
+  RAM: {
+    capacidad: '8GB',
+    slots: 2,
+    Marca: 'Corsair',
+    Modelo: 'Vengance RGB PRO',
+    Velocidad: '3600 Mhz'
+  },
 
+}
+
+// 8. Accede y muestra el valor de las propiedades anidadas
+for (let key in computadora.RAM) {
+  console.log(`${key}: ${computadora.RAM[key]}`);
+}
 // 9. Comprueba si los dos objetos creados son iguales
+if (auto === computadora) {
+  console.log('los objetos son iguales');
+
+} else {
+  console.log('los objetos no son iguales');
+
+}
+// 10. Comprueba si dos propiedades diferentes son iguales
+if (auto.marca === computadora.motherboard) {
+  console.log('las propiedades son iguales');
 
-// 10. Comprueba si dos propiedades diferentes son iguales
\ No newline at end of file
+} else {
+  console.log('las propiedades no son iguales');
+}
\ No newline at end of file
diff --git a/Basic/21-destructuring-spreading-exercises.js b/Basic/21-destructuring-spreading-exercises.js
index feadceb3..f1e3f7f6 100644
--- a/Basic/21-destructuring-spreading-exercises.js
+++ b/Basic/21-destructuring-spreading-exercises.js
@@ -4,22 +4,46 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=16802
 */
 
 // 1. Usa desestructuración para extraer los dos primeros elementos de un array 
-
+let array1 = [1, 2, 3, 4, 5, 67, 8,]
+let [number1, number2] = array1
 // 2. Usa desestructuración en un array y asigna un valor predeterminado a una variable
-
+let array2 = [1, 2, 3, 4, 5, 67, 8,]
+let [number3 = 12, number4 = 10] = array1
 // 3. Usa desestructuración para extraer dos propiedades de un objeto
-
+let object1 = {
+  name: 'a',
+  lastname: 'b',
+  phone: '5555645864',
+  blood_type: 'o+',
+  direction: {
+    street: 'test a #1',
+    city: 'mexico',
+    contry: 'mexico',
+    cp: '54785'
+  }
+}
+let object2 = {
+  shipping: false,
+  deliver: 'on store',
+  test: 'true'
+}
+let { name, lastname } = object1
 // 4. Usa desestructuración para extraer dos propiedades de un objeto y asígnalas
 //    a nuevas variables con nombres diferentes
-
+let { phone: userPhone, blood_type: bloodType } = object1
 // 5. Usa desestructuración para extraer dos propiedades de un objeto anidado
-
+let { direction: { street, city } } = object1
 // 6. Usa propagación para combinar dos arrays en uno nuevo
+let a = ['a', 'sdae', 'asfsfe', 'asfdgfsrf', '123', 12, 122, 211]
+let b = [1, 4, 63, 6, 3, 6, 454, 6, 4, 56]
 
+let newArray = [...a, ...b]
 // 7. Usa propagación para crear una copia de un array
-
+let copyArray = [...b]
 // 8. Usa propagación para combinar dos objetos en uno nuevo
-
+let combinedObject = { ...object1, ...object2 }
 // 9. Usa propagación para crear una copia de un objeto
+let copyObject = { ...object1 }
 
-// 10. Combina desestructuración y propagación
\ No newline at end of file
+// 10. Combina desestructuración y propagación
+let [combiancion] = [...array1]
diff --git a/Basic/23-classes-exercises.js b/Basic/23-classes-exercises.js
index e26e0232..0bb3b68d 100644
--- a/Basic/23-classes-exercises.js
+++ b/Basic/23-classes-exercises.js
@@ -4,21 +4,99 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=18630
 */
 
 // 1. Crea una clase que reciba dos propiedades
+class Clase1 {
+  constructor(a, b) {
+    this.a = a
+    this.b = b
+  }
 
+  static restar() {
+    return this.a - this.b
+  }
+}
+let clase1 = new Clase1(1, 2)
 // 2. Añade un método a la clase que utilice las propiedades
+class Clase2 {
+  constructor(a, b) {
+    this.a = a
+    this.b = b
+  }
 
+  sumar() {
+    return this.a + this.b
+  }
+
+}
+let clase2 = new Clase2(1, 2)
 // 3. Muestra los valores de las propiedades e invoca a la función
+console.log(clase2.a, clase2.b);
+clase2.sumar()
 
 // 4. Añade un método estático a la primera clase
-
+class Clase3 {
+  constructor(a, b) {
+    this.a = a
+    this.b = b
+  }
+  static restar() {
+    return this.a - this.b
+  }
+}
 // 5. Haz uso del método estático
-
+let clase3 = new Clase3(1, 5)
+clase3.restar()
 // 6. Crea una clase que haga uso de herencia
-
+class Clase4 extends Clase1 {
+  multiplicar() {
+    return this.a * this.b
+  }
+}
 // 7. Crea una clase que haga uso de getters y setters
+class Clase5 {
+  constructor(a, b) {
+    this.a = a
+    this.b = b
+  }
 
+  getValues() {
+    return { a: this.a, b: this.b }
+  }
+
+  setValues(a, b) {
+    this.a = a
+    this.b = b
+  }
+}
 // 8. Modifica la clase con getters y setters para que use propiedades privadas
+class Clase5 {
+  #a
+  #b
+  constructor(a, b) {
+    this.#a = a
+    this.#b = b
+  }
+
+  getValues() {
+    return { a: this.#a, b: this.#b }
+  }
 
+  setValues(a, b) {
+    this.#a = a
+    this.#b = b
+  }
+}
 // 9. Utiliza los get y set y muestra sus valores
+let clase5 = new Clase5(1, 6)
+console.log(clase5.getValues);
+clase5.setValues(6, 5)
+
+// 10. Sobrescribe un método de una clase que utilice herencia 
+
+class Clase6 extends Clase2 {
+  sumar() {
 
-// 10. Sobrescribe un método de una clase que utilice herencia 
\ No newline at end of file
+    let suma = 0
+    suma = this.a + this.b
+    return suma
+  }
+}
\ No newline at end of file
diff --git a/Basic/25-error-handling-exercises.js b/Basic/25-error-handling-exercises.js
index 5e227586..5734c206 100644
--- a/Basic/25-error-handling-exercises.js
+++ b/Basic/25-error-handling-exercises.js
@@ -4,21 +4,154 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=20392
 */
 
 // 1. Captura una excepción utilizando try-catch
-
+try {
+  5 / 0
+} catch {
+  console.log("no se puede dividir entre 0");
+}
 // 2. Captura una excepción utilizando try-catch y finally
+try {
+  console.log(arreglo.name);
 
-// 3. Lanza una excepción genérica
+} catch (error) {
+  console.log('Se produjo un error: ', error.message);
+} finally {
+  console.log('fin de proceso arreglo');
 
+}
+// 3. Lanza una excepción genérica
+let variable = 0;
+try {
+  if (variable == 0) {
+    throw new Error("La variable no puede ser 0")
+  }
+} catch (error) {
+  console.log(error.message);
+}
 // 4. Crea una excepción personalizada
+class customException extends Error {
+  constructor(message) {
+    super(message)
+  }
+  printMessage() {
+    console.log('end error message');
 
+  }
+
+}
 // 5. Lanza una excepción personalizada
+try {
+  10 / 0
+} catch (error) {
+  console.log('error personalizado: ', error.message);
+  error.printMessage()
 
+}
 // 6. Lanza varias excepciones según una lógica definida
+try {
+  let arreglo = [1, 2, 3, 4, 5];
+  if (arreglo.length <= 5) {
+    throw new Error('el arreglo es demasiado pequeño')
+  } else {
+    arreglo.forEach((number, index) => {
 
+      if (typeof number !== 'number') {
+        throw new TypeError('no es de tipo  numero')
+      }
+      if (number === 0) {
+        throw new Error('no se puede dividir entre 0')
+      } else {
+        arreglo[index] = number / 2
+      }
+    })
+  }
+} catch (error) {
+  if (error instanceof TypeError) {
+    console.log("Se ha producido un error de tipo:", error.message)
+  } else {
+    console.log('ocurrió un error:', error.message);
+  }
+}
 // 7. Captura varias excepciones en un mismo try-catch
+try {
+  let arreglo = [1, 2, 3, 4, 5];
+  if (arreglo.length <= 5) {
+    throw new Error('el arreglo es demasiado pequeño')
+  } else {
+    arreglo.forEach((number, index) => {
+      if (number === 0) {
+        throw new Error('no se puede dividir entre 0')
+      } else {
+        arreglo[index] = number / 2
+      }
+    })
+  }
+} catch (error) {
+  console.log('ocurrió un error:', error.message);
 
+}
 // 8. Crea un bucle que intente transformar a float cada valor y capture y muestre los errores
+let numeros = ['1.23', '3.6', '2.4', '1.3', '0']
+try {
+
+  numeros.forEach((number, index) => {
+    if (number === '0') {
+      throw new Error('el numero 0 no es un float')
+    } else {
+      numeros[index] = parseFloat(number)
+    }
+  })
+} catch (error) {
+  console.log('se produjo un error: ', error.message);
+
+}
 
 // 9. Crea una función que verifique si un objeto tiene una propiedad específica y lance una excepción personalizada
+class PropertyError extends Error {
+  constructor(message, propiedad) {
+    super(message)
+    this.propiedad = propiedad
+  }
+
+  printProperty() {
+    console.log('propiedad: ', this.propiedad)
+  }
+}
+
+try {
+  let objeto = {
+    a: 1,
+    b: 2,
+    nombre: 'prueba',
+    apellido: 'doe',
+    phone: '445853242',
+    clientHash: 'asgenrisufh3245583fej'
+  }
+  if (objeto.clientHash) {
+    throw new PropertyError('propiedad client hash incluida', objeto.clientHash)
+  }
+} catch (error) {
+  console.log("Se ha producido un error personalizado:", error.message)
+  error.printProperty()
+}
+
+// 10. Crea una función que realice reintentos en caso de error hasta un máximo de 10
+function retryOperation() {
+  let maxRetries = 10;
+  let attempts = 0;
 
-// 10. Crea una función que realice reintentos en caso de error hasta un máximo de 10
\ No newline at end of file
+  while (attempts < maxRetries) {
+    try {
+      // Simulación de una operación que puede fallar
+      if (Math.random() < 0.5) {
+        throw new Error("Operación fallida");
+      }
+      console.log("Operación exitosa después de", attempts, "intentos");
+      return;
+    } catch (error) {
+      console.log("Error en la operación:", error.message);
+      attempts++;
+    }
+  }
+  console.log("Se alcanzó el máximo de intentos");
+}
diff --git a/Basic/27-console-methods-exercises.js b/Basic/27-console-methods-exercises.js
index 9c38919b..901600cc 100644
--- a/Basic/27-console-methods-exercises.js
+++ b/Basic/27-console-methods-exercises.js
@@ -4,21 +4,67 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=21421
 */
 
 // 1. Crea un función que utilice error correctamente
-
+function checarEdad(edad) {
+  edad < 18 ? console.error('No puedes acceder a esta página') : console.log('Bienvenido a la página')
+}
 // 2. Crea una función que utilice warn correctamente
-
+function sumar(a = 0, b = 0) {
+  if (a == 0 || b == 0) {
+    console.warn('No se puede sumar 0')
+  } else {
+    console.log(a + b);
+  }
+}
 // 3. Crea una función que utilice info correctamente
-
+function saludar(nombre) {
+  console.info(`Hola ${nombre}, bienvenido a la página`)
+}
 // 4. Utiliza table
+let errorDetails = [
+  { name: 'error info', code: 'X243324' }
+]
 
+console.table(errorDetails)
 // 5. Utiliza group
+console.group('Grupo datos')
+console.log('Datos PC');
+console.log('Motherboard: ASUS ROG STRIX a620-m');
+console.log('Procesador: AMD ryzen 3 2200');
+console.log('RAM: Corsair Vengance pro 2 X 16 GB');
+console.groupEnd()
 
 // 6. Utiliza time
+console.time("Tiempo de ejecucion");
+let suma = 0;
+for (let i = 0; i < 1000; i++) {
+  console.log(suma += i);
+}
+console.timeEnd("Tiempo de ejecucion")
 
 // 7. Valida con assert si un número es positivo
-
+const numero = 4;
+console.assert(numero > 0, "El numero no es positivo")
 // 8. Utiliza count
-
+console.count('funcion ejecutada')
+console.count('funcion ejecutada')
+console.count('funcion ejecutada')
+console.count('funcion ejecutada')
 // 9. Utiliza trace
+function funcA() {
+  funcB()
+}
+
+function funcB() {
+  console.trace("Seguimiento de la ejecución.")
+}
+function funcC() {
+  funcA()
+}
+function funcD() {
+  funcA()
+}
+funcC()
+funcD()
+// 10. Utiliza clear
 
-// 10. Utiliza clear
\ No newline at end of file
+console.clear();
diff --git a/Basic/31-modules-exercises.js b/Basic/31-modules-exercises.js
index a09c62b9..5fd3e49c 100644
--- a/Basic/31-modules-exercises.js
+++ b/Basic/31-modules-exercises.js
@@ -4,21 +4,42 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=22720
 */
 
 // 1. Exporta una función
+export function prueba() {
+  console.log('funcion de prueba');
 
+}
 // 2. Exporta una constante
-
+export const a = 234238
 // 3. Exporta una clase
-
+export class prueba2 {
+  constructor() {
+    console.log('clase de prueba');
+  }
+}
 // 4. Importa una función
-
+import { prueba } from "./31-modules-exercises.js";
 // 5. Importa una constante
-
+import { a } from "./31-modules-exercises.js";
 // 6. Importa una clase
-
+import { prueba2 } from "./31-modules-exercises.js";
 // 7. Exporta una función, una constante y una clase por defecto (en caso de que lo permita)
+export function prueba5() {
+  console.log('tercera funcion');
 
-// 8. Importa una función, una constante y una clase por defecto (en caso de que lo permita)
+}
+
+export const numeroID = 23434234
 
+export default class prueba6 {
+  constructor() {
+    console.log('clase por defecto');
+  }
+}
+
+// 8. Importa una función, una constante y una clase por defecto (en caso de que lo permita)
+import prueba5, { numeroID, prueba6 } from "./31-modules-exercises.js";
 // 9. Exporta una función, una constante y una clase desde una carpeta
+import prueba5, { numeroID, prueba6 } from "../../practice-dev/Js/export-import-js/index.js";
 
-// 10. Importa una función, una constante y una clase desde un directorio diferente al anterior
\ No newline at end of file
+// 10. Importa una función, una constante y una clase desde un directorio diferente al anterior
+import prueba10, { identificador, registros } from "../../practice-dev/Js/Nodejs/hello-nodejs/src/index.js";
\ No newline at end of file