Listo ejercicio 7 y 8

clase-7-arrays-funciones-objetos/.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+
+# Entorno virtual de Python
+venv/
+.venv/
+env/
+
+# Variables de entorno y configuración sensible
+.env
+
+# Sistemas operativos
+.DS_Store        # macOS
+Thumbs.db        # Windows
+
+# Node.js (por si se utiliza npm en algún momento)
+node_modules/

clase-7-arrays-funciones-objetos/README.md

@@ -0,0 +1,102 @@
+# Clase 7: Arrays, objetos y funciones útiles en javascript
+
+## Ejercicios propuestos
+
+0. Seguir los pasos habituales para gestionar con git estos ejercicios:
+  - Hacer un fork de este repositorio (el que tiene `marquez.juan` en la URL)
+  - Clonar **tu fork**. (No debería figurar `marquez.juan` en la URL).
+  - Crear una nueva rama con `switch -c nombre-de-tu-rama`
+  - Hacer `git push origin nombre-de-tu-rama`
+  - Desde gitea, crear el pull request, desde la rama recién creada de tu fork
+hacia la rama `main` del repositorio que pertenece a `marquez.juan`. De esta
+manera el docente puede ir siguiendo tu trabajo y respondiendo las consultas
+más fácilmente.
+  - Comenzar a resolver los ejercicios, en el archivo `ejercicios.js`.
+  - Hacer al menos un commit por cada uno de los ejercicios que siguen.
+  - Al finalizar cada sesión de trabajo, hacer `git push origin
+    nombre-de-tu-rama`
+
+1. Dado el siguiente array, usar `filter` para obtener solo los números pares, y
+   luego `map` para elevarlos al cuadrado.
+   ```js
+   const numeros = [1, 2, 3, 4, 5, 6, 7, 8];
+   // Resultado esperado: [4, 16, 36, 64]
+   ```
+
+2. Dado el siguiente array de productos, obtener los nombres de todos los
+   productos que cuestan menos de $1000.
+   ```js
+   const productos = [
+       { nombre: "Teclado", precio: 800 },
+       { nombre: "Monitor", precio: 3500 },
+       { nombre: "Mouse", precio: 600 },
+       { nombre: "Auriculares", precio: 1200 }
+   ];
+   // Resultado esperado: ["Teclado", "Mouse"]
+   ```
+   Pista: se puede resolver encadenando `filter` y `map`.
+
+3. Escribir una función `describir` que reciba un objeto persona con las
+   propiedades `nombre`, `edad` y `ciudad`, y retorne un string del estilo:
+   `"Ana tiene 25 años y vive en Rosario."` Usar destructuring en los
+   parámetros de la función.
+
+4. Dado el siguiente array de estudiantes, calcular el promedio general de notas
+   usando `map` para extraer las notas y luego un loop para sumarlas.
+   ```js
+   const estudiantes = [
+       { nombre: "Ana", nota: 88 },
+       { nombre: "Luis", nota: 72 },
+       { nombre: "Marta", nota: 95 },
+       { nombre: "Carlos", nota: 60 }
+   ];
+   // Resultado esperado: 78.75
+   ```
+
+5. Usar `find` para buscar un usuario por nombre dentro de un array, y mostrar
+   en consola un mensaje diferente según si se encontró o no.
+   ```js
+   const usuarios = [
+       { nombre: "Ana", activa: true },
+       { nombre: "Luis", activa: false },
+       { nombre: "Marta", activa: true }
+   ];
+   // Buscar "Luis" → mostrar sus datos
+   // Buscar "Pedro" → mostrar "Usuario no encontrado"
+   ```
+
+6. Dado el siguiente array, construir un nuevo array que contenga solo las
+   palabras con más de 4 letras, convertidas a mayúsculas.
+   ```js
+   const palabras = ["sol", "tormenta", "mar", "lluvia", "río", "arcoíris"];
+   // Resultado esperado: ["TORMENTA", "LLUVIA", "ARCOÍRIS"]
+   ```
+   Pistas: `palabra.length` da la cantidad de letras. `palabra.toUpperCase()`
+   convierte a mayúsculas.
+
+7. Escribir una función `agrupar` que reciba un array de objetos con la forma
+   `{ nombre, aprobado }` y retorne un objeto con dos propiedades: `aprobados`
+   y `desaprobados`, cada una con un array de nombres.
+   ```js
+   const resultados = [
+       { nombre: "Ana", aprobado: true },
+       { nombre: "Luis", aprobado: false },
+       { nombre: "Marta", aprobado: true },
+       { nombre: "Carlos", aprobado: false }
+   ];
+
+   // Resultado esperado:
+   // {
+   //   aprobados: ["Ana", "Marta"],
+   //   desaprobados: ["Luis", "Carlos"]
+   // }
+   ```
+
+8. *(Opcional - closures)* Escribir una función `crearSumador` que reciba un
+   número `base` y retorne una función que, al llamarla con otro número,
+retorne la suma de ambos.
+   ```js
+   const sumarDiez = crearSumador(10);
+   console.log(sumarDiez(5));   // 15
+   console.log(sumarDiez(20));  // 30
+   ```

clase-7-arrays-funciones-objetos/ejercicios.js

