ES10: try catch y fromEntries

Hola Chic@s 😃

ES10:

• Try catch

try {
    hello ();
} catch (error) {
    console.log(error);
}

try {
    onotherFn();
} catch {
    console.log("esto es un error")
}

• FromEntries

const entries = new Map ([["name", "alexa"], ["age", 24]]);
console.log(entries);
console.log(Object.fromEntries(entries));

Para quienes no entiendan por qué el profesor usó Map en vez de un array, les comento que también se puede usar el mismo método con un array normal,

// Ahora se puede cambiar de un array a un objeto
const entries = [
  ["name", "Sime"],
  ["age", 30],
];
console.log("Array original", entries);
// Array origintal [ [ 'name', 'Sime' ], [ 'age', 30 ] ]
console.log("Array transformado a object", Object.fromEntries(entries));
// Array transformado a object { name: 'Sime', age: 30 }

Un uso de try { } catch { } es cuando tienes llamadas a una API, pero con async ... await

async function getUsers() {
  try {
    const data = await fetch('....')
  } catch {
    console.log(error)
  }
}

Dado que a diferencia de las promesas, no tenemos un método then ... catch

Me preguntaba como hacer lo opuesto, de Object a Array… usando entries() seria:

const array = Object.entries(object);
console.table(array);

quisiera comentarles algunas cosas que no se pueden hacer con el OjectfromEntries, si tenemos el siguiente codigo

const entries = new Map([["name", "Arnoll"],["Country", "Col"],["age", 20]]);
console.log(entries);
console.log(Object.fromEntries(entries));

no funcionara si tenemos mas de un par de datos dentro del array por ejemplo:

Input
const entries = new Map([["name", "Arnoll", "Country", "Col"],["age", 20]]);

Output
{ name: 'Arnoll', age: 20 }

para que hayan mas elementos deben estar separados de a par por los corchetes por ejemplo:

Input
const entries = new Map([["name", "Arnoll"],["Country", "Col"],["age", 20]]);

Output
{ name: 'Arnoll', Country: 'Col', age: 20 }

acepto feedback

El error del catch ahora es opcional

try {
  hello();
} catch(e) {
  console.log('F por el hello()!')
  console.log(e);
}

try {
  anotherFn();
} catch {
  console.log('Esto es un error')
}

Se puede pasar directamente el array a Object.fromEntries y tambien lo va a transformar en un objeto. Sin necesidad de pasarlo por new Map

const transformar = [['nombre', 'Leopoldo'],['edad','35']]
const entries = new Map(transformar)
console.log(transformar)
console.log(Object.fromEntries(transformar))
console.log(Object.fromEntries(entries))

Bastante decepcionado de las explicaciones, solo de saber que Oscar es el profesor de los siguientes cursos en mi ruta Full Stack Developer con JavaScript, ya decepciona bastante. No por su conocimiento, sencillamente hay personas que sirven para explicar y otras no.

ES10: try catch y fromEntries

Veamos más detalladamente sobre estas dos características introducidas en ECMAScript 2019 (ES10): try...catch y Object.fromEntries().

1. try...catch con parámetros opcionales en catch:
   
   En ECMAScript 2019, se introdujo una mejora en la sintaxis del bloque catch que permite omitir el parámetro entre paréntesis.
   
   Anteriormente, en un bloque catch, era necesario proporcionar un parámetro para capturar la excepción, incluso si no planeabas utilizarlo. Con la actualización en ES10, puedes escribir un bloque catch sin parámetros, lo que resulta útil cuando solo estás interesado en manejar la excepción sin necesidad de acceder al objeto de error.
   
   Por ejemplo:

   try {
       // Código que puede generar una excepción
   } catch {
       // Manejar la excepción sin necesidad del parámetro de error
   }
   

   Esta característica hace que el código sea más limpio y evita la necesidad de declarar un parámetro que no se va a usar.

2. Object.fromEntries():
   
   Object.fromEntries() es un método estático que se agregó en ES10. Permite convertir un array de pares clave-valor en un objeto. Antes de esta adición, para crear un objeto a partir de un array de pares clave-valor, tenías que recorrer el array y agregar cada par clave-valor al objeto manualmente. Con Object.fromEntries(), este proceso se simplifica significativamente.
   
   Por ejemplo:

   const entries = [
       ['nombre', 'Juan'],
       ['edad', 30],
       ['ciudad', 'Madrid']
   ];
   
   const obj = Object.fromEntries(entries);
   
   console.log(obj); // { nombre: 'Juan', edad: 30, ciudad: 'Madrid' }
   

   
   Este método es útil cuando trabajas con datos en forma de pares clave-valor y deseas convertirlos en un objeto.

Estas características son solo dos de las muchas mejoras y adiciones que se introdujeron en ECMAScript 2019 (ES10) para mejorar la experiencia de programación en JavaScript.

Espero sea de utilidad. 👨‍💻

📖 Archivos del Proyecto 📖

Pasos 📌

• • Dentro de la carpeta es10, crear el archivo llamado: 02-try-catch.js
  • • ◦ El código queda:

//Compilar: seleccionar el código + click derecho + Run Code

