La mejor manera de prevenir/manejar la división por 0 en javascript

divide-by-zero

Question

¿Cuál es la mejor manera de evitar la división por 0 en javascript que está aceptando entradas de usuario? Si no hay una manera particular de lograr esto, ¿cuál sería la mejor manera de manejar una situación de este tipo para evitar que se ejecuten otros scripts?

Cualquier información es muy apreciada.

Answer 1

¿Cuál sería la mejor manera de manejar tal situación para no evitar que se ejecuten otros scripts?

La división por cero no parece impedir que otros scripts se ejecuten en JavaScript:

var a = 20;
var b = 0;
var result = a/b;
console.log(result); // returns Infinity

Si desea que ocurra algo diferente en caso de división por cero, puede utilizar

function divideIfNotZero(numerator, denominator) {
if (denominator === 0 || isNaN(denominator)) {
return null;
}
else {
return numerator / denominator;
}
}

Answer 2

Para evitar la ejecución (no deseada)

1. Siempre verifique los comentarios y / o resultados críticos del usuario.
2. Usa lógica y / o devoluciones de llamada que puedes evitar para ejecutar
3. En formularios HTML, etc., puede utilizar, por ejemplo, return false; como valor para detener la sumisión.

Answer 3

¿Por qué no comprobar simplemente si el denominador es cero?

if(x != 0) z = y / x;

También puedes comprobar si el resultado es Infinity:

3 / 0 == Infinity

Resultados en true ;

(Solo probado en cromo).

Answer 4

De la parte superior de mi cabeza podrías:

1. Verifique la entrada del usuario para ver si el denominador es cero (o se evalúa como cero, dependiendo de lo que realmente haga su script).
2. Verifique si el resultado de la acción es isFinite() y si no lo es, manéjelo apropiadamente.

Answer 5

Espero que esto sea útil

(denominator != 0 ? nominator/denominator : Infinity)

o cualquier valor que quieras poner al final.

Saludos.

Answer 6

La mejor manera es contextual. Pero aquí está lo más fácil:

function myFunction( input ){
input = 0 ? 0.0001 : input; // same as if( input == 0 ){ input = 0.0001; }
return 1 / input;
}

Básicamente, si la entrada es cero, conviértala en un número muy pequeño antes de usarlo como denominador. Funciona muy bien para los enteros, ya que después de la división puedes redondearlos hacia abajo.

Un par de advertencias impiden que esto sea universal:

• Podría causar falsos positivos si su entrada acepta números realmente pequeños
• No activará ningún código de manejo de errores, si necesita hacer algo especial si se ingresa cero

Así que es mejor para casos generales, no críticos. Por ejemplo, si necesita devolver el resultado de un cálculo complejo y no le importa si la respuesta es precisa para N dígitos (determinado por 0.0001 frente a 0.00000001, etc.); simplemente no quieres que se rompa en una división por cero.

Como sugirió otra respuesta, también podría crear una función global reutilizable.

function divisor( n ){ return ( n = 0 ? 0.0001 : n ); }
function myFunction( input ){ return 1 / divisor( input ); }

Posibles mejoras:

function divisor( n, orError ){
if( typeof n == ''undefined'' || isNaN( n ) || !n ){
if( orError ){ throw new Error( ''Divide by zero.'' ); }
return 0.000000000000001;
}else{ return 0 + n; }
}

Esto tomaría cualquier valor (nulo, número, cadena, objeto) y si no es válido o cero, devuelve el valor cero a prueba de fallos. También forzaría la salida a un número en caso de que fuera una cadena y estuvieras haciendo algo extraño. Todo esto aseguraría que su función de divisor siempre funcionó. Finalmente, para los casos en los que quisiera manejar tales errores usted mismo, podría establecer el segundo parámetro en verdadero y usar un try/catch .

Answer 7

Un poco diferente a detener la ejecución, pero el operador ternario es una forma bastante elegante de personalizar la asignación de variables.

var one = 1,
zero = 0,
customValue = 1;
var quotient = zero===0 ? customValue : one / zero;

De esta manera, al configurar la variable personalizada para el entero de su elección, puede esperar un resultado predecible cuando se produce la división por cero.

Answer 8

No hay manera de hacer eso con los operadores normales / y /= .

La mejor manera de hacer lo que quieres es con guardias:

function notZero(n) {
n = +n; // Coerce to number.
if (!n) { // Matches +0, -0, NaN
throw new Error(''Invalid dividend '' + n);
}
return n;
}

y luego hacer división como

numerator / notZero(denominator)

Alternativamente, siempre puede guardar la salida

function dividend(numerator, denominator) {
var quotient = numerator / denominator;
if (quotient !== quotient) { throw new Error(numerator + " / " + denominator); }
return quotient;
}

pero eso pierde la legibilidad y expresividad de /= .