Tester si une valeur est paire ou impaire

Question

J'ai décidé de créer des est même y estOdd 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 correct si n est avec certains paramètres, mais c'est un échec pour 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 de javascript sont testés, tout le reste retournant faux (y compris + et - l'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 voit-il des problèmes dans ce qui précède ? Existe-t-il une meilleure version (c'est-à-dire plus précise, plus rapide ou plus concise sans être obscurcie) ?

Il existe plusieurs messages relatifs à d'autres langages, mais je n'arrive pas à trouver une version définitive pour ECMAScript.

Answer 1

Utiliser le module :

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

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

Vous pouvez vérifier que n'importe quelle valeur en Javascript peut être transformée en nombre avec :

Number.isFinite(parseFloat(n))

Ce contrôle doit de préférence être effectué en dehors de l'enceinte de l'entreprise. isEven y isOdd afin d'éviter de dupliquer la gestion des erreurs dans les deux fonctions.

Answer 2

Je préfère utiliser un bit test :

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

Cela permet de vérifier si le premier bit est activé, ce qui signifie un nombre impair.

Answer 3

Que pensez-vous de ce qui suit ? Je n'ai testé cette fonction que sous IE, mais elle était très heureuse 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'on leur passait un booléen, un indéfini, un 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 de caractères est passée - j'ai supposé qu'ils l'étaient no ignorés et que les deux fonctions renvoient un message faux).

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

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

Answer 4

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

Answer 5

Pour compléter le test de Robert Brisita .

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