//Ejercicio #1
try {
	hello();
} catch(error) {
	console.log(error);
}

/*output: ocurre un error y lo muestra por consola
ReferenceError: hello is not defined
*/

//Ejercicio #2
try {
	anotherFn();
} catch(error) {
	console.log('Esto es un error');
}

/*output: muestra el console porque entró en el catch
Esto es un error
*/

 
• Dentro de la carpeta es10, crear el archivo llamado: 03-fromentries.js
◦ El código queda:

//Compilar: seleccionar el código + click derecho + Run Code

//Ejercicio #1
const entries = new Map([["name", "oscar"], ["age", 34]]);
console.log(entries);
console.log(Object.fromEntries(entries));

/*output:
Map(2) { 'name' => 'oscar', 'age' => 34 }
{ name: 'oscar', age: 34 }
*/

uhmmm me quedo un poco falto de explicación, pero ta bn

25/35 ES10: try catch y fromEntries
El parámetro opcional de catch y el método Object.fromEntries para transformar arrays en objetos.

El parámetro opcional de catch permite omitir el uso del parámetro “err” en la función catch si no es necesario. Por ejemplo:

try {
  // código que puede generar un error
} catch {
  // manejar el error sin el parámetro "err"
}

El método Object.fromEntries convierte un array de entries (pares clave-valor) en un objeto. Por ejemplo:

const arrayEntries = [  [ 'name', 'Andres' ],
  [ 'email', '[email protected]' ],
  [ 'age', 23 ]
] 

const usuario = Object.fromEntries(arrayEntries) 

console.log(usuario) // { name: 'Andres', email: '[email protected]', 
// age: 23 }

En esta clase me he dado cuenta que existen dos map.
el .map() y el Map([…])
Segun lo que he buscado (corríjanme si estoy mal)

• Es que .map() es un método que se utiliza en arrays, para crear un nuevo array con los resultados de aplicar una funcion a cada elemento del array original.

var numbers = [1, 5, 10, 15];

var doubles = numbers.map(function (x) {
  return x * 2;
});
console.log(doubles);

• Y el otro Map([…]) es una estructura que esta diseñada para guardar pares clave-valor, que no acepta repetidos en sus key/clave.

const miMapa = new Map(); //Creamos dicho elemento
miMapa.set("clave1", "valor1");
miMapa.set("clave2", "valor2");
miMapa.set("clave3", "valor1");
miMapa.set("clave3", "valor6");
miMapa.set("clave4", "valor2");
console.log(miMapa);
console.log(miMapa.get("clave3"));

//Responde:
Map(4) {
  'clave1' => 'valor1',
  'clave2' => 'valor2',
  'clave3' => 'valor6',
  'clave4' => 'valor2'
}
valor6

Ese seria mi aporte, espero no esté muy mal y a alguien le sirva 😃

/*sirve para manejar errores, si no pasa la primera opcion, sucedera la segunda */
/*usare promesas para que todo el codigo se pueda ejecutar, si no, no lo hace */

function primerTry() {
    return new Promise((resolve) => {
        try {
            resolve(hello());
        } catch (error) {
            console.log(error);
        }
    })
}
primerTry().then(resolve => console.log(resolve));


function segundoTry() {
    return new Promise((resolve) => {
        try {
            resolve(anotherFunction());
        } catch (error) {
            throw new Error("madafacka");
        }
    })
}
segundoTry().then(resolve => console.log(resolve));


function thisFunctionIsGonnaWork() {
    console.log("************this works************");
}

try {
    thisFunctionIsGonnaWork();
} catch (error) {
    console.log(error);
}

Mi resumen:

// Con fromEntries ES10,se puede transformar un array de arrays a un objeto

const entries = new Map ([["name", "Oscar"], ["age", 24]]);
    console.log(entries);
    console.log(Object.fromEntries(entries));

    // Map(2) { 'name' => 'Oscar', 'age' => 24 }
    // { name: 'Oscar', age: 24 }

    //otro ejemplo sin Map
const entrie = [
    ["name", "Vale"],
    ["age", 43],
  ];
  console.log("Array original", entrie);
  // Array origintal [ [ 'name', 'Vale' ], [ 'age', 43 ] ]
  console.log("Array transformado a object", Object.fromEntries(entrie));
  // Array transformado a object { name: 'Vale, age: 43 }

// parámetro catch puede ser opcional (Manejo de errores)
//puedo hacer que lo muestre

try {
    hello ();
} catch (error) {
    console.log(error);
}
// ReferenceError: hello is not defined
//     at Object.<anonymous> (c:\Users\Usuario\ECMA-Vale\js\CursoEcmaScript\src\tempCodeRunnerFile.js:2:5)
//     (...)

//puedo hacer que no lo muestre y personalizarlo

try {
    onotherFn();
} catch {
    console.log("esto es un error")
}
//CUIDADO!!! En este último caso no sabré qué está pasando.
//No sabré el motivo por el cual pasó a catch

https://github.com/techwithulises/javascript/commit/1442267b30d74200c8019d5475c65866a7acb770

Apunte en Notion

Link: https://pogolo.notion.site/25-ES10-try-catch-y-fromEntries-b4d842164b5b4773830834de7ae6bef6