diff --git a/Basic/.prettierrc b/Basic/.prettierrc
new file mode 100644
index 00000000..3469682d
--- /dev/null
+++ b/Basic/.prettierrc
@@ -0,0 +1,6 @@
+{
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": false,
+  "trailingComma": "all"
+}
diff --git a/Basic/02-datatypes.js b/Basic/02-datatypes.js
new file mode 100644
index 00000000..9b076eee
--- /dev/null
+++ b/Basic/02-datatypes.js
@@ -0,0 +1,41 @@
+// Clase 2 en curso | 17/07/2024
+// Tipos de datos primitivos
+
+// Cadenas de texto (string)
+let myName = "Brais Moure"
+let alias = 'MoureDev'
+
+// Números (number)
+let age = 37 // Entero
+let height = 1.77 // Decimal
+
+// Booleanos (boolean)
+let isTeacher = true
+let isStudent = false
+
+// Undefined
+let undefinedValue
+console.log(undefinedValue)
+
+// Null
+let nullValue = null
+
+// Symbol
+let mySymbol = Symbol("mysymbol")
+
+// BigInt
+let myBigInt = BigInt(9879887765765878987656789876789876)
+let myBigInt2 = 9879887765765878987656789876789876n
+
+// Mostramos los tipos de datos
+console.log(typeof myName)
+console.log(typeof alias)
+console.log(typeof age)
+console.log(typeof height)
+console.log(typeof isTeacher)
+console.log(typeof isStudent)
+console.log(typeof undefinedValue)
+console.log(typeof nullValue)
+console.log(typeof mySymbol)
+console.log(typeof myBigInt)
+console.log(typeof myBigInt2)
\ No newline at end of file
diff --git a/Basic/03-beginner-exercises.js b/Basic/03-beginner-exercises.js
new file mode 100644
index 00000000..02ff6ac4
--- /dev/null
+++ b/Basic/03-beginner-exercises.js
@@ -0,0 +1,83 @@
+/*
+Clase 2 en vídeo | 17/07/2024
+Tipos de datos, operadores y strings
+https://www.twitch.tv/videos/2200149072?t=00h08m02s
+*/
+
+// 1. Escribe un comentario en una línea
+// Como este
+
+// 2. Escribe un comentario en varias líneas
+/*
+* Como este otro
+*/
+
+// 3. Declara variables con valores asociados a todos los datos de tipo primitivos
+
+let myName = "Brais Moure" // String
+let age = 37 // Number
+let isTeacher = true // Boolean
+let undefinedValue // Undefined
+let nullValue = null // Null
+let mySymbol = Symbol("mysymbol") // Symbol
+let myBigInt = 9879887765765878987656789876789876n // BigInt
+
+// 4. Imprime por consola el valor de todas las variables
+
+console.log(myName)
+console.log(age)
+console.log(isTeacher)
+console.log(undefinedValue)
+console.log(nullValue)
+console.log(mySymbol)
+console.log(myBigInt)
+
+// 5. Imprime por consola el tipo de todas las variables
+
+console.log(typeof myName)
+console.log(typeof age)
+console.log(typeof isTeacher)
+console.log(typeof undefinedValue)
+console.log(typeof nullValue)
+console.log(typeof mySymbol)
+console.log(typeof myBigInt)
+
+// 6. A continuación, modifica los valores de las variables por otros del mismo tipo
+
+myName = "MoureDev"
+age = 38
+isTeacher = false
+mySymbol = Symbol("mysymbol2")
+myBigInt = 9879887765765878987656789876789877n
+
+// 7. A continuación, modifica los valores de las variables por otros de distinto tipo
+
+myName = 38
+age = "MoureDev"
+isTeacher = Symbol("mysymbol")
+mySymbol = 9879887765765878987656789876789876n
+myBigInt = false
+undefinedValue = null
+nullValue = 9879887765765878987656789876789876789876n
+
+// 8. Declara constantes con valores asociados a todos los tipos de datos primitivos
+
+const myName2 = "Brais Moure" // String
+const age2 = 37 // Number
+const isTeacher2 = true // Boolean
+const mySymbol2 = Symbol("mysymbol")  // Symbol
+const myBigInt2 = 9879887765765878987656789876789876n // BigInt
+const undefinedValue2 = undefined // Undefined
+const nullValue2 = null // Null
+
+// 9. A continuación, modifica los valores de las constantes
+
+// myName2 = "MoureDev"
+// age2 = 38
+// isTeacher2 = false
+// mySymbol2 = Symbol("mysymbol2")
+// myBigInt2 = 9879887765765878987656789876789877n
+// undefinedValue2 = null
+// nullValue2 = 98
+
+// 10. Comenta las líneas que produzcan algún tipo de error al ejecutarser
\ No newline at end of file
diff --git a/Basic/04-operators.js b/Basic/04-operators.js
new file mode 100644
index 00000000..a5353018
--- /dev/null
+++ b/Basic/04-operators.js
@@ -0,0 +1,110 @@
+/*
+Clase 2 en vídeo | 17/07/2024
+Tipos de datos, operadores y strings
+https://www.twitch.tv/videos/2200149072?t=00h08m02s
+*/
+
+// Operadores Aritméticos
+
+let a = 5
+let b = 10
+
+console.log(a + b) // Suma
+console.log(a - b) // Resta
+console.log(a * b) // Multiplicación
+console.log(a / b) // División
+
+console.log(a % b) // Módulo
+console.log(a ** b) // Exponente
+
+a++ // Incremento
+console.log(a)
+
+b-- // Decremento
+console.log(b)
+
+// Operadores de asignacion
+
+let myVariable = 2
+console.log(myVariable)
+myVariable += 2 // Suma con asignación
+console.log(myVariable)
+
+myVariable -= 2 // Resta con asignación
+myVariable *= 2 // Multiplicación con asignación
+myVariable /= 2 // División con asignación
+myVariable %= 2 // Módulo con asignación
+myVariable **= 2 // Exponente con asignación
+
+// Operadores de comparación
+
+console.log(a > b) // Mayor que
+console.log(a < b) // Menor que
+console.log(a >= b) // Mayor o igual que
+console.log(a <= b) // Menor o igual que
+console.log(a == b) // Igualdad por valor
+console.log(a == 6)
+console.log(a == "6")
+console.log(a == a)
+console.log(a === a) // Igualdad por identidad (por tipo y valor) o igualdad estricta
+console.log(a === 6)
+console.log(a === "6")
+console.log(a != 6) // Desigualdad por valor
+console.log(a !== "6") // Desigualdad por identidad (por tipo y valor) o desigualdad estricta
+console.log(0 == false)
+console.log(1 == false)
+console.log(2 == false)
+console.log(0 == "")
+console.log(0 == " ")
+console.log(0 == '')
+console.log(0 == "Hola")
+console.log(0 === "")
+console.log(undefined == null)
+console.log(undefined === null)
+
+/*
+Truthy values (valores verdaderos)
+
+- Todos los numeros positivos y negativos menos el cero
+- Todas las cadenas de texto menos las vacías
+- El boolean true
+*/
+
+/*
+Falsy values (valores falsos)
+
+- 0
+-  0n
+- null
+- undefined
+- NaN (Not a Number)
+- El boolean false
+- Cadenas de texto vacías
+*/
+
+// Operadores lógicos
+
+// and (&&)
+console.log(5 > 10 && 15 > 20)
+console.log(5 < 10 && 15 < 20)
+console.log(5 < 10 && 15 > 20)
+console.log(5 > 10 && 15 > 20 && 30 > 40)
+
+// or (||)
+console.log(5 > 10 || 15 > 20)
+console.log(5 < 10 || 15 < 20)
+console.log(5 < 10 || 15 > 20)
+console.log(5 > 10 || 15 > 20 || 30 > 40)
+
+console.log(5 > 10 && 15 > 20 || 30 < 40)
+
+// not (!)
+console.log(!true)
+console.log(!false)
+console.log(!(5 > 10 && 15 > 20))
+console.log(!(5 > 10 || 15 > 20))
+
+// Operadores ternarios
+
+const isRaining = false
+isRaining ? console.log("Está lloviendo") : console.log("No está lloviendo")
\ No newline at end of file
diff --git a/Basic/05-operators-exercises.js b/Basic/05-operators-exercises.js
new file mode 100644
index 00000000..9f496696
--- /dev/null
+++ b/Basic/05-operators-exercises.js
@@ -0,0 +1,68 @@
+/*
+Clase 2 en vídeo | 17/07/2024
+Tipos de datos, operadores y strings
+https://www.twitch.tv/videos/2200149072?t=00h08m02s
+*/
+
+// 1. Crea una variable para cada operación aritmética
+let a = 5
+let b = 10
+
+let suma = a + b
+let resta = a - b
+let multiplicacion = a * b
+let division = a / b
+let modulo = a % b
+let exponente = a ** b
+
+let incremento = a++
+let decremento = b--
+
+// 2. Crea una variable para cada tipo de operación de asign., que haga uso de las vars. usadas para las op. aritméticas
+
+let asignada = suma // asignación
+let sumAsignada = asignada += resta // suma y asignación
+let restAsignada = asignada -= multiplicacion // resta y asignación
+let multAsignada = asignada *= division // multiplicación y asignación
+let divAsignada = asignada /= modulo // división y asignación
+let modAsignada = asignada %= exponente // modulo y asignación
+let expAsignada = asignada **= exponente // exponente y asignación
+
+// 3. Imprime 5 comparaciones verdades con diferentes operadores de comparación
+console.log(a < b)
+console.log(a > 3)
+console.log(b >= a)
+console.log(b == "9")
+console.log(a === 6)
+
+// 4. Imprime 5 comparaciones falsas con diferentes operadores de comparación
+
+console.log(a > b)
+console.log(a !== 6)
+console.log(a < 3)
+console.log(b <= a)
+console.log(b != "9")
+
+// 5. Utiliza el operador lógico and
+
+console.log(5 < 10 && b < 20)
+
+// 6. Utiliza el operador lógico or
+
+console.log(5 == 10 || b < 20)
+
+// 7. Combina ambos operadores lógicos
+
+console.log(5 == 10 || b < 20 && b > 1)
+
+// 8. Añade alguna negación
+
+console.log(5 == 10 || !(b > 20 && b != 1))
+
+// 9. Utiliza el operador ternario
+
+console.log(b == 9 ? 'verdadero' : 'falso')
+
+// 10. Combina operadores aritméticos, de comparáción y lógicos
+
+console.log(5 == (b - 4) || b < 20 && b <= 3**2 ? 'verdadero' : 'falso')
\ No newline at end of file
diff --git a/Basic/06-strings.js b/Basic/06-strings.js
new file mode 100644
index 00000000..4e79331c
--- /dev/null
+++ b/Basic/06-strings.js
@@ -0,0 +1,49 @@
+/*
+Clase 2 en vídeo | 17/07/2024
+Tipos de datos, operadores y strings
+https://www.youtube.com/live/euVbF1eatEY?si=nHS3QznAlA_C39NK&t=808
+*/
+
+// Strings (cadenas de texto)
+
+// Concatenación
+
+let myName = "Brais"
+let greeting = "Hola, " + myName + "!"
+console.log(greeting)
+console.log(typeof greeting)
+
+// Longitud
+
+console.log(greeting.length)
+
+// Acceso a caracteres
+
+console.log(greeting[0])
+console.log(greeting[11])
+
+// Métodos comunes
+
+console.log(greeting.toUpperCase()) // Mayúsculas
+console.log(greeting.toLowerCase()) // Minúsculas
+console.log(greeting.indexOf("Hola")) // Índice
+console.log(greeting.indexOf("Brais"))
+console.log(greeting.indexOf("MoureDev"))
+console.log(greeting.includes("Hola")) // Incluye
+console.log(greeting.includes("Brais"))
+console.log(greeting.includes("MoureDev"))
+console.log(greeting.slice(0, 10)) // Sección
+console.log(greeting.replace("Brais", "MoureDev")) // Reemplazo
+
+// Template literals (plantillas literales)
+
+// Strings en varias líneas
+let message = `Hola, este
+es mi
+curso de
+JavaScript`
+console.log(message)
+
+// Interpolación de valores
+let email = "braismoure@mouredev.com"
+console.log(`Hola, ${myName}! Tu email es ${email}.`)
\ No newline at end of file
diff --git a/Basic/07-strings-exercises.js b/Basic/07-strings-exercises.js
new file mode 100644
index 00000000..2dcdb54d
--- /dev/null
+++ b/Basic/07-strings-exercises.js
@@ -0,0 +1,41 @@
+/*
+Clase 2 en vídeo | 17/07/2024
+Tipos de datos, operadores y strings
+https://www.twitch.tv/videos/2200149072?t=00h08m02s
+*/
+
+// 1. Concatena dos cadenas de texto
+console.log("Hay que concatenar estas " + "dos cadenas de texto")
+
+// 2. Muestra la longitud de una cadena de texto
+let cadena = "Califragilístico espialidoso"
+console.log(cadena.length);
+
+// 3. Muestra el primer y último carácter de un string
+console.log("Primero: -" + cadena.charAt(0) + "- Último: -" + cadena.charAt(cadena.length -1) + "-")
+
+// 4. Convierte a mayúsculas y minúsculas un string
+let may = cadena.toUpperCase
+let min = cadena.toLowerCase
+
+// 5. Crea una cadena de texto en varias líneas
+let cadena2 = `Para poder crear 
+una cadena de 
+texto en varias líneas, usamos 
+las template literals con backtick`
+
+// 6. Interpola el valor de una variable en un string
+let miFisico = "simplemente impresionante"
+console.log(`Soy un tipo ${miFisico}`)
+
+// 7. Reemplaza todos los espacios en blanco de un string por guiones
+console.log(cadena2.replaceAll(" ", "-"))
+
+// 8. Comprueba si una cadena de texto contiene una palabra concreta
+console.log(cadena2.includes("Poder"))
+
+// 9. Comprueba si dos strings son iguales
+console.log(cadena === cadena2)
+
+// 10. Comprueba si dos strings tienen la misma longitud
+console.log(cadena.length === cadena2.length)
\ No newline at end of file
diff --git a/Basic/08-conditionals.js b/Basic/08-conditionals.js
new file mode 100644
index 00000000..01c8704d
--- /dev/null
+++ b/Basic/08-conditionals.js
@@ -0,0 +1,71 @@
+/*
+Clase 3 en vídeo | 24/07/2024
+Condicionales, arrays y sets
+https://www.twitch.tv/videos/2206228701?t=00h16m02s
+*/
+
+// if, else if, else
+
+// if (si)
+
+let age = 37
+
+if (age == 37) {
+    console.log("La edad es 37")
+}
+
+// else (si no)
+
+if (age == 37) {
+    console.log("La edad es 37")
+} else {
+    console.log("La edad no es 37")
+}
+
+// else if (si no, si)
+
+if (age == 37) {
+    console.log("La edad es 37")
+} else if (age < 18) {
+    console.log("Es menor de edad")
+} else {
+    console.log("La edad no es 37 ni es menor de edad")
+}
+
+// Operador ternario
+
+const message = age == 37 ? "La edad es 37" : "La edad no es 37"
+console.log(message)
+
+// switch
+
+let day = 3
+let dayName
+
+switch (day) {
+    case 0:
+        dayName = "Lunes"
+        break
+    case 1:
+        dayName = "Martes"
+        break
+    case 2:
+        dayName = "Miércoles"
+        break
+    case 3:
+        dayName = "Jueves"
+        break
+    case 4:
+        dayName = "Viernes"
+        break
+    case 5:
+        dayName = "Sábado"
+        break
+    case 6:
+        dayName = "Domingo"
+        break
+    default:
+        dayName = "Número de día incorrecto"
+}
+
+console.log(dayName)
\ No newline at end of file
diff --git a/Basic/09-conditionals-execises.js b/Basic/09-conditionals-execises.js
new file mode 100644
index 00000000..c1d2f538
--- /dev/null
+++ b/Basic/09-conditionals-execises.js
@@ -0,0 +1,158 @@
+/*
+Clase 3 en vídeo | 24/07/2024
+Condicionales, arrays y sets
+https://www.twitch.tv/videos/2206228701?t=00h16m02s
+*/
+
+// if/else/else if/ternaria
+
+// 1. Imprime por consola tu nombre si una variable toma su valor
+
+let name = "Desi"
+if (name === "Desi") {
+  console.log(`Sen dúbida, estamos ante ${name}.`)
+}
+
+// 2. Imprime por consola un mensaje si el usuario y contraseña concide con unos establecidos
+
+let user = "Desi"
+let pass = "1234"
+if (user === "Desi" && pass === "1234") {
+  console.log(`Bienvenido, ${user}, la contraseña es correcta.`)
+}
+// 3. Verifica si un número es positivo, negativo o cero e imprime un mensaje
+
+let num = 7
+if (num === 0) {
+  console.log("Es un cero")
+} else if (num > 0) {
+  console.log("Es positivo")
+} else {
+  console.log("Es negativo")
+}
+
+// 4. Verifica si una persona puede votar o no (mayor o igual a 18) e indica cuántos años le faltan
+
+let edadLegal = 18
+let edad = 26
+
+if (edad >= edadLegal) {
+  console.log("Muy bien, ya puedes  votarrrr ")
+} else {
+    let diff = edadLegal - edad
+    console.log("Nada, vuélvase a casa, no puede votar hasta dentro de " + diff + "años");
+}
+
+// 5. Usa el operador ternario para asignar el valor "adulto" o "menor" a una variable
+//    dependiendo de la edad
+
+let condicion = edad >= 18 ? "adulto" : "menor"
+// console.log(condicion);
+
+// 6. Muestra en que estación del año nos encontramos dependiendo del valor de una variable "mes"
+let mes = 2
+let estacion = "invierno"
+if (mes > 3 && mes < 7) {
+  estacion = "primavera"
+} else if (mes > 6 && mes < 10) {
+  estacion = "verano"
+} else if (mes > 9 && mes < 13) {
+  estacion = "otoño"
+}
+if ( mes < 1 || mes > 12) {
+  console.log("Mes tiene que tener un valor entre 1 (enero) y 12 (diciembre)")
+} else {
+  console.log("Ahora mismo estamos en " + estacion)
+}
+
+// 7. Muestra el número de días que tiene un mes dependiendo de la variable del ejercicio anterior
+
+let dias = 31
+if (mes == 4 || mes == 6 || mes == 9 || mes == 11) {
+  dias = 30
+} else if (mes == 2) {
+  dias = "28 o 29"
+}
+
+if ( mes < 1 || mes > 12) {
+  console.log("Mes tiene que tener un valor entre 1 (enero) y 12 (diciembre)")
+} else {
+  console.log(`El mes número ${mes} tiene ${dias} días`)
+}
+
+// switch
+
+// 8. Usa un switch para imprimir un mensaje de saludo diferente dependiendo del idioma
+
+let idioma = "gl"
+switch (idioma) {
+  case "es":
+    console.log("Bienvenid@")
+    break
+  case "it":
+    console.log("Benvenut@")
+    break
+  case "gl":
+    console.log("Benvid@")
+    break
+  case "fr":
+    console.log("Bienvenue")
+    break
+  default:
+    console.log("Welcome")
+}
+
+// 9. Usa un switch para hacer de nuevo el ejercicio 6
+
+switch (mes) {
+  case 1:
+  case 2:
+  case 3:
+    console.log("En Switch estamos en invierno")
+    break
+  case 4:
+  case 5:
+  case 6:
+    console.log("En Switch estamos en primavera")
+    break
+  case 7:
+  case 8:
+  case 9:
+    console.log("En Switch estamos en verano")
+    break
+  case 10:
+  case 11:
+  case 12:
+    console.log("En Switch estamos en otoño")
+    break
+  default:
+    console.log("En Switch, mes tiene que tener un valor entre 1 (enero) y 12 (diciembre)")
+    break
+}
+
+
+// 10. Usa un switch para hacer de nuevo el ejercicio 7
+
+switch (mes) {
+  case 1:
+  case 3:
+  case 5:
+  case 7:
+  case 8:
+  case 10:
+  case 12:
+    console.log(`En Switch, el mes ${mes} tiene 31 días`)
+    break
+  case 4:
+  case 6:
+  case 9:
+  case 11:
+    console.log(`En Switch, el mes ${mes} tiene 30 días`)
+    break
+  case 2:
+    console.log(`En Switch, el mes ${mes} tiene 28 ó 29 días`)
+    break
+  default:
+    console.log("En Switch, mes tiene que tener un valor entre 1 (enero) y 12 (diciembre)")
+    break
+}
\ No newline at end of file
diff --git a/Basic/10-array.js b/Basic/10-array.js
new file mode 100644
index 00000000..6f152e77
--- /dev/null
+++ b/Basic/10-array.js
@@ -0,0 +1,105 @@
+/*
+Clase 3 en vídeo | 24/07/2024
+Condicionales, arrays y sets
+https://www.youtube.com/live/XCNjoIoO3Ws?si=3XCjdZ9r41JID-by&t=978
+*/
+
+// Array
+
+// Declaración
+
+let myArray = []
+let myArray2 = new Array()
+
+console.log(myArray)
+console.log(myArray2)
+
+// Inicialización
+
+myArray = [3]
+myArray2 = new Array(3) // Reserva 3 espacios
+
+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 = ["Brais", "Moure", "mouredev", 37, true]
+myArray2 = new Array("Brais", "Moure", "mouredev", 37, true)
+
+console.log(myArray)
+console.log(myArray2)
+
+myArray2 = new Array(3)
+myArray2[2] = "Brais"
+// myArray2[0] = "Moure"
+myArray2[1] = "mouredev"
+myArray2[4] = "mouredev"
+
+console.log(myArray2)
+
+myArray = []
+myArray[2] = "Brais"
+// myArray[0] = "Moure"
+myArray[1] = "mouredev"
+
+console.log(myArray)
+
+// Métodos comunes
+
+myArray = []
+
+// push y pop
+
+myArray.push("Brais")
+myArray.push("Moure")
+myArray.push("mouredev")
+myArray.push(37)
+
+console.log(myArray)
+
+console.log(myArray.pop()) // Elimina el último y lo devuelve
+myArray.pop()
+
+console.log(myArray)
+
+// shift y unshift
+
+console.log(myArray.shift())
+console.log(myArray)
+
+myArray.unshift("Brais", "mouredev")
+console.log(myArray)
+
+// length
+
+console.log(myArray.length)
+
+// clear
+
+myArray = []
+myArray.length = 0 // alternativa
+console.log(myArray)
+
+// slice
+
+myArray = ["Brais", "Moure", "mouredev", 37, true]
+
+let myNewArray = myArray.slice(1, 3)
+
+console.log(myArray)
+console.log(myNewArray)
+
+// splice
+
+myArray.splice(1, 3)
+console.log(myArray)
+
+myArray = ["Brais", "Moure", "mouredev", 37, true]
+
+myArray.splice(1, 2, "Nueva entrada")
+console.log(myArray)
\ No newline at end of file
diff --git a/Basic/11-set.js b/Basic/11-set.js
new file mode 100644
index 00000000..84bddd57
--- /dev/null
+++ b/Basic/11-set.js
@@ -0,0 +1,62 @@
+/*
+Clase 3 en vídeo | 24/07/2024
+Condicionales, arrays y sets
+https://www.youtube.com/live/XCNjoIoO3Ws?si=3XCjdZ9r41JID-by&t=978
+*/
+
+// Set
+
+// Declaración
+
+let mySet = new Set()
+
+console.log(mySet)
+
+// Inicialización
+
+mySet = new Set(["Brais", "Moure", "mouredev", 37, true, "braismoure@mouredev.com"])
+
+console.log(mySet)
+
+// Métodos comunes
+
+// add y delete
+
+mySet.add("https://moure.dev")
+
+console.log(mySet)
+
+mySet.delete("https://moure.dev")
+
+console.log(mySet)
+
+console.log(mySet.delete("Brais"))
+console.log(mySet.delete(4))
+
+console.log(mySet)
+
+// has
+
+console.log(mySet.has("Moure"))
+console.log(mySet.has("Brais"))
+
+// size
+
+console.log(mySet.size)
+
+// Convertir un set a array
+let myArray = Array.from(mySet)
+console.log(myArray)
+
+// Convertir un array a set
+
+mySet = new Set(myArray)
+console.log(mySet)
+
+// No admite duplicados
+
+mySet.add("braismoure@mouredev.com")
+mySet.add("braismoure@mouredev.com")
+mySet.add("braismoure@mouredev.com")
+mySet.add("BraisMoure@mouredev.com")
+console.log(mySet)
\ No newline at end of file
diff --git a/Basic/12-map.js b/Basic/12-map.js
new file mode 100644
index 00000000..a2b6cf2a
--- /dev/null
+++ b/Basic/12-map.js
@@ -0,0 +1,64 @@
+/*
+Clase 4 en vídeo | 31/07/2024
+Mapas, bucles y funciones
+https://www.youtube.com/live/xg1GeHKiNzU?si=oiWHK8bDTZ1c98hF&t=885
+*/
+
+// Map
+
+// Declaración
+
+let myMap = new Map()
+
+console.log(myMap)
+
+// Inicialiación
+
+myMap = new Map([
+    ["name", "Brais"],
+    ["email", "braismoure@mouredev.com"],
+    ["age", 37]
+])
+
+console.log(myMap)
+
+// Métodos y propiedades
+
+// set
+
+myMap.set("alias", "mouredev")
+myMap.set("name", "Brais Moure")
+
+console.log(myMap)
+
+// get
+
+console.log(myMap.get("name"))
+console.log(myMap.get("surname"))
+
+// has
+
+console.log(myMap.has("surname"))
+console.log(myMap.has("age"))
+
+// delete
+
+myMap.delete("email")
+
+console.log(myMap)
+
+// keys, values y entries
+
+console.log(myMap.keys())
+console.log(myMap.values())
+console.log(myMap.entries())
+
+// size
+
+console.log(myMap.size)
+
+// clear
+
+myMap.clear()
+
+console.log(myMap)
\ No newline at end of file
diff --git a/Basic/13-structures-exercises.js b/Basic/13-structures-exercises.js
new file mode 100644
index 00000000..e02a2251
--- /dev/null
+++ b/Basic/13-structures-exercises.js
@@ -0,0 +1,86 @@
+/*
+Clase 4 en vídeo | 31/07/2024
+Mapas, bucles y funciones
+https://www.youtube.com/live/xg1GeHKiNzU?si=oiWHK8bDTZ1c98hF&t=885
+*/
+
+// 1. Crea un array que almacene cinco animales
+
+animales = ["vaca", "oveja", "caballo", "gallina", "conejo"]
+
+// 2. Añade dos más. Uno al principio y otro al final
+
+animales.unshift("mosca")
+// animales.splice(0,0, "mosca")
+
+animales.push("periquito")
+
+// 3. Elimina el que se encuentra en tercera posición
+
+console.log(animales.splice(2,1))
+
+console.log("Array de animales: " + animales)
+
+// 4. Crea un set que almacene cinco libros
+
+libros = new Set(["El quijote", "La Biblia", "Romancero Gitano", "El Jarama", "La Colmena"])
+
+// 5. Añade dos más. Uno de ellos repetido
+
+libros.add("El Perfume")
+libros.add("Yerma")
+libros.add("El Perfume")
+
+// 6. Elimina uno concreto a tu elección
+
+
+console.log("Set de libros: " + libros)
+console.log(libros)
+
+libros.delete("La Biblia")
+
+console.log("Set de libros: " + libros)
+console.log(libros)
+
+// 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))
+} else {
+  console.log("No existe la clave 5")
+}
+
+console.log(meses)
+
+// 9. Añade al mapa una clave con un array que almacene los meses de verano
+
+meses.set([6, 7, 8], "Verano")
+console.log(meses)
+
+// 10. Crea un Array, transfórmalo a un Set y almacénalo en un Map
+
+const celta = ["Aspas", "Mostovoi", "Karpin", "Mazinho"]
+console.log(celta)
+const celtaSet = new Set (celta)
+console.log(celtaSet)
+const celtaMap = new Map()
+celtaMap.set("jugadores", celtaSet)
+console.log(celtaMap)
+
diff --git a/Basic/14-loops.js b/Basic/14-loops.js
new file mode 100644
index 00000000..7d3828c0
--- /dev/null
+++ b/Basic/14-loops.js
@@ -0,0 +1,80 @@
+/*
+Clase 4 en vídeo | 31/07/2024
+Mapas, bucles y funciones
+https://www.youtube.com/live/xg1GeHKiNzU?si=oiWHK8bDTZ1c98hF&t=885
+*/
+
+// Loops o bucles
+
+// for
+
+for (let i = 0; i < 5; i++) {
+  console.log(`Hola ${i}`)
+}
+
+const numbers = [1, 2, 3, 4, 5, 6, 7, 8]
+
+for (let i = 0; i < numbers.length; i++) {
+  console.log(`Elemento: ${numbers[i]}`)
+}
+
+// while
+
+let i = 0
+while (i < 5) {
+  console.log(`Hola ${i}`)
+  i++
+}
+
+// Bucle infinito
+// while(true) {
+// }
+
+// do while
+
+i = 6
+do {
+  console.log(`Hola ${i}`)
+  i++
+} while (i < 5)
+
+// for of
+
+myArray = [1, 2, 3, 4]
+
+mySet = new Set(["Brais", "Moure", "mouredev", 37, true, "braismoure@mouredev.com"])
+
+myMap = new Map([
+  ["name", "Brais"],
+  ["email", "braismoure@mouredev.com"],
+  ["age", 37]
+])
+
+myString = "¡Hola, JavaScript!"
+
+for (let value of myArray) {
+  console.log(value)
+}
+
+for (let value of mySet) {
+  console.log(value)
+}
+
+for (let value of myMap) {
+  console.log(value)
+}
+
+for (let value of myString) {
+  console.log(value)
+}
+
+// break y continue
+
+for (let i = 0; i < 10; i++) {
+  if (i == 5) {
+      continue
+  } else if (i == 7) {
+      break
+  }
+  console.log(`Hola ${i}`)
+}
\ No newline at end of file
diff --git a/Basic/15-loops-exercises.js b/Basic/15-loops-exercises.js
new file mode 100644
index 00000000..ed47cb72
--- /dev/null
+++ b/Basic/15-loops-exercises.js
@@ -0,0 +1,121 @@
+/*
+Clase 4 en vídeo | 31/07/2024
+Mapas, bucles y funciones
+https://www.youtube.com/live/xg1GeHKiNzU?si=oiWHK8bDTZ1c98hF&t=885
+*/
+
+// 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 index = 1; index < 21; index++) {
+  console.log('Num. ' + index)
+}
+
+// 2. Crea un bucle que sume todos los números del 1 al 100 y muestre el resultado
+
+let num = 1
+let sum = 0
+do {
+  sum += num
+  ++num
+} while (num < 101)
+console.log(sum)
+
+
+// 3. Crea un bucle que imprima todos los números pares entre 1 y 50
+
+let num2 = 1
+while (num2 < 51) {
+  if (num2%2 === 0) {
+    console.log('Par: ' + num2)
+  }
+  num2++
+}
+
+// 4. Dado un array de nombres, usa un bucle para imprimir cada nombre en la consola
+
+const nombres = ['Ana', 'Bea', 'Chus', 'Desi', 'Eva']
+for (const element of nombres) {
+  console.log(element);
+}
+
+// 5. Escribe un bucle que cuente el número de vocales en una cadena de texto
+
+function cuentaVocales (cadena) {
+  // const caracteres = cadena.length
+  const minusculas = cadena.toLowerCase()
+  let numVocales = 0
+  let vocales = ['a', 'e', 'i', 'o', 'u']
+  for (let i = 0; i < cadena.length; i++) {
+    if (vocales.includes( minusculas[i] )) {
+      numVocales ++
+    }
+  }
+  return numVocales
+}
+
+const cadena = "plkgy tr7rt 43"
+let numVocales = cuentaVocales(cadena)
+console.log('Hay ' + numVocales + ' vocales')
+
+// 6. Dado un array de números, usa un bucle para multiplicar todos los números y mostrar el producto
+
+const numeros = [10, 9, 4]
+if (numeros.length < 2) {
+  console.log('Se necesitan al menos dos números para hallar el producto total del array');
+} else {
+  let producto = numeros[0] * numeros[1]
+  let posicion = 2
+  while (posicion < numeros.length) {
+    producto *= numeros[posicion]
+    posicion++
+  }
+  console.log('El producto de multiplicar todos los números del array es ' + producto)
+}
+
+// La solución óptima sería utilizando el método reduce
+const numerosReduce = [2, 3, 4, 5]
+const producto = numerosReduce.reduce((acumulador, numero) => acumulador * numero, 1)
+console.log("El producto es:", producto)
+
+
+// 7. Escribe un bucle que imprima la tabla de multiplicar del 5
+
+let multiplicador = 1
+do {
+  console.log('5 x ' + multiplicador + ' = ' + (multiplicador * 5))
+  multiplicador++
+} while (multiplicador < 11)
+
+// 8. Usa un bucle para invertir una cadena de texto
+
+const texto = "a torre da derrota"
+let posicionOriginal = (texto.length - 1)
+let inversion = ""
+while (posicionOriginal >= 0) {
+  inversion += texto[posicionOriginal]
+  posicionOriginal--
+}
+console.log(`Texto invertido: ${inversion}`);
+
+// 9. Usa un bucle para generar los primeros 10 números de la secuencia de Fibonacci
+
+let serie = [0, 1]
+do {
+  let nuevoNum = serie[serie.length - 1] + serie[serie.length - 2]
+  serie.push(nuevoNum)
+} while (serie.length < 10)
+console.log(serie);
+
+
+// 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 arrayNumeros = [5, 10, 1, 20, 25, 3, 35, -12, 45, 9]
+let arrayMayoresDiez = []
+arrayNumeros.forEach(element => {
+  if (element > 10) {
+    arrayMayoresDiez.push(element)
+  }
+})
+console.log(arrayMayoresDiez);
diff --git a/Basic/16-functions.js b/Basic/16-functions.js
new file mode 100644
index 00000000..89754335
--- /dev/null
+++ b/Basic/16-functions.js
@@ -0,0 +1,118 @@
+/*
+Clase 4 en vídeo | 31/07/2024
+Mapas, bucles y funciones
+https://www.twitch.tv/videos/2212289583?t=00h17m45s
+*/
+
+// Funciones
+
+// Simple
+
+function myFunc() {
+  console.log("¡Hola, función!")
+}
+
+for (let i = 0; i < 5; i++) {
+  myFunc()
+}
+
+// Con parámetros
+
+function myFuncWithParams(name) {
+  console.log(`¡Hola, ${name}!`)
+}
+
+myFuncWithParams("Brais")
+myFuncWithParams("MoureDev")
+
+// Funciones anónimas
+
+const myFunc2 = function (name) {
+  console.log(`¡Hola, ${name}!`)
+}
+
+myFunc2("Brais Moure")
+
+// Arrow functions
+
+const myFunc3 = (name) => {
+  console.log(`¡Hola, ${name}!`)
+}
+
+const myFunc4 = (name) => console.log(`¡Hola, ${name}!`)
+
+myFunc3("Brais Moure")
+myFunc4("Brais Moure")
+
+// Parámetros
+
+function sum(a, b) {
+  console.log(a + b)
+}
+
+sum(5, 10)
+sum(5)
+sum()
+
+function defaultSum(a = 0, b = 0) {
+  console.log(a + b)
+}
+
+// Por defecto
+
+defaultSum()
+defaultSum(5)
+defaultSum(5, 10)
+defaultSum(b = 5)
+
+// Retorno de valores
+
+function mult(a, b) {
+  return a * b
+}
+
+let result = mult(5, 10)
+console.log(result)
+
+// Funciones anidadas
+
+function extern() {
+  console.log("Función externa")
+  function intern() {
+      console.log("Función interna")
+  }
+  intern()
+}
+
+extern()
+// intern() Error: fuera del scope
+
+// Funciones de orden superior
+
+function applyFunc(func, param) {
+  func(param)
+}
+
+applyFunc(myFunc4, "función de orden superior")
+
+// forEach
+
+myArray = [1, 2, 3, 4]
+
+mySet = new Set(["Brais", "Moure", "mouredev", 37, true, "braismoure@mouredev.com"])
+
+myMap = new Map([
+  ["name", "Brais"],
+  ["email", "braismoure@mouredev.com"],
+  ["age", 37]
+])
+
+myArray.forEach(function (value) {
+  console.log(value)
+})
+
+myArray.forEach((value) => console.log(value))
+
+mySet.forEach((value) => console.log(value))
+ 
+myMap.forEach((value) => console.log(value))
\ No newline at end of file
diff --git a/Basic/17-functions-exercises.js b/Basic/17-functions-exercises.js
new file mode 100644
index 00000000..3e0cc200
--- /dev/null
+++ b/Basic/17-functions-exercises.js
@@ -0,0 +1,149 @@
+/*
+Clase 4 en vídeo | 31/07/2024
+Mapas, bucles y funciones
+https://www.youtube.com/live/xg1GeHKiNzU?si=oiWHK8bDTZ1c98hF&t=885
+*/
+
+// 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 sumar(num1, num2) {
+  return num1 + num2
+}
+console.log('1: ' + sumar(49,5))
+
+// 2. Crea una función que reciba un array de números y devuelva el mayor de ellos
+
+const escogerMayor = function (numeros) {
+  let mayor = numeros[0]
+  for (let i = 1; i < numeros.length; i++) {
+    const element = numeros[i]
+    if (element > mayor) {
+      mayor = element
+    }
+  }
+  return mayor
+}
+console.log('2: ' + escogerMayor([2, 5, 7, 21, 49, 9]))
+
+// 3. Crea una función que reciba un string y devuelva el número de vocales que contiene
+
+function contarVocales(cadena) {
+  const vocales = ['a', 'e', 'i', 'o', 'u']
+  const minusCadena = cadena.toLowerCase()
+  let cuenta = 0
+  for (const element of minusCadena) {
+    if (vocales.includes(element)) {
+      cuenta++
+    }
+  }
+  return cuenta
+}
+const cadena = 'Cadena con muuUUchas vocalEs'
+console.log('3: ' + contarVocales(cadena) + ' vocales')
+
+// 4. Crea una función que reciba un array de strings y devuelva un nuevo array con las strings en mayúsculas
+
+const cadenas = ['cosa', 'mucho', 'Ana', 'RTVG', 'fIn']
+
+/* Tal vez más elegante, pero no devuelve un nuevo array, transforma el mismo
+* const enMayusculas = cadenas.map(cadena => cadena.toLocaleUpperCase())
+* console.log('4: ' + enMayusculas)
+*/
+const enMayusculas = function (array) {
+  newArray = []
+  for (const element of array) {
+    newArray.push(element.toUpperCase())
+  }
+  return newArray
+}
+
+console.log('4: ' + enMayusculas(cadenas));
+
+// 5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario
+
+function comprobarNumero(num) {
+  function esPrimo(numero) {
+    // Casos base
+    if (numero <= 1) return false;
+    if (numero <= 3) return true;
+    if (numero % 2 === 0 || numero % 3 === 0) return false;
+
+    // Comprobamos divisibilidad por 6k ± 1 (optimización adicional)
+    let i = 5;
+    while (i * i <= numero) {
+      if (numero % i === 0 || numero % (i + 2) === 0) return false;
+      i += 6;
+    }
+
+    return true;
+  }
+
+  return esPrimo(num)? ' es primo' : ' no es primo'
+}
+const numToCheck = 79
+console.log('5: ' + numToCheck + comprobarNumero(numToCheck));
+
+// 6. Crea una función que reciba dos arrays y devuelva un nuevo array que contenga los elementos comunes entre ambos
+
+function sonIguales(array1, array2) {
+  const elementosComunes = new Array()
+  array1.forEach(element => {
+    if (array2.includes(element)) {
+      elementosComunes.push(element)
+    }
+  })
+  return elementosComunes
+}
+const array1 = [2, 5, 67, 8, 2.4, -2]
+const array2 = new Array(6, -1, 4, -2, 0, 2, 2.9)
+console.log('6: ' + sonIguales(array1, array2))
+
+// 7. Crea una función que reciba un array de números y devuelva la suma de todos los números pares
+
+const sumarPares = function (array) {
+  let suma = 0
+  for (const element of array) {
+    if (element % 2 === 0) {
+      suma += element
+    }
+  }
+  return suma
+}
+
+console.log('7: ' + sumarPares(array2));
+
+// 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 cuadrados (num) {
+  return num * num
+}
+
+const nums = [4, 6, 87, 3]
+
+console.log('8: ' + nums.map(cuadrados));
+
+// 9. Crea una función que reciba una cadena de texto y devuelva la misma cadena con las palabras en orden inverso
+
+const ltr = "Soy una frase cualquiera"
+function reverso(cadena) {
+  const array = cadena.split(' ')
+  array.reverse()
+  const rtl = array.join(' ')
+  return rtl
+}
+
+console.log('9: ' + reverso(ltr))
+
+// 10. Crea una función que calcule el factorial de un número dado
+
+function factorial(num) {
+  let resultado = 1;
+  for (let i = 2; i <= num; i++) {
+    resultado *= i;
+  }
+  return resultado;
+}
+
+console.log('10: ' + factorial(6));
diff --git a/Basic/18-objects.js b/Basic/18-objects.js
new file mode 100644
index 00000000..71d9675c
--- /dev/null
+++ b/Basic/18-objects.js
@@ -0,0 +1,120 @@
+/*
+Clase 5 en vídeo | 07/08/2024
+Objetos, desestructuración, propagación y clases
+https://www.twitch.tv/videos/2218300512?t=00h17m10s
+*/
+
+// Objetos
+
+// Sintaxis
+
+let person = {
+  name: "Brais",
+  age: 37,
+  alias: "MoureDev"
+}
+
+// Acceso a propiedades
+
+// Notación punto
+console.log(person.name)
+
+// Notación de corchetes
+console.log(person["name"])
+
+// Modificación de propiedades
+
+person.name = "Brais Moure"
+console.log(person.name)
+
+console.log(typeof person.age)
+person.age = "37"
+console.log(person.age)
+console.log(typeof person.age)
+
+// Eliminación de propiedades
+
+delete person.age
+
+console.log(person)
+
+// Nueva propiedad
+
+person.email = "braismoure@mouredev.com"
+person["age"] = 37
+
+console.log(person)
+
+// Métodos (funciones)
+
+let person2 = {
+  name: "Brais",
+  age: 37,
+  alias: "MoureDev",
+  walk: function () {
+      console.log("La persona camina.")
+  }
+}
+person2.walk()
+
+// Anidación de objetos
+
+let person3 = {
+  name: "Brais",
+  age: 37,
+  alias: "MoureDev",
+  walk: function () {
+      console.log("La persona camina.")
+  },
+  job: {
+      name: "Programador",
+      exp: 15,
+      work: function () {
+          console.log(`La persona de ${this.age} años de experiencia trabaja.`)
+      }
+  }
+}
+
+console.log(person3)
+
+console.log(person3.name)
+console.log(person3.job)
+console.log(person3.job.name)
+person3.job.work()
+
+// Igualdad de objetos
+
+let person4 = {
+  name: "Brais Moure",
+  alias: "MoureDev",
+  email: "braismoure@mouredev.com",
+  age: 37
+}
+
+console.log(person)
+console.log(person4)
+
+console.log(person == person4)
+console.log(person === person4)
+
+console.log(person.name == person4.name)
+
+// Iteración
+
+for (let key in person4) {
+  console.log(key + ": " + person4[key])
+}
+
+// Funciones como objetos
+
+function Person(name, age) { // Debería ser una clase
+  this.name = name
+  this.age = age
+}
+
+let person5 = new Person("Brais", 37)
+console.log(person5)
+console.log(person5.name)
+
+console.log(typeof person5)
+console.log(typeof person4)
\ No newline at end of file
diff --git a/Basic/19-objects-exercises.js b/Basic/19-objects-exercises.js
new file mode 100644
index 00000000..5aa9eff2
--- /dev/null
+++ b/Basic/19-objects-exercises.js
@@ -0,0 +1,74 @@
+/*
+Clase 5 en vídeo | 07/08/2024
+Objetos, desestructuración, propagación y clases
+https://www.youtube.com/live/SBXEpAx_y_Q?si=Sbqqa2-_eGwsUkH-&t=958
+*/
+
+// 1. Crea un objeto con 3 propiedades
+
+let fulanoGuapo = {
+  nombre: 'Desi',
+  apel1: 'Martínez',
+  apel2: 'Silva',
+}
+
+// 2. Accede y muestra su valor
+
+console.log(fulanoGuapo.nombre)
+console.log(fulanoGuapo.apel1)
+console.log(fulanoGuapo.apel2)
+
+// 3. Agrega una nueva propiedad
+
+fulanoGuapo.edad = 52
+console.log(fulanoGuapo)
+
+// 4. Elimina una de las 3 primeras propiedades
+
+delete fulanoGuapo.apel2
+console.log(fulanoGuapo)
+
+// 5. Agrega una función e invócala
+
+fulanoGuapo.saludo = function () {
+  console.log('Hey, como estáis, nenas??')
+}
+
+fulanoGuapo.saludo()
+
+// 6. Itera las propiedades del objeto
+
+for (const key in fulanoGuapo) {
+  console.log(key)
+}
+
+// 7. Crea un objeto anidado
+
+fulanoGuapo.cosas = {
+  coche: 'Mercedes',
+  moto: 'Honda',
+}
+
+// 8. Accede y muestra el valor de las propiedades anidadas
+
+for (const key in fulanoGuapo.cosas) {
+console.log(key)
+}
+// 9. Comprueba si los dos objetos creados son iguales
+const otroFulano = {
+  nombre: 'vulgar',
+  aspecto: 'miserable',
+  atractivo: 0,
+}
+
+const otroFulanoMas = {
+  nombre: 'vulgar',
+  aspecto: 'miserable',
+  atractivo: 0
+}
+
+console.log(otroFulano == otroFulanoMas)
+
+// 10. Comprueba si dos propiedades diferentes son iguales
+
+console.log(otroFulano.aspecto === otroFulanoMas.aspecto)
\ No newline at end of file
diff --git a/Basic/20-destructuring-spreading.js b/Basic/20-destructuring-spreading.js
new file mode 100644
index 00000000..dcfa5c7c
--- /dev/null
+++ b/Basic/20-destructuring-spreading.js
@@ -0,0 +1,122 @@
+/*
+Clase 5 en vídeo | 07/08/2024
+Objetos, desestructuración, propagación y clases
+https://www.youtube.com/live/SBXEpAx_y_Q?si=Sbqqa2-_eGwsUkH-&t=958
+*/
+
+let myArray = [1, 2, 3, 4]
+
+let person = {
+    name: "Brais",
+    age: 37,
+    alias: "MoureDev"
+}
+
+let myValue = myArray[1]
+console.log(myValue)
+
+let myName = person.name
+console.log(myName)
+
+// Desestructuración
+
+// Sintaxis arrays
+
+let [myValue0, myValue1, myValue2, myValue3, myValue4] = myArray
+console.log(myValue0)
+console.log(myValue1)
+console.log(myValue2)
+console.log(myValue3)
+console.log(myValue4)
+
+// Sintaxis arrays con valores predeterminados
+
+let [myValue5 = 0, myValue6 = 0, myValue7 = 0, myValue8 = 0, myValue9 = 0] = myArray
+console.log(myValue5)
+console.log(myValue6)
+console.log(myValue7)
+console.log(myValue8)
+console.log(myValue9)
+
+// Ignorar elementos array
+
+let [myValue10, , , myValue13] = myArray
+console.log(myValue10)
+console.log(myValue13)
+
+// Sintaxis objects
+
+let { name, age, alias } = person
+console.log(name)
+console.log(age)
+console.log(alias)
+
+// Sintaxis objects con valores predeterminados
+
+let { name2, age2, alias2, email = "email@email.com" } = person
+console.log(name2) // No existe
+console.log(age2)  // No existe
+console.log(alias2)  // No existe
+console.log(email)
+
+// Sintaxis objects con nuevos nombres de variables
+
+let { alias: alias3, name: name3, age: age3 } = person
+console.log(name3)
+console.log(age3)
+console.log(alias3)
+
+// Objects anidados
+
+let person3 = {
+    name: "Brais",
+    age: 37,
+    alias: "MoureDev",
+    walk: function () {
+        console.log("La persona camina.")
+    },
+    job: {
+        name: "Programador",
+        exp: 15,
+        work: function () {
+            console.log(`La persona de ${this.age} años de experiencia trabaja.`)
+        }
+    }
+}
+
+let { name: name4, job: { name: jobName } } = person3
+
+console.log(name4)
+console.log(jobName)
+
+// Propagación (...)
+
+// Sintaxis arrays
+
+let myArray2 = [...myArray, 5, 6]
+
+console.log(myArray2)
+
+// Copia de arrays
+
+let myArray3 = [...myArray]
+
+console.log(myArray3)
+
+// Combinación de arrays
+
+let myArray4 = [...myArray, ...myArray2, ...myArray3]
+
+console.log(myArray4)
+
+// Sintaxis objects
+
+let person4 = { ...person, email: "braismoure@mouredev.com" }
+
+console.log(person4)
+
+// Copia de objects
+
+let person5 = { ...person }
+
+console.log(person5)
\ No newline at end of file
diff --git a/Basic/21-destructuring-spreading-exercises.js b/Basic/21-destructuring-spreading-exercises.js
new file mode 100644
index 00000000..9b03c88d
--- /dev/null
+++ b/Basic/21-destructuring-spreading-exercises.js
@@ -0,0 +1,83 @@
+/*
+Clase 5 en vídeo | 07/08/2024
+Objetos, desestructuración, propagación y clases
+https://www.youtube.com/live/SBXEpAx_y_Q?si=Sbqqa2-_eGwsUkH-&t=958
+*/
+
+// 1. Usa desestructuración para extraer los dos primeros elementos de un array
+
+const arrayUno = [1, 2, 3, 4, 5, 6]
+const [itemUno, itemDos] = arrayUno
+console.log('1: ' + itemUno + ', ' + itemDos)
+
+// 2. Usa desestructuración en un array y asigna un valor predeterminado a una variable
+
+const [dosUno,,,,,, dosDos = 14] = arrayUno
+console.log('2: ' + dosUno + ' y ' + dosDos)
+
+// 3. Usa desestructuración para extraer dos propiedades de un objeto
+
+const objetoUno = {
+  prop1 : 'prop1',
+  prop2 : 'prop2',
+  prop3 : 'prop3',
+}
+
+const { prop3, prop2 } = objetoUno
+console.log('3: ' + prop3 + ' y ' + prop2 )
+
+
+// 4. Usa desestructuración para extraer dos propiedades de un objeto y asígnalas
+//    a nuevas variables con nombres diferentes
+
+const { prop1: primera, prop2: segunda } = objetoUno
+console.log('4: ' + primera + ' y ' + segunda)
+
+// 5. Usa desestructuración para extraer dos propiedades de un objeto anidado
+objetoUno.objetoAnidado = {
+  propAnidada1 : 1,
+  propAnidada2 : 2,
+  propAnidada3 : 3,
+}
+
+const { propAnidada1, propAnidada2 } = objetoUno.objetoAnidado
+console.log('5: ' + propAnidada1 + ' y ' + propAnidada2)
+
+const { prop1, objetoAnidado: { propAnidada3 }} = objetoUno
+
+console.log('5bis: ' + prop1 + ' y ' + propAnidada3)
+
+
+
+// 6. Usa propagación para combinar dos arrays en uno nuevo
+
+const arrayDos = [10, 20, 30]
+const nuevoArray = [...arrayUno, ...arrayDos]
+console.log('6: ' + nuevoArray)
+
+// 7. Usa propagación para crear una copia de un array
+
+const copiaArrayUno = [...arrayUno]
+console.log('7: ' + copiaArrayUno)
+
+// 8. Usa propagación para combinar dos objetos en uno nuevo
+
+const objetoDos = {
+  prop1 : 1,
+  prop2 : 2,
+  prop3 : 3,
+}
+
+const nuevoObjeto = { ...objetoUno, ...objetoDos}
+console.log('8: ' + nuevoObjeto.objetoAnidado.propAnidada1 + ' y ' + nuevoObjeto.prop3)
+
+// 9. Usa propagación para crear una copia de un objetoç
+
+const copiaObjetoDos = { ...objetoDos }
+console.log('9: ' + copiaObjetoDos.prop2)
+
+// 10. Combina desestructuración y propagación
+
+const [uno,,tres, ...resto] = arrayUno
+
+console.log('10: ' + uno + ', ' + tres + ' y ' + resto)
\ No newline at end of file
diff --git a/Basic/22-classes.js b/Basic/22-classes.js
new file mode 100644
index 00000000..9b559b58
--- /dev/null
+++ b/Basic/22-classes.js
@@ -0,0 +1,178 @@
+/*
+Clase 5 en vídeo | 07/08/2024
+Objetos, desestructuración, propagación y clases
+https://www.youtube.com/live/SBXEpAx_y_Q?si=Sbqqa2-_eGwsUkH-&t=958
+*/
+
+// Clases
+
+class Person {
+  constructor(name, age, alias) {
+    this.name = name;
+    this.age = age;
+    this.alias = alias;
+  }
+}
+
+// Sintaxis
+
+let person = new Person("Brais", 37, "MoureDev");
+let person2 = new Person("Brais", 37, "MoureDev");
+
+console.log(person);
+console.log(person2);
+
+console.log(typeof person);
+
+// Valores por defecto
+
+class DefaultPerson {
+  constructor(name = "Sin nombre", age = 0, alias = "Sin alias") {
+    this.name = name;
+    this.age = age;
+    this.alias = alias;
+  }
+}
+
+let person3 = new DefaultPerson("Brais", 37);
+
+console.log(person3);
+
+// Acceso a propiedades
+
+console.log(person3.alias);
+console.log(person3["alias"]);
+
+person3.alias = "MoureDev";
+
+console.log(person3.alias);
+
+// Funciones en clases
+
+class PersonWithMethod {
+  constructor(name, age, alias) {
+    this.name = name;
+    this.age = age;
+    this.alias = alias;
+  }
+
+  walk() {
+    console.log("La persona camina.");
+  }
+}
+
+let person4 = new PersonWithMethod("Brais", 37, "MoureDev");
+person4.walk();
+
+// Propiedades privadas
+
+class PrivatePerson {
+  #bank;
+
+  constructor(name, age, alias, bank) {
+    this.name = name;
+    this.age = age;
+    this.alias = alias;
+    this.#bank = bank;
+  }
+
+  pay() {
+    this.#bank;
+  }
+}
+
+let person5 = new PrivatePerson("Brais", 37, "MoureDev", "IBAN123456789");
+
+// No podemos acceder
+// console.log(person5.bank)
+// person5.bank = "new IBAN123456789" // bank no es #bank
+
+console.log(person5);
+
+// Getters y Setters
+
+class GetSetPerson {
+  #name;
+  #age;
+  #alias;
+  #bank;
+
+  constructor(name, age, alias, bank) {
+    this.#name = name;
+    this.#age = age;
+    this.#alias = alias;
+    this.#bank = bank;
+  }
+
+  get name() {
+    return this.#name;
+  }
+
+  set bank(bank) {
+    this.#bank = bank;
+  }
+}
+
+person6 = new GetSetPerson("Brais", 37, "MoureDev", "IBAN123456789");
+
+console.log(person6);
+console.log(person6.name);
+
+person6.bank = "new IBAN123456789";
+
+/*
+Clase 6 en vídeo | 15/08/2024
+Clases (continuación) y manejo de errores
+https://www.twitch.tv/videos/2225058195?t=00h16m42s
+*/
+
+// Herencia
+
+class Animal {
+  constructor(name) {
+    this.name = name;
+  }
+
+  sound() {
+    console.log("El animal emite un sonido genérico");
+  }
+}
+
+class Dog extends Animal {
+  sound() {
+    console.log("Guau!");
+  }
+
+  run() {
+    console.log("El perro corre");
+  }
+}
+
+class Fish extends Animal {
+  constructor(name, size) {
+    super(name);
+    this.size = size;
+  }
+
+  swim() {
+    console.log("El pez nada");
+  }
+}
+
+let myDog = new Dog("MoureDog");
+myDog.run();
+myDog.sound();
+
+let myFish = new Fish("MoureFish", 10);
+myFish.swim();
+myFish.sound();
+
+// Métodos estáticos
+
+class MathOperations {
+  static sum(a, b) {
+    return a + b;
+  }
+}
+
+console.log(MathOperations.sum(5, 10));
diff --git a/Basic/23-classes-exercises.js b/Basic/23-classes-exercises.js
new file mode 100644
index 00000000..ce6db2f0
--- /dev/null
+++ b/Basic/23-classes-exercises.js
@@ -0,0 +1,109 @@
+/*
+Clase 6 en vídeo | 15/08/2024
+Clases (continuación) y manejo de errores
+https://www.youtube.com/live/8p6SLAIgwZI?si=MS9o7qIhezx9NTQX&t=902
+*/
+
+// 1. Crea una clase que reciba dos propiedades
+
+class Human {
+  constructor(soul, body) {
+    this.body = body
+    this.soul = soul
+  }
+
+  static sleep() {
+    console.log("zzz")
+  }
+}
+
+// 2. Añade un método a la clase que utilice las propiedades
+
+Human.prototype.born = function () {
+  let personality = this.body + this.soul
+  return personality
+}
+
+// 3. Muestra los valores de las propiedades e invoca a la función
+
+let baby = new Human(89, 65)
+console.log(
+  "This baby has a " + baby.soul + " soul and " + baby.body + " body.",
+)
+let babyPersonality = baby.born()
+console.log("It's personality is " + babyPersonality)
+
+// 4. Añade un método estático a la primera clase
+
+// 5. Haz uso del método estático
+
+Human.sleep()
+
+// 6. Crea una clase que haga uso de herencia
+
+class PoliceMan extends Human {
+  constructor(soul, body, character) {
+    super(soul, body)
+    this.character = character
+  }
+
+  arrest() {
+    console.log(" ha arrestado a alguien")
+  }
+}
+
+let policeMan = new PoliceMan(89, 65, "Cabo")
+
+console.log(
+  `El policía es ${
+    policeMan.character
+  } y se tiene una personalidad de ${policeMan.born()} y además`,
+)
+policeMan.arrest()
+// 7. Crea una clase que haga uso de getters y setters
+
+class SecretClass {
+  #secret1
+  #secret2
+  constructor(secret1, secret2) {
+    this.#secret1 = secret1
+    this.#secret2 = secret2
+  }
+
+  get secret1() {
+    return this.#secret1
+  }
+
+  get secret2() {
+    return this.#secret2
+  }
+
+  set secret1(secret) {
+    this.#secret1 = secret
+  }
+
+  set secret2(secret) {
+    this.#secret2 = secret
+  }
+}
+
+let hidden = new SecretClass("secreto1", "secreto2")
+console.log(hidden.secret1)
+hidden.secret1 = "secreto3"
+console.log(hidden.secret1)
+hidden.secret2 = "secreto4"
+console.log(hidden.secret2)
+
+// 8. Modifica la clase con getters y setters para que use propiedades privadas
+
+// 9. Utiliza los get y set y muestra sus valores
+
+// 10. Sobrescribe un método de una clase que utilice herencia
+
+class OldMan extends Human {
+  static sleep() {
+    console.log("grrrrrrrrr")
+  }
+}
+
+OldMan.sleep()
diff --git a/Basic/24-error-handling.js b/Basic/24-error-handling.js
new file mode 100644
index 00000000..e69de29b