Técnicas antideslícalas de JavaScript para indicar el fracaso.

Question

¿Cuál sería una buena manera de informar errores en JavaScript en lugar de confiar en NULLS, y no está definido cuando se producen errores y una función no puede continuar adelante? Puedo pensar en tres enfoques:

1. no hacer nada
2. lanzar una excepción
3. afirmando

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

Aquí está la solución ingenua.

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

Un problema importante con este enfoque no es válido los datos. Vamos a arreglarlo, 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 en la anterior, pero el código del cliente deberá verificar el valor de devolución para asegurarse de que la operación haya tenido éxito. Hacer esto por básicamente, cada método en el sistema puede ser engorroso.

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

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

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

Un cuarto enfoque similar a la lanzamiento de excepciones es usar afirmaciones en su código. Una deficiencia en comparación con el enfoque anterior es que, dado que el afirmación es genérico, perdemos la capacidad de lanzar excepciones personalizadas. Aunque todavía es posible pasando el objeto para lanzar en cada llamada de afirmación.

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

Una función global assert 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, lo que sería una buena manera de lidiar con valores inesperados e infelices caminos. ¿Hay algún otro enfoque que no se mencione aquí que pueda ser útil?

Answer 1

Considere un marco de registro del lado del cliente para informar errores, como log4js .Uno puede registrar mensajes (es decir, información, depuración, advertir, 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, el uso de su ejemplo de excepción personalizado, sería lanzar la excepción y registrar el error como se encuentra en forma.

Answer 2

Un deficiencia en comparación con lo anterior El enfoque es que ya que el afirmación es genérico, perdemos la capacidad de lanzar Excepciones personalizadas

no necesariamente:

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

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