Classe di errore personalizzata in TypeScript

Question

Vorrei creare la mia classe di errore in TypeScript, estendendo il core Error per fornire una migliore gestione degli errori e rapporti personalizzati. Ad esempio, desidero creare una classe HttpRequestError con url, response e body passati nel suo costruttore, che risponde con richiesta Http a http://example.com non riuscita con codice di stato 500 e messaggio: Qualcosa è andato storto e traccia dello stack corretta.

Come estendere la classe di errore di base in TypeScript? Ho già trovato post in SO: How do I extend a host object (e.g. Error) in TypeScript ma questa soluzione non funziona per me. Uso TypeScript 1.5.3

Qualche idea?

Answer 1

Fino a quando rotola intorno a 1,6, ho appena creato le mie classi estendibili.

class BaseError { 
    constructor() { 
     Error.apply(this, arguments); 
    } 
} 

BaseError.prototype = new Error(); 

class HttpRequestError extends BaseError { 
    constructor (public status: number, public message: string) { 
     super();  
    } 
} 

var error = new HttpRequestError(500, 'Server Error'); 

console.log(
    error, 
    // True 
    error instanceof HttpRequestError, 
    // True 
    error instanceof Error 
); 

Answer 2

Sto usando dattiloscritto 1.8 e questo è come uso le classi di errore personalizzate:

UnexpectedInput.ts

class UnexpectedInput extends Error { 

    public static UNSUPPORTED_TYPE: string = "Please provide a 'String', 'Uint8Array' or 'Array'."; 

    constructor(public message?: string) { 
    super(message); 
    this.name = "UnexpectedInput"; 
    this.stack = (<any> new Error()).stack; 
    } 

} 

export default UnexpectedInput; 

MyApp.ts

import UnexpectedInput from "./UnexpectedInput"; 

... 

throw new UnexpectedInput(UnexpectedInput.UNSUPPORTED_TYPE); 

Per le versioni dattiloscritto di età superiore a 1.8, è necessario dichiarare Error:

export declare class Error { 
    public message: string; 
    public name: string; 
    public stack: string; 
    constructor(message?: string); 
} 

Answer 3

dattiloscritto 2.1 ha avuto una rottura cambiamenti per quanto riguarda Estendere built-in come errore.

Dal TypeScript breaking changes documentation

class FooError extends Error { 
    constructor(m: string) { 
     super(m); 

     // Set the prototype explicitly. 
     Object.setPrototypeOf(this, FooError.prototype); 
    } 

    sayHello() { 
     return "hello " + this.message; 
    } 
} 

Quindi è possibile utilizzare:

let error = new FooError("msg"); 
if(error instanceof FooError){ 
    console.log(error.sayHello(); 
}