Samuel Mosquera

ej01.js

@@ -0,0 +1,14 @@
+
+// Concepto: let y const respetan el bloque; const impide reasignación, let la permite.
+// Completa con let o const según corresponda para obtener la salida indicada.
+let x = 10;
+if (true) {
+    let x = 20;          // declara una nueva variable en este bloque
+    console.log(x);        // 20
+}
+console.log(x);            // 10
+
+const obj = { valor: 5 };
+obj.valor = 8;             // mutación permitida
+// obj = {};               // Error si la palabra clave es correcta
+console.log(obj.valor);    // 8

ej02.js

@@ -0,0 +1,10 @@
+// Concepto: `const` impide reasignar la variable, pero permite modificar propiedades.
+const persona = { nombre: "Ada", edad: 25 };
+persona.edad = 26;                 // mutación válida
+
+// Completa para crear una copia con una propiedad adicional, sin alterar el original:
+const actualizado = { ...persona, activo: true };
+console.log(actualizado); // { nombre: "Ada", edad: 26, activo: true }
+
+// Ahora completa para mostrar la edad del objeto original:
+console.log(persona.edad);   // 26

ej03.js

@@ -0,0 +1,11 @@
+// Concepto: Los parámetros pueden tener valores por defecto.
+// Para devolver un objeto desde una función se construye con { ... }.
+const crearLibro = (titulo, autor = "Anónimo", año = new Date().getFullYear()) => {
+    return { titulo, autor, año };
+};
+
+console.log(crearLibro("El Principito", "Saint-Exupéry", 1943));
+// { titulo: "El Principito", autor: "Saint-Exupéry", año: 1943 }
+
+console.log(crearLibro("1984"));
+// { titulo: "1984", autor: "Anónimo", año: 2026 }

ej04.js

@@ -0,0 +1,6 @@
+// Concepto: ...rest captura argumentos sobrantes en un array real.
+function generarInforme(categoria, ...items) {
+    return `Informe de ${categoria}: ${items.join(" – ")}`;
+}
+console.log(generarInforme("Ventas", "Enero", "Febrero", "Marzo"));
+// "Informe de Ventas: Enero – Febrero – Marzo"

ej05.js

@@ -0,0 +1,11 @@
+// Concepto: El spread copia superficialmente; útil para inmutabilidad.
+const valores = [10, 20, 30];
+const doble = valores.map(n => n * 2);
+// Usando spread, crea un array con el primer elemento de 'valores', luego los duplicados:
+const mezcla = [valores[0], ...doble];
+console.log(mezcla); // [10, 20, 40, 60]
+
+// Completa para clonar un objeto y sobrescribir una propiedad:
+const objBase = { x: 1, y: 2 };
+const objMod = { ...objBase, y: 100 };
+console.log(objMod); // { x: 1, y: 100 }

ej06.js

@@ -0,0 +1,16 @@
+
+// Concepto: ?.[variable] accede a una posición de array de forma segura; ?.() llama a métodos.
+const estructura = {
+    bloques: [
+        { id: "a", ejecutar: () => "A ejecutado" },
+        null,
+        { id: "c", acciones: ["imprimir"] }
+    ]
+};
+const idx = 0;
+const res0 = estructura.bloques?.[idx]?.ejecutar?.();
+console.log(res0); // "A ejecutado"
+const res1 = estructura.bloques?.[1]?.idx?.();
+console.log(res1); // undefined
+const res2 = estructura.bloques?.[2]?.acciones?.[0];
+console.log(res2); // "imprimir"

ej07.js

@@ -0,0 +1,12 @@
+// Concepto: Puedes encadenar varios métodos de array. .join() convierte un array en una cadena.
+const productos = [
+    { nombre: "Laptop", precio: 1000, activo: true },
+    { nombre: "Mouse", precio: 20, activo: true },
+    { nombre: "Teclado", precio: 50, activo: true },
+    { nombre: "Monitor", precio: 200, activo: false }
+];
+const lista = productos
+    .filter(p => p.activo && p.precio > 30)
+    .map(p => p.nombre)
+    .join(" – ");
+console.log(lista); // "Laptop – Teclado"

ej08.js

