Can anyone point me to some code to determine if a number in JavaScript is even or odd?
8
32 Answers
Use the below code:
function isOdd(num) { return num % 2;}
console.log("1 is " + isOdd(1));
console.log("2 is " + isOdd(2));
console.log("3 is " + isOdd(3));
console.log("4 is " + isOdd(4));1 represents an odd number, while 0 represents an even number.
11 Comments
T.J. Crowder
Note that this will return
0 or 1 (or NaN if you feed it something that isn't a number and can't be coerced into one), which will work fine for most situations. But if you want a real true or false: return (num % 2) == 1;
Chii
yea good note about the NaN. But usually, you want javascript to be truthy or falsey, which is why i wrote it the way i did.
Abuh
Just to clarify, the modulo operator (%) gives the remainder of a division. So 3%2 would be 3/2, leaving 1 as a remainder, therefore 3%2 will return 1.
nnnnnn
Further to what T.J. said, this will return a fraction if
num isn't an integer. Which will still work if you compare isOdd(1.5)==true (because a fractional value is not equal to true), but it would be better if the function returned true or false as implied by the name "isOdd".
Duncan
You can also do
return !!(num % 2) to get a boolean |
Use the bitwise AND operator.
function oddOrEven(x) {
return ( x & 1 ) ? "odd" : "even";
}
function checkNumber(argNumber) {
document.getElementById("result").innerHTML = "Number " + argNumber + " is " + oddOrEven(argNumber);
}
checkNumber(17);<div id="result" style="font-size:150%;text-shadow: 1px 1px 2px #CE5937;" ></div>If you don't want a string return value, but rather a boolean one, use this:
var isOdd = function(x) { return x & 1; };
var isEven = function(x) { return !( x & 1 ); };
15 Comments
s0d4pop
+1, you're answer definitely beats mine, not to mention that you have the only answer that does not use
X % Y!
Blender
I'm not sure if my test is accurate, but the bitwise AND seems to be 40 times slower than the modulo operator for a fixed number and 2 times slower for a random number: jsperf.com/odd-or-even
nnnnnn
Note that this will return "odd" or "even" for numbers that are not either (e.g., 3.14).
RobG
Or:
function isEven(n){return !(n & 1);}.
David G
@Gnuey Every number is comprised of a series of bits. All odd numbers have the least-significant (rightmost) bit set to 1, all even numbers 0. The
x & 1 checks if the last bit is set in the number (because 1 Is a number with all bits set to 1 except for the least significant bit): If it is, the number is odd, otherwise even. |
You could do something like this:
function isEven(value){
if (value%2 == 0)
return true;
else
return false;
}
6 Comments
TNC
No need to get snarky, because I program something differently.
nnnnnn
@awm - It seems like you don't know JavaScript. You can't cast to boolean with
(bool) (that'll give an error) and in any case you don't need to: return value%2 == 0; will do the job since the == operator returns a boolean.
awm
Wow, did I really write that? Yes, that's obviously wrong; should be something like
answer = !!(condition). The point I was trying to make, of course is that you can just return value%2==0 and don't need to bother with the conditional.
carlodurso
I find it elegant:
value%2===0
éclairevoyant
if (condition) return true; else return false; isn't a "style difference", it's just bad code in isolation as it's just extra boilerplate for no benefit. Someone new to coding should understand that you can return expressions and variables, not just raw values, and in JS, value%2==0 is in fact a boolean expression |
Do I have to make an array really large that has a lot of even numbers
No. Use modulus (%). It gives you the remainder of the two numbers you are dividing.
Ex. 2 % 2 = 0 because 2/2 = 1 with 0 remainder.
Ex2. 3 % 2 = 1 because 3/2 = 1 with 1 remainder.
Ex3. -7 % 2 = -1 because -7/2 = -3 with -1 remainder.
This means if you mod any number x by 2, you get either 0 or 1 or -1. 0 would mean it's even. Anything else would mean it's odd.
Comments
function isEven(x) { return (x%2)==0; }
function isOdd(x) { return !isEven(x); }
Comments
Like many languages, Javascript has a modulus operator %, that finds the remainder of division. If there is no remainder after division by 2, a number is even:
// this expression is true if "number" is even, false otherwise
(number % 2 == 0)
Similarly, if there is a remainder of 1 after division by 2, a number is odd:
// this expression is true if "number" is odd, false otherwise
(number % 2 == 1)
This is a very common idiom for testing for even integers.
This can be solved with a small snippet of code:
function isEven(value) {
return !(value % 2)
}
Hope this helps :)
Comments
In ES6:
const isOdd = num => num % 2 == 1;
2 Comments
Jason Aller
When adding an answer to an eight year old question with 26 existing answers it really is useful to explain what new aspect of the question your answer addresses, and if the passage of time and new versions impacts the answer. A code only answer can almost always be improved by the addition of some explanation and in this case some example calls showing usage.
Darryl Mendonez
the title is 'How to determine if a number is odd in JavaScript' and there was no ES6 solution posted for what is asked.
With bitwise, codegolfing:
var isEven=n=>(n&1)?"odd":"even";
5 Comments
Rewind
& bitwise only exactly works on numbers up to 2^32. % works on numbers up to 2^53.
Katia Punter
Yes, @Rewind it's only useful for some codegolfing challenges, not for writing production code
éclairevoyant
it's also incorrect if the input isn't an integer
Katia Punter
@éclairevoyant I interpreted the question as "show me all different ways of doing odd or even" and I gave a codegolfing answer which I clearly labelled as codegolfing. This means - focus on doing it in as little characters as possible.
éclairevoyant
@KatiaPunter this is a valid method in some other languages but not JS
Use my extensions :
Number.prototype.isEven=function(){
return this % 2===0;
};
Number.prototype.isOdd=function(){
return !this.isEven();
}
then
var a=5;
a.isEven();
==False
a.isOdd();
==True
if you are not sure if it is a Number , test it by the following branching :
if(a.isOdd){
a.isOdd();
}
UPDATE :
if you would not use variable :
(5).isOdd()
Performance :
It turns out that Procedural paradigm is better than OOP paradigm . By the way , i performed profiling in this FIDDLE . However , OOP way is still prettiest .
3 Comments
Shoib Mohammed A
Thanks dude, for this logic, in interviewee someone asked this kind of logic, could not answer, now i got it, thanks.. but is there any benefit in performance by following this method? we could have written isEven(x); etc.
Abdennour TOUMI
@ShoibMohammedA : Comparison has been done ! jsfiddle.net/abdennour/jL2uyksa/3
tim-montague
-1 don't extend native prototype functions. (stackoverflow.com/questions/14034180/…)
A simple function you can pass around. Uses the modulo operator %:
var is_even = function(x) {
return !(x % 2);
}
is_even(3)
false
is_even(6)
true
1 Comment
dom_watson
If your results in the ternary operator are either 'true' or 'false', you really don't need the ternary operator. Here, you could/should just do:
return !(x % 2);if (X % 2 === 0){
} else {
}
Replace X with your number (can come from a variable). The If statement runs when the number is even, the Else when it is odd.
If you just want to know if any given number is odd:
if (X % 2 !== 0){
}
Again, replace X with a number or variable.
Comments
<script>
function even_odd(){
var num = document.getElementById('number').value;
if ( num % 2){
document.getElementById('result').innerHTML = "Entered Number is Odd";
}
else{
document.getElementById('result').innerHTML = "Entered Number is Even";
}
}
</script>
</head>
<body>
<center>
<div id="error"></div>
<center>
<h2> Find Given Number is Even or Odd </h2>
<p>Enter a value</p>
<input type="text" id="number" />
<button onclick="even_odd();">Check</button><br />
<div id="result"><b></b></div>
</center>
</center>
</body>
Comments
Many people misunderstand the meaning of odd
isOdd("str")should be false.
Only an integer can be odd.isOdd(1.223)andisOdd(-1.223)should be false.
A float is not an integer.isOdd(0)should be false.
Zero is an even integer (https://en.wikipedia.org/wiki/Parity_of_zero).isOdd(-1)should be true.
It's an odd integer.
Solution
function isOdd(n) {
// Must be a number
if (isNaN(n)) {
return false;
}
// Number must not be a float
if ((n % 1) !== 0) {
return false;
}
// Integer must not be equal to zero
if (n === 0) {
return false;
}
// Integer must be odd
if ((n % 2) !== 0) {
return true;
}
return false;
}
JS Fiddle (if needed): https://jsfiddle.net/9dzdv593/8/
1-liner
Javascript 1-liner solution. For those who don't care about readability.
const isOdd = n => !(isNaN(n) && ((n % 1) !== 0) && (n === 0)) && ((n % 2) !== 0) ? true : false;
5 Comments
You can accelerate the solution yet. i.e., in the final statements you can just return !!(n % 2) , this will optionally make it work with signed numbers (i.e., when n % 2 returns 0, it's false, but when -1 or 1 returned, this would return true). Your solution is actually returning false for odd numbers since it's checking if the modulus return is 0, but should check for 1, and 1 would fail for negative numbers, thus return !!(n % 2) is safer. And anyways, {} (block statement) doesn't cause minification issues and is not present in the discussion.
tim-montague
@TheProHands - Thanks for the notes. (1) The issue was that the Modulus Version had a typo; it should have been
(n % 2) !== 0 instead of (n % 2) === 0. (2) My advice is to avoid !!(n % 2), because (a) it has slower performance than (n % 2) !== 0 (jsperf.com/notnot-vs-strict-not), (b) it's a hack - it coerces a falsey value 0 into false, and (c) it's obscure (high-level programming languages shouldn't read like Pascal at the sake of performance - that's the compiler's job). (3) Yes, missing {} block statements do result in several issues (as updated in my answer).I never avoid block statements because I care about readability, but I'm trying to tell that seeking block statements doesn't result in issues, only in the code maintainace. I.e., using sequence expressions merged with expression statement instead of block statement might make the code unreadable and ugly, i.e.:
if (0) call1(), assign = 0, call2(), but a single statement isn't bad: if (0) return; if (0) ;; if (0); break; if (0) continue;, and anyways I prefer to continue using break-line block statements when I've long-inline conditions.
Mulan
type/null checks like your
isNaN(n) are silly - sure you covered the NaN case, but isOdd(null), isOdd(undefined), isOdd({x:1}) all return false which I consider to be an error; unless of course you're only specifying that your function has correct behaviour over a given domain: only Number-type inputs. In which case, just drop the isNaN check and force the user to call it with the correct type. Defensive programming is awful. Then your function is simplified to isOdd = x => Math.floor(x) === x && x & 1 === 1 – returning explicit true or false values is not necessarytim-montague
null, undefined and objects {} are not odd integers, and therefore the function returns false - not sure why you consider that an error. The isNaN check is for performance (not for defense), it lets the function exit prematurely without performing the other checks.Just executed this one in Adobe Dreamweaver..it works perfectly. i used if (isNaN(mynmb))
to check if the given Value is a number or not, and i also used Math.abs(mynmb%2) to convert negative number to positive and calculate
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
</head>
<body bgcolor = "#FFFFCC">
<h3 align ="center"> ODD OR EVEN </h3><table cellspacing = "2" cellpadding = "5" bgcolor="palegreen">
<form name = formtwo>
<td align = "center">
<center><BR />Enter a number:
<input type=text id="enter" name=enter maxlength="10" />
<input type=button name = b3 value = "Click Here" onClick = compute() />
<b>is<b>
<input type=text id="outtxt" name=output size="5" value="" disabled /> </b></b></center><b><b>
<BR /><BR />
</b></b></td></form>
</table>
<script type='text/javascript'>
function compute()
{
var enter = document.getElementById("enter");
var outtxt = document.getElementById("outtxt");
var mynmb = enter.value;
if (isNaN(mynmb))
{
outtxt.value = "error !!!";
alert( 'please enter a valid number');
enter.focus();
return;
}
else
{
if ( mynmb%2 == 0 ) { outtxt.value = "Even"; }
if ( Math.abs(mynmb%2) == 1 ) { outtxt.value = "Odd"; }
}
}
</script>
</body>
</html>
Comments
When you need to test if some variable is odd, you should first test if it is integer. Also, notice that when you calculate remainder on negative number, the result will be negative (-3 % 2 === -1).
function isOdd(value) {
return typeof value === "number" && // value should be a number
isFinite(value) && // value should be finite
Math.floor(value) === value && // value should be integer
value % 2 !== 0; // value should not be even
}
If Number.isInteger is available, you may also simplify this code to:
function isOdd(value) {
return Number.isInteger(value) // value should be integer
value % 2 !== 0; // value should not be even
}
Note: here, we test value % 2 !== 0 instead of value % 2 === 1 is because of -3 % 2 === -1. If you don't want -1 pass this test, you may need to change this line.
Here are some test cases:
isOdd(); // false
isOdd("string"); // false
isOdd(Infinity); // false
isOdd(NaN); // false
isOdd(0); // false
isOdd(1.1); // false
isOdd("1"); // false
isOdd(1); // true
isOdd(-1); // true
Comments
Using % will help you to do this...
You can create couple of functions to do it for you... I prefer separte functions which are not attached to Number in Javascript like this which also checking if you passing number or not:
odd function:
var isOdd = function(num) {
return 'number'!==typeof num ? 'NaN' : !!(num % 2);
};
even function:
var isEven = function(num) {
return isOdd(num)==='NaN' ? isOdd(num) : !isOdd(num);
};
and call it like this:
isOdd(5); // true
isOdd(6); // false
isOdd(12); // false
isOdd(18); // false
isEven(18); // true
isEven('18'); // 'NaN'
isEven('17'); // 'NaN'
isOdd(null); // 'NaN'
isEven('100'); // true
Comments
A more functional approach in modern javascript:
const NUMBERS = "nul one two three four five six seven ocho nueve".split(" ")
const negate = f=> (...args)=> !f(...args)
const isOdd = n=> NUMBERS[n % 10].indexOf("e")!=-1
const isEven = negate(isOdd)
Comments
One liner in ES6 just because it's clean.
const isEven = (num) => num % 2 == 0;
Comments
You can use a for statement and a conditional to determine if a number or series of numbers is odd:
for (var i=1; i<=5; i++)
if (i%2 !== 0) {
console.log(i)
}
This will print every odd number between 1 and 5.
Comments
Every odd number when divided by two leaves remainder as 1 and every even number when divided by zero leaves a zero as remainder. Hence we can use this code
function checker(number) {
return number%2==0?even:odd;
}
Comments
How about this...
var num = 3 //instead get your value here
var aa = ["Even", "Odd"];
alert(aa[num % 2]);
Comments
This is what I did
//Array of numbers
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,32,23,643,67,5876,6345,34,3453];
//Array of even numbers
var evenNumbers = [];
//Array of odd numbers
var oddNumbers = [];
function classifyNumbers(arr){
//go through the numbers one by one
for(var i=0; i<=arr.length-1; i++){
if (arr[i] % 2 == 0 ){
//Push the number to the evenNumbers array
evenNumbers.push(arr[i]);
} else {
//Push the number to the oddNumbers array
oddNumbers.push(arr[i]);
}
}
}
classifyNumbers(numbers);
console.log('Even numbers: ' + evenNumbers);
console.log('Odd numbers: ' + oddNumbers);
For some reason I had to make sure the length of the array is less by one. When I don't do that, I get "undefined" in the last element of the oddNumbers array.
1 Comment
Zakher Masri
It's because the condition is set to less to or equal "<=" to the length of the array. I removed the equal sign and is the result was as desired.
I'd implement this to return a boolean:
function isOdd (n) {
return !!(n % 2);
// or ((n % 2) !== 0).
}
It'll work on both unsigned and signed numbers. When the modulus return -1 or 1 it'll get translated to true.
Non-modulus solution:
var is_finite = isFinite;
var is_nan = isNaN;
function isOdd (discriminant) {
if (is_nan(discriminant) && !is_finite(discriminant)) {
return false;
}
// Unsigned numbers
if (discriminant >= 0) {
while (discriminant >= 1) discriminant -= 2;
// Signed numbers
} else {
if (discriminant === -1) return true;
while (discriminant <= -1) discriminant += 2;
}
return !!discriminant;
}
Comments
Return true if odd
function isOdd(n) {
return Math.abs(n)%2===1;
}
Return true if even
function isEven(n) {
return Math.abs(n)%2!==1;
}
I used Math.abs() in case of getting a negative number
Comments
So many answers here but i just have to mention one point.
Normally it's best to use the modulo operator like % 2 but you can also use the bitwise operator like & 1. They both would yield the same outcome. However their precedences are different. Say if you need a piece of code like
i%2 === p ? n : -n
it's just fine but with the bitwise operator you have to do it like
(i&1) === p ? n : -n
So there is that.
Comments
Subtract 2 to it recursively until you reach either -1 or 0 (only works for positive integers obviously) :)
2 Comments
rioV8
And it takes a hell of a time when n=2^52, and an infinite amount for n>2^53
By using ternary operator, you we can find the odd even numbers:
var num = 2;
result = (num % 2 == 0) ? 'even' : 'odd'
console.log(result);
Comments
Another example using the filter() method:
let even = arr.filter(val => {
return val % 2 === 0;
});
// even = [2,4,6]
Comments
this works for arrays:
function evenOrOdd(numbers) {
const evenNumbers = [];
const oddNumbers = [];
numbers.forEach(number => {
if (number % 2 === 0) {
evenNumbers.push(number);
} else {
oddNumbers.push(number);
}
});
console.log("Even: " + evenNumbers + "\nOdd: " + oddNumbers);
}
evenOrOdd([1, 4, 9, 21, 41, 92]);
this should log out: 4,92 1,9,21,41
for just a number:
function evenOrOdd(number) {
if (number % 2 === 0) {
return "even";
}
return "odd";
}
console.log(evenOrOdd(4));
this should output even to the console
%operator than&, and 2. While&is theoretically faster, it really doesn't matter.