Capítulo 5: Funciones Avanzadas
Ejercicios Prácticos
Para reforzar los conceptos discutidos en este capítulo sobre funciones avanzadas, aquí hay varios ejercicios prácticos. Estos ejercicios están diseñados para probar tu comprensión de las funciones flecha, callbacks y promesas, async/await, y closures. Cada ejercicio incluye una solución para ayudarte a verificar tu implementación.
Ejercicio 1: Convertir a Funciones Flecha
Convierte las siguientes expresiones de funciones tradicionales en funciones flecha.
Expresiones de Funciones Tradicionales:
function add(x, y) {
return x + y;
}
function filterNumbers(arr) {
return arr.filter(function(item) {
return item > 5;
});
}Solución:
const add = (x, y) => x + y;
const filterNumbers = arr => arr.filter(item => item > 5);Ejercicio 2: Implementar una Promesa Simple
Crea una función multiply que devuelva una promesa que se resuelva con el producto de dos números pasados como argumentos.
Solución:
function multiply(x, y) {
return new Promise((resolve, reject) => {
if (typeof x !== 'number' || typeof y !== 'number') {
reject(new Error("Invalid input"));
} else {
resolve(x * y);
}
});
}
multiply(5, 2).then(result => console.log(result)).catch(error => console.error(error));Ejercicio 3: Usando Async/Await
Escribe una función async que utilice la función multiply del Ejercicio 2 para encontrar el producto de dos números, luego registre el resultado. Incluye manejo de errores.
Solución:
async function calculateProduct(x, y) {
try {
const result = await multiply(x, y);
console.log('Product:', result);
} catch (error) {
console.error('Error:', error.message);
}
}
calculateProduct(10, 5); // Outputs: Product: 50Ejercicio 4: Crear un Closure
Crea un closure que mantenga una variable contador privada y exponga métodos para incrementar y decrementar el contador.
Solución:
function createCounter() {
let counter = 0;
return {
increment() {
counter++;
console.log('Counter:', counter);
},
decrement() {
counter--;
console.log('Counter:', counter);
}
};
}
const myCounter = createCounter();
myCounter.increment(); // Counter: 1
myCounter.increment(); // Counter: 2
myCounter.decrement(); // Counter: 1Ejercicio 5: Memoización con Closures
Implementa una función de memoización que almacene en caché los resultados de una función basada en sus parámetros para optimizar el rendimiento.
Solución:
function memoize(fn) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (!cache[key]) {
cache[key] = fn.apply(this, args);
}
return cache[key];
};
}
const factorial = memoize(function(x) {
if (x === 0) {
return 1;
} else {
return x * factorial(x - 1);
}
});
console.log(factorial(5)); // Outputs: 120
console.log(factorial(5)); // Outputs: 120 (from cache)Estos ejercicios proporcionan práctica práctica con los conceptos clave de este capítulo, ayudándote a consolidar tu comprensión de las funciones avanzadas de JavaScript y sus aplicaciones en escenarios del mundo real.
Ejercicios Prácticos
Para reforzar los conceptos discutidos en este capítulo sobre funciones avanzadas, aquí hay varios ejercicios prácticos. Estos ejercicios están diseñados para probar tu comprensión de las funciones flecha, callbacks y promesas, async/await, y closures. Cada ejercicio incluye una solución para ayudarte a verificar tu implementación.
Ejercicio 1: Convertir a Funciones Flecha
Convierte las siguientes expresiones de funciones tradicionales en funciones flecha.
Expresiones de Funciones Tradicionales:
function add(x, y) {
return x + y;
}
function filterNumbers(arr) {
return arr.filter(function(item) {
return item > 5;
});
}Solución:
const add = (x, y) => x + y;
const filterNumbers = arr => arr.filter(item => item > 5);Ejercicio 2: Implementar una Promesa Simple
Crea una función multiply que devuelva una promesa que se resuelva con el producto de dos números pasados como argumentos.
Solución:
function multiply(x, y) {
return new Promise((resolve, reject) => {
if (typeof x !== 'number' || typeof y !== 'number') {
reject(new Error("Invalid input"));
} else {
resolve(x * y);
}
});
}
multiply(5, 2).then(result => console.log(result)).catch(error => console.error(error));Ejercicio 3: Usando Async/Await
Escribe una función async que utilice la función multiply del Ejercicio 2 para encontrar el producto de dos números, luego registre el resultado. Incluye manejo de errores.
Solución:
async function calculateProduct(x, y) {
try {
const result = await multiply(x, y);
console.log('Product:', result);
} catch (error) {
console.error('Error:', error.message);
}
}
calculateProduct(10, 5); // Outputs: Product: 50Ejercicio 4: Crear un Closure
Crea un closure que mantenga una variable contador privada y exponga métodos para incrementar y decrementar el contador.
Solución:
function createCounter() {
let counter = 0;
return {
increment() {
counter++;
console.log('Counter:', counter);
},
decrement() {
counter--;
console.log('Counter:', counter);
}
};
}
const myCounter = createCounter();
myCounter.increment(); // Counter: 1
myCounter.increment(); // Counter: 2
myCounter.decrement(); // Counter: 1Ejercicio 5: Memoización con Closures
Implementa una función de memoización que almacene en caché los resultados de una función basada en sus parámetros para optimizar el rendimiento.
Solución:
function memoize(fn) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (!cache[key]) {
cache[key] = fn.apply(this, args);
}
return cache[key];
};
}
const factorial = memoize(function(x) {
if (x === 0) {
return 1;
} else {
return x * factorial(x - 1);
}
});
console.log(factorial(5)); // Outputs: 120
console.log(factorial(5)); // Outputs: 120 (from cache)Estos ejercicios proporcionan práctica práctica con los conceptos clave de este capítulo, ayudándote a consolidar tu comprensión de las funciones avanzadas de JavaScript y sus aplicaciones en escenarios del mundo real.
Ejercicios Prácticos
Para reforzar los conceptos discutidos en este capítulo sobre funciones avanzadas, aquí hay varios ejercicios prácticos. Estos ejercicios están diseñados para probar tu comprensión de las funciones flecha, callbacks y promesas, async/await, y closures. Cada ejercicio incluye una solución para ayudarte a verificar tu implementación.
Ejercicio 1: Convertir a Funciones Flecha
Convierte las siguientes expresiones de funciones tradicionales en funciones flecha.
Expresiones de Funciones Tradicionales:
function add(x, y) {
return x + y;
}
function filterNumbers(arr) {
return arr.filter(function(item) {
return item > 5;
});
}Solución:
const add = (x, y) => x + y;
const filterNumbers = arr => arr.filter(item => item > 5);Ejercicio 2: Implementar una Promesa Simple
Crea una función multiply que devuelva una promesa que se resuelva con el producto de dos números pasados como argumentos.
Solución:
function multiply(x, y) {
return new Promise((resolve, reject) => {
if (typeof x !== 'number' || typeof y !== 'number') {
reject(new Error("Invalid input"));
} else {
resolve(x * y);
}
});
}
multiply(5, 2).then(result => console.log(result)).catch(error => console.error(error));Ejercicio 3: Usando Async/Await
Escribe una función async que utilice la función multiply del Ejercicio 2 para encontrar el producto de dos números, luego registre el resultado. Incluye manejo de errores.
Solución:
async function calculateProduct(x, y) {
try {
const result = await multiply(x, y);
console.log('Product:', result);
} catch (error) {
console.error('Error:', error.message);
}
}
calculateProduct(10, 5); // Outputs: Product: 50Ejercicio 4: Crear un Closure
Crea un closure que mantenga una variable contador privada y exponga métodos para incrementar y decrementar el contador.
Solución:
function createCounter() {
let counter = 0;
return {
increment() {
counter++;
console.log('Counter:', counter);
},
decrement() {
counter--;
console.log('Counter:', counter);
}
};
}
const myCounter = createCounter();
myCounter.increment(); // Counter: 1
myCounter.increment(); // Counter: 2
myCounter.decrement(); // Counter: 1Ejercicio 5: Memoización con Closures
Implementa una función de memoización que almacene en caché los resultados de una función basada en sus parámetros para optimizar el rendimiento.
Solución:
function memoize(fn) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (!cache[key]) {
cache[key] = fn.apply(this, args);
}
return cache[key];
};
}
const factorial = memoize(function(x) {
if (x === 0) {
return 1;
} else {
return x * factorial(x - 1);
}
});
console.log(factorial(5)); // Outputs: 120
console.log(factorial(5)); // Outputs: 120 (from cache)Estos ejercicios proporcionan práctica práctica con los conceptos clave de este capítulo, ayudándote a consolidar tu comprensión de las funciones avanzadas de JavaScript y sus aplicaciones en escenarios del mundo real.
Ejercicios Prácticos
Para reforzar los conceptos discutidos en este capítulo sobre funciones avanzadas, aquí hay varios ejercicios prácticos. Estos ejercicios están diseñados para probar tu comprensión de las funciones flecha, callbacks y promesas, async/await, y closures. Cada ejercicio incluye una solución para ayudarte a verificar tu implementación.
Ejercicio 1: Convertir a Funciones Flecha
Convierte las siguientes expresiones de funciones tradicionales en funciones flecha.
Expresiones de Funciones Tradicionales:
function add(x, y) {
return x + y;
}
function filterNumbers(arr) {
return arr.filter(function(item) {
return item > 5;
});
}Solución:
const add = (x, y) => x + y;
const filterNumbers = arr => arr.filter(item => item > 5);Ejercicio 2: Implementar una Promesa Simple
Crea una función multiply que devuelva una promesa que se resuelva con el producto de dos números pasados como argumentos.
Solución:
function multiply(x, y) {
return new Promise((resolve, reject) => {
if (typeof x !== 'number' || typeof y !== 'number') {
reject(new Error("Invalid input"));
} else {
resolve(x * y);
}
});
}
multiply(5, 2).then(result => console.log(result)).catch(error => console.error(error));Ejercicio 3: Usando Async/Await
Escribe una función async que utilice la función multiply del Ejercicio 2 para encontrar el producto de dos números, luego registre el resultado. Incluye manejo de errores.
Solución:
async function calculateProduct(x, y) {
try {
const result = await multiply(x, y);
console.log('Product:', result);
} catch (error) {
console.error('Error:', error.message);
}
}
calculateProduct(10, 5); // Outputs: Product: 50Ejercicio 4: Crear un Closure
Crea un closure que mantenga una variable contador privada y exponga métodos para incrementar y decrementar el contador.
Solución:
function createCounter() {
let counter = 0;
return {
increment() {
counter++;
console.log('Counter:', counter);
},
decrement() {
counter--;
console.log('Counter:', counter);
}
};
}
const myCounter = createCounter();
myCounter.increment(); // Counter: 1
myCounter.increment(); // Counter: 2
myCounter.decrement(); // Counter: 1Ejercicio 5: Memoización con Closures
Implementa una función de memoización que almacene en caché los resultados de una función basada en sus parámetros para optimizar el rendimiento.
Solución:
function memoize(fn) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (!cache[key]) {
cache[key] = fn.apply(this, args);
}
return cache[key];
};
}
const factorial = memoize(function(x) {
if (x === 0) {
return 1;
} else {
return x * factorial(x - 1);
}
});
console.log(factorial(5)); // Outputs: 120
console.log(factorial(5)); // Outputs: 120 (from cache)Estos ejercicios proporcionan práctica práctica con los conceptos clave de este capítulo, ayudándote a consolidar tu comprensión de las funciones avanzadas de JavaScript y sus aplicaciones en escenarios del mundo real.