DanLevy.net

Quiz:Dominio Avanzado de Errores en JS

¿Tus excepciones son realmente excepcionales?

¿Crees que dominas los errores de JavaScript al detalle?

1. 

Sorpresas de Serialización

¿Qué devuelve JSON.stringify(error)?

const error = new Error('Oops');
console.log(JSON.stringify(error));

Los objetos Error tienen propiedades no enumerables (message, name, stack), por lo que JSON.stringify() devuelve {}. Esto es una trampa frecuente al enviar errores en respuestas de API. Usa JSON.stringify(error, Object.getOwnPropertyNames(error)) o crea un objeto plano en su lugar.

2. 

Sorpresas de Serialización

¿Cuál es la diferencia entre estos dos?

const err = new Error('Test');
console.log(err);
console.log(JSON.stringify(err));

console.log(err) muestra el error con su mensaje y traza de pila porque la consola tiene un manejo especial para objetos Error. JSON.stringify(err) devuelve '{}' porque las propiedades de Error no son enumerables. Esta diferencia confunde a muchos desarrolladores al depurar APIs.

3. 

Trucos de verificación de tipos

¿Cuáles son los resultados de estas comprobaciones?

class CustomError extends Error {}
const err = new CustomError('test');


console.log(err instanceof CustomError);
console.log(err instanceof Error);
console.log(err instanceof Object);

Los tres devuelven true. CustomError extiende a Error, que a su vez extiende a Object. El operador instanceof verifica toda la cadena de prototipos, por lo que una instancia de CustomError también es una instancia de Error y Object.

4. 

Trucos de verificación de tipos

¿Qué ocurre con instanceof Error entre iframes?

// In iframe:
const iframeError = new Error('test');
// In parent window:
console.log(iframeError instanceof Error);

instanceof puede devolver false entre diferentes contextos de ejecución (iframes, workers) porque cada contexto tiene su propio constructor Error. Usa Object.prototype.toString.call(obj) === '[object Error]' para una detección fiable de errores entre contextos.

5. 

Lanzando No‑Errores

¿Qué ocurre cuando lanzas una cadena?

try {
  throw "Oops!";
} catch (e) {
  console.log(e instanceof Error);
  console.log(typeof e);
}

JavaScript permite lanzar cualquier valor. Aquí, e instanceof Error es false y typeof e es "string". Esto puede romper el código de manejo de errores que asume que todas las excepciones capturadas son objetos Error. Siempre lanza instancias de Error para una mejor depuración.

6. 

Errores personalizados

¿Cuál es el valor de err.name?

class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
  }
}
const err = new CustomError('test');
console.log(err.name);

err.name es "CustomError" porque this.constructor.name devuelve el nombre de la clase. Asignar this.name = this.constructor.name es un patrón común para garantizar que las clases de error personalizadas muestren el nombre correcto en trazas de pila y mensajes de error.

7. 

Errores Personalizados

¿Cuál es la salida sin establecer name?

class MyError extends Error {
  // No constructor or name setting
}
const err = new MyError('test');
console.log(err.name);

Sin establecer explícitamente this.name, el error hereda la propiedad name predeterminada de la clase Error, que es "Error". Por eso las clases de error personalizadas siempre deben establecer this.name = this.constructor.name en su constructor.

8. 

Causa del Error

¿Qué devuelve wrapper.cause.message?

const original = new Error('Original error');
const wrapper = new Error('Wrapper',
  { cause: original }
);
console.log(wrapper.cause.message);

Error.cause (ES2022) permite encadenar errores para preservar el contexto del error original. wrapper.cause hace referencia al error original, por lo que wrapper.cause.message devuelve "Error original". Esto es útil para envolver errores de bajo nivel con un contexto de nivel superior.

9. 

Rastros de Pila

¿Qué hace Error.captureStackTrace?

function createError(msg) {
  const err = new Error(msg);
  Error.captureStackTrace(err, createError);
  return err;
}
const error = createError('test');

Error.captureStackTrace (V8/Node.js) elimina la función especificada (createError) del rastro de pila, haciendo que las funciones fábrica de errores sean invisibles para los usuarios finales. Esto genera rastros de pila más limpios que apuntan al lugar donde se llamó a la fábrica, no a la propia fábrica.

10. 

Plantillas de mensajes

¿Cuál es el mensaje de error?

function validate(value) {
  if (!value) {
    throw new Error(
      `Value ${value} is invalid`
    );
  }
}
try {
  validate(undefined);
} catch (e) {
  console.log(e.message);
}

Las plantillas de texto convierten undefined a la cadena "undefined" durante la interpolación. El mensaje de error se vuelve "Value undefined is invalid". Para mensajes más claros, considera usar value ?? 'null' o verificaciones similares antes de la interpolación.

11. 

Trucos de API

¿Qué se envía al cliente?

// Express.js route
app.get('/api/data', (req, res) => {
  const error = new Error('Database failed');
  res.json({ error });
});

res.json() usa internamente JSON.stringify(), por lo que el objeto Error se convierte en {}. El cliente recibe {"error":{}}. Para solucionarlo, usa res.json({ error: error.message }) o res.json({ error: { message: error.message, name: error.name } }).

12. 

Errores Asíncronos

¿Qué puede aceptar Promise.reject()?

Promise.reject('string').catch(e =>
  console.log(typeof e)
);
Promise.reject({code: 404}).catch(e =>
  console.log(e.code)
);
Promise.reject(42).catch(e =>
  console.log(e)
);

Al igual que throw, Promise.reject() acepta cualquier valor: cadenas, objetos, números, etc. Esto imprime "string", 404 y 42. Siempre verifica el tipo de los valores capturados en las cadenas de promesas, sobre todo al trabajar con código de terceros que podría rechazar con valores que no sean Error.

13. 

Propiedades de error

¿Qué tan fiables son error.code y error.errno?

const fs = require('fs');
fs.readFile('missing.txt', (err, data) => {
  if (err) {
    console.log(err.code);    // 'ENOENT'
    console.log(err.errno);   // -2
  }
});

Propiedades como code y errno son específicas del entorno (Node.js en este caso) y no forman parte del objeto Error estándar. Los errores del navegador no tendrán estas propiedades. Siempre verifica su existencia: if (err.code === 'ENOENT') en lugar de asumir que existen.

14. 

Límites de Error

¿Qué devuelven estas comprobaciones?

const fakeError = {
  name: 'Error',
  message: 'Fake error',
  stack: 'fake stack'
};


console.log(fakeError instanceof Error);
console.log(Object.prototype.toString.call(
  fakeError
) === '[object Error]');

instanceof Error devuelve false porque el objeto no fue creado por el constructor Error. Object.prototype.toString.call() también devuelve false (devuelve '[object Object]') porque verifica la ranura interna [[Class]]. Ambos métodos identifican correctamente este objeto como un error falso.

Domina el Arte del Manejo de Errores

Desde los escollos de la serialización hasta los fallos de instanceof entre contextos, estos conceptos avanzados son lo que separa a los desarrolladores junior de los profesionales experimentados.

¿Listo para más desafíos? Consulta nuestra colección completa de quizzes para encontrar más acertijos sobre JavaScript, algoritmos y mucho más.

Loading comments...