Probar si un valor es par o impar

Decidí crear funciones simples isEven e isOdd con un algoritmo muy simple:

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

function isOdd(n) {
  return isEven(Number(n) + 1);
}

Eso está bien si n está con ciertos parámetros, pero falla en muchos escenarios. Así que me propuse crear funciones robustas que brinden resultados correctos para tantos escenarios como pueda, de modo que solo se prueben los enteros dentro de los límites de los números de JavaScript, todo lo demás devuelve falso (incluido + e - infinito). Tenga en cuenta que cero es 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));

¿Alguien puede ver algún problema con lo anterior? ¿Existe una versión mejor (es decir, más precisa, más rápida o más concisa sin ofuscarse)?

Hay varias publicaciones relacionadas con otros idiomas, pero parece que no puedo encontrar una versión definitiva para ECMAScript.

Usar módulo:

function isEven(n) {
   return n % 2 == 0;
}

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

Puede verificar que cualquier valor en Javascript se puede convertir a un número con:

Number.isFinite(parseFloat(n))

Esta verificación debe realizarse preferiblemente fuera de las funciones isEveny isOdd, para que no tenga que duplicar el manejo de errores en ambas funciones.

Prefiero usar una prueba de bit:

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

Esto prueba si el primer bit está activado, lo que significa un número impar.

¿Qué tal lo siguiente? Solo probé esto en IE, pero estaba muy contento de manejar cadenas que representan números de cualquier longitud, números reales que eran enteros o flotantes, y ambas funciones devuelven falso cuando se pasa un booleano, indefinido, nulo, una matriz o un objeto. (Depende de usted si desea ignorar los espacios en blanco iniciales o finales cuando se pasa una cadena; he asumido que no se ignoran y hacen que ambas funciones devuelvan falso).

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

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

Nota: también hay números negativos.

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

dónde

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

¿Por qué no solo hacer esto?

    function oddOrEven(num){
        if(num % 2 == 0)
            return "even";
        return "odd";
    }
    oddOrEven(num);

Para completar la prueba de bits de Robert Brisita.

if ( ~i & 1 ) {
    // Even
}

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

¡Una simple modificación / mejora de la respuesta de Steve Mayne!

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

Nota: ¡Devuelve falso si no es válido!

¡Solo necesitamos una línea de código para esto!

Aquí hay una forma más nueva y alternativa de hacer esto, utilizando la nueva sintaxis ES6 para las funciones JS y la sintaxis de una línea para la if-elsellamada a la instrucción:

const isEven = num => ((num % 2) == 0) ? true : false;

alert(isEven(8));  //true
alert(isEven(9));  //false
alert(isEven(-8)); //true

Unos pocos

x % 2 == 0; // Check if even

!(x & 1); // bitmask the value with 1 then invert.

((x >> 1) << 1) == x; // divide value by 2 then multiply again and check against original value

~x&1; // flip the bits and bitmask

Diferente modo:

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

isEven(69)

De lo contrario, usar cadenas porque ¿por qué no?

function isEven(__num){
    return String(__num/2).indexOf('.') === -1;
}

if (testNum == 0);
else if (testNum % 2  == 0);
else if ((testNum % 2) != 0 );

¿Tal vez esto? if (ourNumber% 2! == 0)

var num = someNumber
    isEven;
parseInt(num/2) === num/2 ? isEven = true : isEven = false;

Para probar si tiene o no un número par o impar, esto también 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 estilo javascript moderno:

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)

¡Este es más simple!

  var num = 3 //instead get your value here
  var aa = ["Even", "Odd"];

  alert(aa[num % 2]);

function isEven(n) {return parseInt(n)%2===0?true:parseInt(n)===0?true:false}

cuando 0 / incluso quería pero

isEven(0) //true
isEven(1) //false
isEven(2) //true
isEven(142856) //true
isEven(142856.142857)//true
isEven(142857.1457)//false

​

if (i % 2) {
return odd numbers
}

if (i % 2 - 1) {
return even numbers
}