personalizados, estendéndose erro

Cando desenvolver algo, que moitas veces precisan de nosas propias clases de erro para reflectir cousas específicas que poden dar mal nas nosas tarefas. Para erros nas operacións de rede, podemos necesitar HttpError, para operacións de base de datos , para operacións de busca NotFoundError, etc.

Os nosos erros deben soportar propiedades de erro básicas como message, name e, preferentemente, stack. Pero tamén poden ter outras propiedades propias, por exemplo, obxectos HttpError pode ter unha propiedade statusCode cun valor como ou 403 ou 500.

JavaScript permítelle usar con calquera argumento, polo que técnicamente as nosas clases de erro personalizadas non necesitan herdar de Error. Pero se herdamos, entón é posible usar obj instanceof Error para identificar o erro dos obxectos. Entón é mellor herdar del.

A medida que a aplicación crece, os nosos propios erros forman naturalmente unha xerarquía. Por exemplo, HttpTimeoutError pode herdar de HttpError e así por diante.

Extensión de erro

Como exemplo, considere unha función que debería ler JSON cos datos do usuario.

Aquí está un exemplo de como pode ser válido:

Internamente, imos usar JSON.parse. Se recibe mal formado, entón Shed SyntaxError. Pero aínda que é sintácticamente correcto, iso non significa que sexa un usuario válido, non? Pode perder os datos necesarios. Por exemplo, pode que non teña nome e propiedades de idade que son esenciais para os nosos usuarios.

A nosa función non só lerá JSON, senón que verificará (” Validar “) os datos. Se non hai campos obrigatorios ou o formato é incorrecto, entón é un erro. E iso non é un” sintaxeiro “, porque os datos son sintácticamente correctos, pero outro tipo de erro. Chamarémolo ValidationError e crear unha clase para el. Un erro dese tipo tamén debe levar a información sobre o campo mineral.

A nosa clase ValidationError debe herdar da clase integrada Error.

Este tipo está incorporado, pero aquí está o seu código aproximado para que poidamos entender o que estamos ampliando:

// El "pseudocódigo" para la clase Error incorporada definida por el propio JavaScriptclass Error { constructor(message) { this.message = message; this.name = "Error"; // (diferentes nombres para diferentes clases error incorporadas) this.stack = <call stack>; // no estándar, pero la mayoría de los entornos lo admiten }}

agora imos herdar ValidationError e probalo en acción:

class ValidationError extends Error { constructor(message) { super(message); // (1) this.name = "ValidationError"; // (2) }}function test() { throw new ValidationError("Vaya!");}try { test();} catch(err) { alert(err.message); // Vaya! alert(err.name); // ValidationError alert(err.stack); // una lista de llamadas anidadas con números de línea para cada una}

class ValidationError extends Error { constructor(message) { super(message); this.name = "ValidationError"; }}// Usofunction readUser(json) { let user = JSON.parse(json); if (!user.age) { throw new ValidationError("Sin campo: age"); } if (!user.name) { throw new ValidationError("Sin campo: name"); } return user;}// Ejemplo de trabajo con try..catchtry { let user = readUser('{ "age": 25 }');} catch (err) { if (err instanceof ValidationError) { alert("Dato inválido: " + err.message); // Dato inválido: sin campo: nombre } else if (err instanceof SyntaxError) { // (*) alert("Error de sintaxis JSON: " + err.message); } else { throw err; // error desconocido, vuelva a lanzarlo (**) }}

// ...// en lugar de (err instanceof SyntaxError)} else if (err.name == "SyntaxError") { // (*)// ...

é moito mellor, porque en O futuro que imos ampliar , imos facer subtipos del, como . E controlinstanceofseguirá traballando para novas clases herdadas. Entón que vai ao futuro.

Tamén é importante que, se catch busca un erro descoñecido, entón volva a tiralo na liña (**). O bloque catch só sabe como xestionar erros de validación e sintaxe, outros tipos (debido a un erro tipográfico no código ou noutros estraños) debe fallar.

adicional Herdanza

clase ValidationError é moi xenérica. Moitas cousas poden ir mal.A propiedade pode estar ausente ou pode estar nun formato incorrecto (como valor de cadea para age). Imos facer unha clase de formigón máis , exactamente para as propiedades ausentes. Terá información adicional sobre a propiedade que falta.

class ValidationError extends Error { constructor(message) { super(message); this.name = "ValidationError"; }}class PropertyRequiredError extends ValidationError { constructor(property) { super("Sin propiedad: " + property); this.name = "PropertyRequiredError"; this.property = property; }}// Usofunction readUser(json) { let user = JSON.parse(json); if (!user.age) { throw new PropertyRequiredError("age"); } if (!user.name) { throw new PropertyRequiredError("name"); } return user;}// Ejemplo de trabajo con try..catchtry { let user = readUser('{ "age": 25 }');} catch (err) { if (err instanceof ValidationError) { alert("Dato inválido: " + err.message); // Dato inválido: Sin propiedad: name alert(err.name); // PropertyRequiredError alert(err.property); // name } else if (err instanceof SyntaxError) { alert("Error de sintaxis JSON: " + err.message); } else { throw err; // error desconocido, vuelva a lanzarlo }}

A nova clase é fácil de usar: só necesitamos pasar o nome da propiedade: new PropertyRequiredError(property) .. O message lexible é xerado polo constructor.

Por favor, teña en conta que this.name no constructor PropertyRequiredError é asignado de novo manualmente. Isto pode chegar a ser un pouco tedioso: asignar this.name = <class name> en cada clase de erro personalizado. Podemos evitalo facendo que a nosa propia clase “Erro básico” que asigne this.name = this.constructor.name e despois herdar todos os nosos erros personalizados.

Imos chamalo MyError.

Aquí está o código con MyError e outras clases personalizadas, Erro simplificado:

try { ... readUser() // la fuente potencial de error ...} catch (err) { if (err instanceof ValidationError) { // manejar errores de validación } else if (err instanceof SyntaxError) { // manejar errores de sintaxis } else { throw err; // error desconocido, vuelva a lanzarlo }}

class ReadError extends Error { constructor(message, cause) { super(message); this.cause = cause; this.name = 'ReadError'; }}class ValidationError extends Error { /*...*/ }class PropertyRequiredError extends ValidationError { /* ... */ }function validateUser(user) { if (!user.age) { throw new PropertyRequiredError("age"); } if (!user.name) { throw new PropertyRequiredError("name"); }}function readUser(json) { let user; try { user = JSON.parse(json); } catch (err) { if (err instanceof SyntaxError) { throw new ReadError("Error de sintaxis", err); } else { throw err; } } try { validateUser(user); } catch (err) { if (err instanceof ValidationError) { throw new ReadError("Error de validación", err); } else { throw err; } }}try { readUser('{json malo}');} catch (e) { if (e instanceof ReadError) { alert(e); // Error original: SyntaxError: inesperado token b en JSON en la posición 1 alert("Error original: " + e.cause); } else { throw e; }}