Erros personalizados, estendendo o erro

Quando desenvolvemos alguma coisa, muitas vezes precisamos de nossas próprias classes de erro para refletir coisas específicas que podem errar em nossas tarefas. Para erros nas operações de rede, podemos precisar HttpError, para operações de banco de dados , para operações de pesquisa NotFoundError, etc.

Os nossos erros devem suportar propriedades de erro básicas, comomessage,namee, de preferência,stack. Mas eles também podem ter outras propriedades, por exemplo, objetosHttpErrorPode ter uma propriedadestatusCodecom um valor como ou403ou .

javascript permite que você use throw Com qualquer argumento, então tecnicamente nossas aulas de erro personalizadas não precisam herdar de Error. Mas se herdarmos, então é possível usar obj instanceof Error para identificar erros de objetos. Então é melhor herdar dele.

Como o aplicativo cresce, nossos próprios erros formam naturalmente uma hierarquia. Por exemplo, HttpTimeoutError pode herdar de HttpError e assim por diante.

Erro de extensão

Como um exemplo, considere uma função readUser(json) Que deve ler JSON com os dados do usuário.

Aqui está um exemplo de como um válido:

let json = `{ "name": "John", "age": 30 }`;

Internamente, usaremos JSON.parse. Se você receber mal formado, então derrame SyntaxError. Mas mesmo se está sintaticamente correto, isso não significa que seja um usuário válido, certo? Você pode perder os dados necessários. Por exemplo, você pode não ter propriedades de nome e idade que são essenciais para nossos usuários.

Nossa função readUser(json) não só lerá JSON, mas verificará (“” Validar “) os dados. Se não houver campos obrigatórios, ou o formato estiver incorreto, ele será um erro. E isso não é um” syntaxError “, porque os dados estão sintaticamente corretos, mas outro tipo de erro. Vamos chamá-lo ValidationError e criar uma classe para ela. Um erro desse tipo também deve trazer as informações sobre o campo mineral.

Nossa classe ValidationError deve herdar da classe incorporada Error

esse tipo é incorporado, mas aqui está o seu código aproximado para que possamos entender o que estamos estendendo:

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") { // (*)// ...

. O blococatchSabe apenas como manipular erros de validação e sintaxe, outros tipos (devido a um erro tipográfico no código ou outros estranhos) deve falhar.

adicional herança

classe ValidationError é muito genérico. Muitas coisas podem dar errado.A propriedade pode estar ausente ou pode estar em um formato incorreto (como um valor de string para age). Vamos fazer uma classe mais concreta PropertyRequiredError, exatamente para propriedades ausentes. Ele terá informações adicionais sobre a propriedade ausente.

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 classe PropertyRequiredError é fácil de usar: só precisamos passar o nome da propriedade: new PropertyRequiredError(property) . O message é gerado pelo construtor.

Por favor, note que this.name no construtor PropertyRequiredError é atribuído manualmente novamente. Isso pode se tornar um pouco tedioso: Atribuir this.name = <class name> em cada classe de erro personalizada. Podemos evitá-lo, tornando nosso próprio “erro básico” que atribui this.name = this.constructor.name. E, em seguida, herda todos os nossos erros personalizados.

Vamos chamá-lo MyError Aqui está o código com MyError e outras classes personalizadas, erro simplificado:

class MyError extends Error { constructor(message) { super(message); this.name = this.constructor.name; }}class ValidationError extends MyError { }class PropertyRequiredError extends ValidationError { constructor(property) { super("sin propiedad: " + property); this.property = property; }}// name es incorrectoalert( new PropertyRequiredError("campo").name ); // PropertyRequiredError

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; }}