Verifica se un valore è pari o dispari

Ho deciso di creare la semplice funzione isEven e isOdd con un algoritmo molto semplice:

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

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

Questo è OK se n è con alcuni parametri, ma fallisce per molti scenari. Quindi ho deciso di creare funzioni robuste che offrano risultati corretti per tutti gli scenari che ho potuto, in modo che vengano testati solo numeri interi entro i limiti dei numeri javascript, tutto il resto restituisce false (inclusi + e - infinito). Si noti che zero è pari.

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

Qualcuno può vedere problemi con quanto sopra? Esiste una versione migliore (ovvero più accurata, più veloce o più concisa senza essere offuscata)?

Esistono vari post relativi ad altre lingue, ma non riesco a trovare una versione definitiva per ECMAScript.

Usa il modulo:

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

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

Puoi verificare che qualsiasi valore in Javascript possa essere forzato su un numero con:

Number.isFinite(parseFloat(n))

Questo controllo dovrebbe preferibilmente essere eseguito al di fuori delle funzioni isEvene isOdd, quindi non è necessario duplicare la gestione degli errori in entrambe le funzioni.

Preferisco usare un bit test:

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

In questo modo viene verificato se il primo bit è attivo per indicare un numero dispari.

Che ne dici di quanto segue? L'ho provato solo in IE, ma era abbastanza felice di gestire stringhe che rappresentavano numeri di qualsiasi lunghezza, numeri reali che erano numeri interi o float ed entrambe le funzioni restituivano false quando veniva passato un valore booleano, indefinito, null, un array o un oggetto. (A te se vuoi ignorare gli spazi vuoti iniziali o finali quando viene passata una stringa - ho assunto che non vengano ignorati e che entrambe le funzioni restituiscano false.)

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

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

Nota: ci sono anche numeri negativi.

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

dove

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

Perché non fare solo questo:

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

Per completare il bit test di Robert Brisita.

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

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

Una semplice modifica / miglioramento della risposta di Steve Mayne!

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

Nota: restituisce false se non valido!

Abbiamo solo bisogno di una riga di codice per questo!

Ecco un modo più nuovo e alternativo per farlo, usando la nuova sintassi ES6 per le funzioni JS e la sintassi a una riga per la if-elsechiamata dell'istruzione:

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

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

Alcune

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

Un modo differente:

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

isEven(69)

Altrimenti usa le stringhe perché perché no

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

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

Forse questo? if (ourNumber% 2! == 0)

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

Per verificare se hai un numero pari o dispari, funziona anche.

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

Utilizzando il moderno stile 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)

Questo è più semplice!

  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}

quando 0 / anche voluto ma

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
}