Testando se um valor é ímpar ou até mesmo

Eu decidi criar funções isEven e isOdd simples com um algoritmo muito simples:

function isEven(n) { n = Number(n); return n === 0 || !!(n && !(n%2)); } function isOdd(n) { return isEven(Number(n) + 1); } 

Tudo bem se n estiver com certos parâmetros, mas falhar em muitos cenários. Então, eu me propus a criar funções robustas que entregassem resultados corretos para tantos cenários quanto eu pudesse, de modo que apenas inteiros dentro dos limites de números de javascript fossem testados, tudo o resto retornasse false (incluindo + e – infinito). Note que zero é par.

 // Returns true if: // // n is an integer that is evenly divisible by 2 // // Zero (+/-0) is even // Returns false if n is not an integer, not even or NaN // Guard against empty string (function (global) { function basicTests(n) { // Deal with empty string if (n === '') return false; // Convert n to Number (may set to NaN) n = Number(n); // Deal with NaN if (isNaN(n)) return false; // Deal with infinity - if (n === Number.NEGATIVE_INFINITY || n === Number.POSITIVE_INFINITY) return false; // Return n as a number return n; } function isEven(n) { // Do basic tests if (basicTests(n) === false) return false; // Convert to Number and proceed n = Number(n); // Return true/false return n === 0 || !!(n && !(n%2)); } global.isEven = isEven; // Returns true if n is an integer and (n+1) is even // Returns false if n is not an integer or (n+1) is not even // Empty string evaluates to zero so returns false (zero is even) function isOdd(n) { // Do basic tests if (basicTests(n) === false) return false; // Return true/false return n === 0 || !!(n && (n%2)); } global.isOdd = isOdd; }(this)); 

Alguém pode ver algum problema com o acima? Existe uma versão melhor (ou seja, mais precisa, mais rápida ou mais concisa sem ser ofuscada)?

Existem vários posts relacionados a outros idiomas, mas não consigo encontrar uma versão definitiva para o ECMAScript.

Editar

Uma tag de revisão de código foi adicionada, mas não estou atrás de uma revisão de código. Eu postei o código simplesmente para que os outros pudessem ver onde eu estava, não como algo para revisar. Respostas postadas até agora parecem conseguir isso.

Editar 2

Uma function final, baseada na resposta de Steve:

 // Use abstract equality == for "is number" test function isEven(n) { return n == parseFloat(n)? !(n%2) : void 0; } // Use strict equality === for "is number" test function isEvenStrict(n) { return n === parseFloat(n)? !(n%2) : void 0; } 

Qualquer coisa que não seja um número retorna indefinido , os números retornam verdadeiro ou falso . Pode ser uma function com um sinalizador estrito, mas acho que a comparação estrita não é realmente necessária.

Use o módulo:

 function isEven(n) { return n % 2 == 0; } function isOdd(n) { return Math.abs(n % 2) == 1; } 

Você pode verificar se qualquer valor em JavaScript pode ser coagido para um número com:

 Number.isFinite(parseFloat(n)) 

Essa verificação deve ser feita preferencialmente fora das funções isOdd e isOdd , para que você não precise duplicar o tratamento de erros nas duas funções.

Eu prefiro usar um teste de bits:

 if(i & 1) { // ODD } else { // EVEN } 

Isso testa se o primeiro bit está no qual significa um número ímpar.

Como sobre o seguinte? Eu só testei isso no IE, mas ficou muito feliz em lidar com strings representando números de qualquer tamanho, números reais que eram inteiros ou flutuantes, e ambas as funções retornavam false quando passavam um booleano, indefinido, nulo, uma matriz ou um object. (Até você se você quer ignorar espaços em branco iniciais ou finais quando uma string é passada – eu assumi que eles não são ignorados e fazem com que ambas as funções retornem false.)

 function isEven(n) { return /^-?\d*[02468]$/.test(n); } function isOdd(n) { return /^-?\d*[13579]$/.test(n); } 

Nota: também existem números negativos.

 function isOddInteger(n) { return isInteger(n) && (n % 2 !== 0) ) ; } 

Onde

 function isInteger(n) { return n === parseInt(n); } 

Por que não fazer isso:

  function oddOrEven(num){ if(num % 2 == 0) return "even"; return "odd"; } oddOrEven(num); 
 var isEven = function(number) { // Your code goes here! if (number % 2 == 0){ return(true); } else{ return(false); } }; 

Uma simples modificação / melhoria da resposta de Steve Mayne!

 function isEvenOrOdd(n){ if(n === parseFloat(n)){ return isNumber(n) && (n % 2 == 0); } return false; } 

Nota: Retorna false se inválido!

Maneira diferente:

 var isEven = function(number) { // Your code goes here! if (((number/2) - Math.floor(number/2)) === 0) {return true;} else {return false;}; }; isEven(69) 

De outra forma, usando cordas porque não

 function isEven(__num){ return String(__num/2).indexOf('.') === -1; } 
 if (testNum == 0); else if (testNum % 2 == 0); else if ((testNum % 2) != 0 ); 

Para testar se você tem ou não um número ímpar ou par, isso também funciona.

 const comapare = x => integer(checkNumber(x)); function checkNumber (x) { if (x % 2 == 0) { return true; } else if (x % 2 != 0) { return false; } } function integer (x) { if (x) { console.log('even'); } else { console.log('odd'); } } 

Usando o estilo moderno de javascript:

 const NUMBERS = "nul one two three four five six seven ocho nueve".split(" ") const isOdd = n=> NUMBERS[n % 10].indexOf("e")!=-1 const isEven = n=> isOdd(+n+1) 

Talvez isto? if (ourNumber% 2! == 0)

Maneira simples de testar se um número é mesmo usando JavaScript

 function isEven(x) { //return true if even if (x % 2 === 0) { return true; } //return false otherwise else { return false } } // or much simpler function isEven(x) { return x % 2 === 0; } 

Este é mais simples!

  var num = 3 //instead get your value here var aa = ["Even", "Odd"]; alert(aa[num % 2]);