Uso apropiado de errores

Estoy usando TypeScript para un proyecto razonablemente grande, y me pregunto cuál es el estándar para el uso de Errors. Por ejemplo, supongamos que entrego una excepción de índice fuera de límites en Java:

throw new IndexOutOfBoundsException();

¿Sería la declaración equivalente en TypeScript:

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

¿De qué otras maneras podría lograr esto? ¿Cuál es el estándar aceptado?

Alguien publicó este enlace en el MDN en un comentario, y creo que fue muy útil . Describe cosas como ErrorTypes muy a fondo.

EvalError --- Crea una instancia que representa un error que ocurre con respecto a la función global eval ().

InternalError --- Crea una instancia que representa un error que ocurre cuando se produce un error interno en el motor de JavaScript. Por ejemplo, "demasiada recursión".

RangeError --- Crea una instancia que representa un error que ocurre cuando una variable numérica o parámetro está fuera de su rango válido.

ReferenceError --- Crea una instancia que representa un error que ocurre al desreferenciar una referencia no válida.

SyntaxError --- Crea una instancia que representa un error de sintaxis que se produce al analizar el código en eval ().

TypeError --- Crea una instancia que representa un error que ocurre cuando una variable o parámetro no es de un tipo válido.

URIError --- Crea una instancia que representa un error que ocurre cuando encodeURI () o decodeURI () pasan parámetros no válidos.

Se utiliza la convención para fuera de rango en JavaScript RangeError. Para verificar el tipo, use if / else + instanceofcomenzando por el más específico al más genérico

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

Solución simple para emitir y mostrar mensajes por Excepción.

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

Precaución

Lo anterior no es una solución si no sabemos qué tipo de error puede emitirse desde el bloque. En tales casos, se deben usar protectores de tipo y se debe realizar un manejo adecuado para el error adecuado: eche un vistazo a la respuesta @Moriarty.

No te olvides de las declaraciones de cambio:

• Asegure el manejo con default.
• instanceof puede coincidir en superclase.
• ES6 constructorcoincidirá en la clase exacta.
• Más fácil de leer.

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();