Uso corretto degli errori

Sto usando TypeScript per un progetto abbastanza grande, e mi chiedo quale sia lo standard per l'uso di Errors. Ad esempio, supponiamo di consegnare un indice fuori dai limiti in Java:

throw new IndexOutOfBoundsException();

L'istruzione equivalente in TypeScript sarebbe:

throw new Error("Index Out of Bounds");

In quali altri modi posso farlo? Qual è lo standard accettato?

Qualcuno ha pubblicato questo link alla MDN in un commento e penso che sia stato molto utile . Descrive cose come ErrorTypes molto accuratamente.

EvalError --- Crea un'istanza che rappresenta un errore che si verifica per quanto riguarda la funzione globale eval ().

InternalError --- Crea un'istanza che rappresenta un errore che si verifica quando viene generato un errore interno nel motore JavaScript. Ad esempio "troppa ricorsione".

RangeError --- Crea un'istanza che rappresenta un errore che si verifica quando una variabile numerica o un parametro è al di fuori del suo intervallo valido.

ReferenceError --- Crea un'istanza che rappresenta un errore che si verifica quando si fa riferimento a un riferimento non valido.

SyntaxError --- Crea un'istanza che rappresenta un errore di sintassi che si verifica durante l'analisi del codice in eval ().

TypeError --- Crea un'istanza che rappresenta un errore che si verifica quando una variabile o un parametro non è di tipo valido.

URIError --- Crea un'istanza che rappresenta un errore che si verifica quando encodeURI () o decodeURI () ricevono parametri non validi.

La convenzione per out of range in JavaScript sta usando RangeError. Per controllare il tipo usa if / else + a instanceofpartire dal più specifico al più generico

try {
    throw new RangeError();
}
catch (e){
    if(e instanceof RangeError){
        console.log('out of range');
    }
}

Soluzione semplice per emettere e mostrare messaggi per eccezione.

try {
  throw new TypeError("Error message");
}
catch (e){
  console.log((<Error>e).message);//conversion to Error type
}

Attenzione

Sopra non è una soluzione se non sappiamo che tipo di errore può essere emesso dal blocco. In tali casi, è necessario utilizzare protezioni di tipo e maneggiare in modo corretto l'errore corretto. Dai un'occhiata alla risposta @Moriarty.

Non dimenticare le istruzioni switch:

• Garantire la gestione con default.
• instanceof può abbinare su superclasse.
• ES6 constructorcorrisponderà sulla classe esatta.
• Più facile da leggere.

function handleError() {
    try {
        throw new RangeError();
    }
    catch (e) {
        switch (e.constructor) {
            case Error:      return console.log('generic');
            case RangeError: return console.log('range');
            default:         return console.log('unknown');
        }
    }
}

handleError();