@@ -0,0 +1,160 @@
+// Vincular este archivo a index.html, debería aparecer este mensaje en la consola:
+console.log("Archivo vinculado correctamente.");
+
+// Resolver los siguientes ejercicios:
+
+/*
+1. Dado el siguiente array, usar `filter` para obtener solo los números pares, y
+   luego `map` para elevarlos al cuadrado.
+*/
+const numeros = [1, 2, 3, 4, 5, 6, 7, 8];
+const pares = numeros.filter(numeros =>{
+   return numeros % 2 === 0;
+} );
+const resultado = pares.map(pares =>{
+   return pares ** 2;
+});
+console.log(resultado);
+// Resultado esperado: [4, 16, 36, 64]
+
+/*
+2. Dado el siguiente array de productos, obtener los nombres de todos los
+   productos que cuestan menos de $1000.
+*/
+
+const productos = [
+    { nombre: "Teclado", precio: 800 },
+    { nombre: "Monitor", precio: 3500 },
+    { nombre: "Mouse", precio: 600 },
+    { nombre: "Auriculares", precio: 1200 }
+];
+
+const nombresBaratos = productos
+.filter(producto => producto.precio < 1000)
+.map(producto => producto.nombre);
+
+console.log(nombresBaratos);
+// Resultado esperado: ["Teclado", "Mouse"]
+// Pista: se puede resolver encadenando `filter` y `map`.
+
+/*
+3. Escribir una función `describir` que reciba un objeto persona con las
+   propiedades `nombre`, `edad` y `ciudad`, y retorne un string del estilo:
+   `"Ana tiene 25 años y vive en Rosario."` Usar destructuring en los
+   parámetros de la función.
+*/
+
+const persona = {
+   nombre : "Ana",
+   edad : 25,
+   ciudad : "Rosario"
+};
+function describir({nombre, edad, ciudad}){
+   return `${nombre} tiene ${edad} años y vive en ${ciudad}.`;
+}
+console.log (describir(persona));
+/*
+4. Dado el siguiente array de estudiantes, calcular el promedio general de notas
+   usando `map` para extraer las notas y luego un loop para sumarlas.
+*/
+
+const estudiantes = [
+    { nombre: "Ana", nota: 88 },
+    { nombre: "Luis", nota: 72 },
+    { nombre: "Marta", nota: 95 },
+    { nombre: "Carlos", nota: 60 }
+];
+
+const notas = estudiantes.map(estudiante => estudiante.nota);
+let suma = 0;
+for (let i = 0; i < notas.length; i++){
+   suma += notas[i];
+}
+const promedio = suma / notas.length;
+console.log(promedio);
+console.log("Notas extraídas:", notas);
+console.log("Promedio general:", promedio);
+// Resultado esperado: 78.75
+
+/*
+5. Usar `find` para buscar un usuario por nombre dentro de un array, y mostrar
+   en consola un mensaje diferente según si se encontró o no.
+*/
+const usuarios = [
+    { nombre: "Ana", activa: true },
+    { nombre: "Luis", activa: false },
+    { nombre: "Marta", activa: true }
+];
+ function buscarUsuario(nombre) {
+   const usuario = usuarios.find(usuario => usuario.nombre === nombre);}
+   if (usario){
+      console.log(`Usuario encontrado: ${usuario.nombre}, Activa: ${usuario.activa}`);
+   } else{
+      console.log("Usuario no encontrado");
+
+   }
+
+// Buscar "Luis" → mostrar sus datos
+// Buscar "Pedro" → mostrar "Usuario no encontrado"
+
+/*
+6. Dado el siguiente array, construir un nuevo array que contenga solo las
+   palabras con más de 4 letras, convertidas a mayúsculas.
+*/
+
+const palabras = ["sol", "tormenta", "mar", "lluvia", "río", "arcoíris"];
+// Resultado esperado: ["TORMENTA", "LLUVIA", "ARCOÍRIS"]
+
+// Pistas: `palabra.length` da la cantidad de letras. `palabra.toUpperCase()`
+// convierte a mayúsculas.
+const palabrasLargas = palabras . filter (palabra  => palabra.length > 4)
+.map(palabra => palabra.toUpperCase());
+console.log(palabrasLargas);
+/*
+7. Escribir una función `agrupar` que reciba un array de objetos con la forma
+   `{ nombre, aprobado }` y retorne un objeto con dos propiedades: `aprobados`
+   y `desaprobados`, cada una con un array de nombres.
+*/
+const resultados = [
+    { nombre: "Ana", aprobado: true },
+    { nombre: "Luis", aprobado: false },
+    { nombre: "Marta", aprobado: true },
+    { nombre: "Carlos", aprobado: false }
+];
+
+function agrupar(resultados){
+   const agrupados = {
+      aprobados: [],
+      desaprobados: []
+}
+   
+   };
+   resultados.forEach(resultado =>{
+      if (resultado.aprobado){
+         agrupados.aprobados.push(resultado.nombre);
+      } else{
+         agrupados.desaprobados.push(resultado.nombre);
+      }
+   });
+   return agrupados;
+
+// Resultado esperado:
+// {
+//   aprobados: ["Ana", "Marta"],
+//   desaprobados: ["Luis", "Carlos"]
+// }
+
+/*
+8. *(Opcional - closures)* Escribir una función `crearSumador` que reciba un
+   número `base` y retorne una función que, al llamarla con otro número,
+retorne la suma de ambos.
+
+const sumarDiez = crearSumador(10);
+console.log(sumarDiez(5));   // 15
+console.log(sumarDiez(20));  // 30
+*/
+function crearSumador(base){
+   return function (numero){
+      return base + numero;
+   };
+}

clase-7-arrays-funciones-objetos/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width">
+        <title>Ejercicios en javascript - clase 7</title>
+    </head>
+    <body>
+        <h1>Ejercicios en javascript - clase 7</h1>        
+        <p>Vincular el archivo ejercicios.js a este archivo. Luego, resolver ahí
+        los ejercicios.</p>
+
+        <script src="ejercicios.js"></script>
+    </body>
+</html>