Tester si une valeur est paire ou impaire

J'ai décidé de créer des fonctions isEven et isOdd simples avec un algorithme très simple:

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

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

C'est OK si n est avec certains paramètres, mais échoue dans de nombreux scénarios. J'ai donc entrepris de créer des fonctions robustes qui fournissent des résultats corrects pour autant de scénarios que possible, de sorte que seuls les entiers dans les limites des nombres javascript soient testés, tout le reste retourne faux (y compris + et - infini). Notez que zéro est pair.

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

Quelqu'un peut-il voir des problèmes avec ce qui précède? Existe-t-il une version meilleure (c'est-à-dire plus précise, plus rapide ou plus concise sans être obscurcie)?

Il existe divers articles relatifs à d'autres langues, mais je n'arrive pas à trouver une version définitive pour ECMAScript.

Utiliser le module:

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

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

Vous pouvez vérifier que toute valeur en Javascript peut être forcée à un nombre avec:

Number.isFinite(parseFloat(n))

Cette vérification doit de préférence être effectuée en dehors des fonctions isEvenet isOdd, pour ne pas avoir à dupliquer la gestion des erreurs dans les deux fonctions.

Je préfère utiliser un petit test:

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

Cela teste si le premier bit est sur lequel signifie un nombre impair.

Que diriez-vous de ce qui suit? Je n'ai testé cela que dans IE, mais c'était assez heureux de gérer des chaînes représentant des nombres de n'importe quelle longueur, des nombres réels qui étaient des entiers ou des flottants, et les deux fonctions renvoyaient false lorsqu'elles étaient passées un booléen, undefined, null, un tableau ou un objet. (À vous de décider si vous voulez ignorer les blancs de début ou de fin lorsqu'une chaîne est passée - j'ai supposé qu'ils ne sont pas ignorés et que les deux fonctions retournent false.)

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

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

Remarque: il existe également des nombres négatifs.

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

où

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

Pourquoi ne pas simplement faire ceci:

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

Pour terminer le test 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);    
    }
};

Une simple modification / amélioration de la réponse de Steve Mayne!

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

Remarque: renvoie false si non valide!

Nous avons juste besoin d'une ligne de code pour cela!

Voici une façon plus nouvelle et alternative de le faire, en utilisant la nouvelle syntaxe ES6 pour les fonctions JS et la syntaxe sur une ligne pour l' if-elseappel d'instruction:

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

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

Quelques

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

Autrement:

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

isEven(69)

Sinon, utiliser des chaînes car pourquoi pas

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

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

Peut être ça? if (notreNombre% 2! == 0)

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

Pour tester si vous avez un nombre pair ou impair, cela fonctionne également.

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

Utilisation du style javascript moderne:

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)

Celui-ci est plus 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}

quand 0 / même voulu mais

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
}