Overview
Divide by Zero is considered a special case by most programming languages. Any number can never be divided by zero because its result is indeterminate. This shot covers how JavaScript handles a Divide by Zero expression.
How do programming languages handle it?
Most programming languages throw an exception
at run time. For handling the exception, they use a try-catch block.
How does JavaScript handle it?
JavaScript acts differently from other programming languages. When it encounters any Divide by Zero expression, it doesn’t throw an exception.
Now, the question may arise of why JavaScript behaves differently and why it doesn’t throw any exception.
The possible reasons for this are as follows:
- JavaScript is a dynamically typed language, and it performs
type-coercion
. - Throwing exceptions at runtime is inconvenient for JavaScript.
So, how does JavaScript evaluate these expressions?
Let’s see that in the following example.
Example
// Declare and initialize a number with 0 const num1 = 0; // Declare and initialize a number with a positive integer const num2 = 10; // Declare and initialize a number with a negative integer const num3 = -10; // Divide by zero with a zero console.log["Divide by zero with a zero:", num1 / 0]; // Divide by zero with a positive integer console.log["Divide by zero with a positive integer:", num2 / 0]; // Divide by zero with a negative integer console.log["Divide by zero with a negative integer:", num3 / 0];
Explanation
- Line 2: We declare and initialize a variable
num1
with 0. - Line 5: We declare and initialize a variable
num2
with a positive value. - Line 8: We declare and initialize a variable
num3
with a negative value. - Line 11: We divide
the variable
num1
with 0, and print the output on the console. - Line 14: We divide the variable
num2
with 0, and print the output on the console. - Line 17: We divide the variable
num3
with 0, and print the output on the console.
Output
The output of the code in JavaScript is as follows:
- Dividing the number 0 by 0 returns NaN.
- Dividing the positive number by 0 returns Infinity.
- Dividing the negative number by 0 returns -Infinity.
RELATED TAGS
javascript
divide by zero
js
communitycreator
CONTRIBUTOR
Shubham Singh Kshatriya
The best way is contextual. But here's the easiest:
function myFunction[ input ]{
input = 0 ? 0.0001 : input; // same as if[ input == 0 ]{ input = 0.0001; }
return 1 / input;
}
Basically if the input is zero, turn it into a very small number before using as a denominator. Works great for integers, since after your division you can round them back down.
A couple caveats prevent this from being universal:
- It could cause false positives if your input accepts really small numbers
- It won't trigger any error-handling code, if you need to do something special if zero is entered
So it's best for general-purpose, non-critical cases. For example, if you need to return the result of a complex calculation and don't care if the answer is accurate to N digits [determined by 0.0001 vs. 0.00000001, etc.]; you just don't want it to break on a divide-by-zero.
As another answer suggested, you could also create a reusable global function.
function divisor[ n ]{ return [ n = 0 ? 0.0001 : n ]; }
function myFunction[ input ]{ return 1 / divisor[ input ]; }
Possible improvements:
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; }
}
This would take any value [null, number, string,
object] and if invalid or zero, return the failsafe zero-like value. It would also coerce the output to a number just in case it was a string and you were doing something odd. All this would ensure that your divisor function always worked. Finally, for cases where you wanted to handle such errors yourself, you could set the second parameter to true and use a try/catch
.