@@ -0,0 +1,23 @@
+// Concepto: Extrae propiedades anidadas, asígnale alias y define un valor por defecto si no existe.
+const pedido = {
+    id: 101,
+    cliente: {
+        nombre: "Carlos",
+        direccion: {
+            ciudad: "Lima"
+        }
+    }
+};
+const {
+    id,
+    cliente: {
+        nombre: clienteNombre,
+        direccion: { ciudad: ciudadEntrega = "Sin dirección" }
+    }
+} = pedido;
+console.log(clienteNombre, ciudadEntrega); // "Carlos" "Lima"
+
+// Completa para que en el siguiente objeto sin dirección se obtenga "Desconocida":
+const pedido2 = { id: 102, cliente: { nombre: "Ana" } };
+const { cliente: { direccion: { ciudad = "Desconocida" } = {} } } = pedido2;
+console.log(ciudad); // "Desconocida"

ej09.js

@@ -0,0 +1,11 @@
+// Concepto: ?. para acceso seguro, ?? para dar un valor solo si es null/undefined.
+const config = {
+    servidor: {
+        cache: {
+            ttl: 0   // 0 es válido
+        }
+    }
+};
+const ttlFinal = config?.servidor?.cache?.ttl ?? 3600; // 0 (el 0 se respeta)
+const timeout = config?.servidor?.timeout ?? 5000;        // 5000 (no existe)
+console.log(ttlFinal, timeout); // 0 5000

ej10.js

@@ -0,0 +1,6 @@
+// Concepto: ??= asigna si la variable es null/undefined, respetando falsy.
+const ajustes = { compresion: false, nivel: 0 };
+ajustes.compresion ??= true; // no cambia (false no es null/undefined)
+ajustes.nivel ||= 5;    // sí cambia porque nivel es 0, que es falsy pero no null/undefined
+// ¿Qué operador de asignación completa la línea? (escribe el operador)
+console.log(ajustes); // { compresion: false, nivel: 5 }

ej11.js

@@ -0,0 +1,11 @@
+const formatear = ({ nombre, edad, pais = "No especificado" }) =>
+    ({ nombre, edad, etiqueta: `${nombre} (${pais})` });
+
+console.log(formatear({ nombre: "Luis", edad: 30, pais: "Perú" }));
+// { nombre: "Luis", edad: 30, etiqueta: "Luis (Perú)" }
+
+// Ahora completa la versión con parámetros separados y rest:
+const resumir = (titulo, ...datos) =>
+    ({ titulo, total: datos.length, primer: datos[0] });
+console.log(resumir("Ventas", "Enero", "Febrero"));
+// { titulo: "Ventas", total: 2, primer: "Enero" }

ej13.js

@@ -0,0 +1,4 @@
+const calificaciones = [85, 92, 78, 95];
+const todosAprobados = calificaciones.every(n => n >= 70);  // true
+const algunSobresaliente = calificaciones.some(n => n >= 90); // true
+console.log(todosAprobados, algunSobresaliente);

ej15.js

@@ -0,0 +1,10 @@
+const obtenerUsuario = async (id) => {
+    try {
+        const respuesta = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
+        if (!respuesta.ok) throw new Error("Error de red");
+        const datos = await respuesta.json();
+        console.log(datos.name);
+    } catch (error) {
+        console.error(error.message);
+    }
+};

ej17.js

@@ -0,0 +1,4 @@
+const stock = 5;
+const estado = stock > 10 ? "Alto" : (stock > 0 ? "Bajo" : "Agotado");
+const mensaje = `Estado del producto: ${stock > 0 ? `Quedan ${stock}` : $[5]}`;
+console.log(mensaje); // "Estado del producto: Quedan 5

ej19.js

@@ -0,0 +1,13 @@
+const tienda = {
+    secciones: [
+        { nombre: "Electrónica", productos: [{ nombre: "TV" }] },
+        null
+    ]
+};
+// Accede de forma segura al nombre del primer producto de la primera sección
+const primerProducto = tienda?.secciones?.[0]?.productos?.[0]?.nombre;
+console.log(primerProducto); // "TV"
+
+// Intenta acceder a la sección nula y a su primer producto
+const segundoProducto = tienda?.secciones?.[1]?.productos?.[0]?.nombre;
+console.log(segundoProducto);tv // undefined