javascript - attribute - Probando si un valor es impar o incluso

title css

Question

Decidí crear la función simple isEven y 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 es con ciertos parámetros, pero falla en muchos escenarios. Así que me propuse crear funciones robustas que brinden resultados correctos para tantos escenarios como pudiera, 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 (incluyendo + y - infinito). Tenga en cuenta que el 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? ¿Hay una versión mejor (es decir, más precisa, más rápida o más concisa sin ser ofuscada)?

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

Editar

Se agregó una etiqueta de revisión de código, pero no estoy buscando una revisión del código. Publiqué el código simplemente para que otros pudieran ver dónde estaba, no como algo para revisar. Las respuestas publicadas hasta ahora parecen obtener eso.

Editar 2

Una función final, basada en la respuesta 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;
}

Cualquier cosa que no sea un número devuelve indefinido , los números devuelven verdadero o falso . Podría ser una función con un indicador estricto, pero creo que la comparación estricta no es realmente necesaria.

Answer 1

¡Este es más simple!

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

  alert(aa[num % 2]);

Answer 2

¡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!

Answer 3

¿Por qué no solo hacer esto?

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

Answer 4

¿Qué tal lo siguiente? Solo probé esto en IE, pero me complació manejar cadenas que representaban números de cualquier longitud, números reales que eran enteros o flotantes, y ambas funciones devolvían false cuando pasaron 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 supuesto que no se ignoran y las funciones se devuelven falsas).

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

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

Answer 5

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

Answer 6

De otra manera usando cadenas porque por qué no

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

Answer 7

Manera diferente:

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

isEven(69)

Answer 8

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);
}

Answer 9

Para probar si tienes o no un número impar o par, 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'');
    }
}

Answer 10

Prefiero usar una prueba de bit:

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

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

Answer 11

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)

Answer 12

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 pueda forzar a un número con:

Number.isFinite(parseFloat(n))

Esta comprobación debería realizarse preferiblemente fuera de las funciones isEven e isOdd , por lo que no es necesario duplicar el manejo de errores en ambas funciones.

Answer 13

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

Answer 14

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