Técnicas JavaScript silenciosas para indicar fallas

error-handling assert

Question

¿Cuál sería una buena forma de informar errores en JavaScript en lugar de confiar en valores nulos y no definidos cuando se producen errores y una función no puede avanzar? Puedo pensar en tres enfoques:

1. hacer nada
2. lanzar una excepción
3. afirmar

Aquí hay un escenario de ejemplo simple: una función que acredita una cuenta de usuario con el monto ingresado. La función de credit es parte de un objeto de Account .

Aquí está la solución ingenua.

function credit(amount) {
   this.balance += amount;
}

Un problema importante con este enfoque es la información no válida. Arreglemos esto y usemos un valor de retorno para indicar que la operación falló.

function credit(amount) {
    if(!isInt(amount)) {
        return false;
    }
    this.balance += amount;
}

Esta es una mejora con respecto a la anterior, pero el código del cliente deberá verificar el valor de retorno para garantizar que la operación tuvo éxito. Hacer esto para básicamente cada método en el sistema puede volverse engorroso.

if(!johnDoe.credit(100)) {
    // do some error handling here
}

Un tercer enfoque, similar al segundo, es arrojar una excepción. Como nosotros mismos estamos lanzando la excepción, podríamos lanzar un tipo específico de excepción en lugar de uno general.

function credit(amount) {
    if(!isInt(amount)) {
        throw new InvalidAmountError(amount);
    }
    this.balance += amount;
}

Un cuarto enfoque similar a tirar excepciones es usar aserciones en tu código. Una deficiencia en comparación con el enfoque anterior es que, dado que la afirmación es genérica, perdemos la capacidad de lanzar excepciones personalizadas. Sin embargo, aún es posible pasando el objeto para lanzar en cada llamada afirmativa.

function credit(amount) {
    assert(!isInt(amount), "Amount to credit is not an integer");
    this.balance += amount;
}

Una función de assert global es fácil de escribir y hace que el código sea un poco más corto.

function assert(value, message) {
    if(value !== true) {
        throw new AssertionError(message);
    }
}

function AssertionError(message) {
    this.message = message;
}

AssertionError.prototype.toString = function() {
    return ''AssertionError: '' + this.message;
}

De estos enfoques, ¿cuál sería una buena manera de lidiar con valores inesperados y caminos infelices? ¿Hay algún otro enfoque no mencionado aquí que podría ser útil?

Answer 1

Una deficiencia en comparación con el enfoque anterior es que, dado que la afirmación es genérica, perdemos la capacidad de lanzar excepciones personalizadas

No necesariamente:

function assert(value,message,Exctype) {
    if(value !== true) throw new Exctype(message);
}

Los constructores son funciones. Las funciones son valores de primera clase. Siéntase libre de pasarlos.

Answer 2

Considere un marco de registro del lado del cliente para informar errores, como Log4js . Uno puede registrar mensajes (es decir, información, depuración, advertencia, error) en el navegador o persistir mensajes al servidor a través de Ajax, dependiendo de la aplicación.

El sitio Log4js también proporciona una lista de otros marcos de registro de JavaScript .

Un buen enfoque, utilizando su ejemplo de excepción personalizado, sería arrojar la excepción y registrar el error como mejor le parezca.