JavaScript técnicas antirruido para indicar el error

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 continuar. No puedo pensar en tres enfoques:

1. no hacen nada
2. lanzar una excepción
3. afirman

He aquí un ejemplo sencillo escenario - una función que acredita una cuenta de usuario con la cantidad aprobada en. 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 son los datos no válidos. 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 al anterior, pero el código de cliente tendrá que comprobar el valor de retorno para asegurar 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 lanzar 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 su 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 global assert es fácil de escribir y hace que el código 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 manejar valores inesperados y caminos infelices? ¿Hay algún otro enfoque no mencionado aquí que podría 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, depurar, 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 un list of other JavaScript logging frameworks.

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

Answer 2

Un defecto en comparación con el enfoque anterior es que, dado que la aserción es genérica, se pierde la capacidad de lanzar excepciones personalizadas

No necesariamente:

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

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