web-dev-qa-db-fra.com

Tester si une valeur est pair ou impair

J'ai décidé de créer des fonctions simples isEven et isOdd 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 échoue pour de nombreux scénarios. Je me suis donc mis en tête de créer des fonctions robustes qui donnent des résultats corrects pour autant de scénarios que possible, de sorte que seuls les entiers compris dans les limites des nombres javascript soient testés; 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 meilleure version (c'est-à-dire plus précise, plus rapide ou plus concise sans être obscurcie)?

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

Modifier

Une balise de révision de code a été ajoutée, mais je ne suis pas après une révision de code. J'ai posté le code simplement pour que les autres puissent voir ce que je faisais, et non comme un élément à réviser. Les réponses postées jusqu'à présent semblent l'avoir.

Modifier 2

Une dernière fonction, basée sur la réponse 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;
}

Tout ce qui n'est pas un nombre renvoie undefined, les nombres renvoient soit true ou false. Ce pourrait être une fonction avec un drapeau strict, mais je pense que la comparaison stricte n'est pas vraiment requise.

javascriptnumbers
132
RobG

Utilisez 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 contrainte à un nombre avec:

Number.isFinite(parseFloat(n))

Cette vérification doit de préférence être effectuée en dehors des fonctions isEven et isOdd, de sorte que vous ne devez pas dupliquer la gestion des erreurs dans les deux fonctions.

292
Steve Mayne

Je préfère utiliser un peu de test:

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

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

65
Robert Brisita

Que diriez-vous de ce qui suit? Je n’ai testé cela que dans IE, mais c’était un plaisir de manipuler des chaînes représentant des nombres de toutes longueurs, des nombres réels entiers ou des nombres flottants, et les deux fonctions renvoyaient la valeur false lorsqu’on leur passait un booléen, undefined, null, un tableau ou un objet. (À vous de décider si vous souhaitez ignorer les espaces de début ou de fin lorsqu'une chaîne est transmise - je suppose qu'ils sont non ignorés et que les deux fonctions renvoient false.)

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

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

Note: il y a aussi des nombres négatifs. 

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

où

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

Pourquoi ne pas simplement faire ceci:

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

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

Voici un moyen plus récent et alternatif de le faire, en utilisant la nouvelle syntaxe ES6 pour les fonctions JS et la syntaxe une ligne pour l'appel d'instruction if-else:

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

alert(isEven(8));  //true
alert(isEven(9));  //false
alert(isEven(-8)); //true
1
Fellipe Sanches

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

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

Remarque: Renvoie false si non valide!

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

Peut-être cela? If (ourNumber% 2! == 0)

0
gavr1loo

Pour vérifier 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');
    }
}
0
Siop

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)
0
gunn

Sinon, en utilisant des cordes, pourquoi pas

function isEven(__num){
    return String(__num/2).indexOf('.') === -1;
}
0
Eric
if (testNum == 0);
else if (testNum % 2  == 0);
else if ((testNum % 2) != 0 );
0
Lindsay

Autrement:

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

isEven(69)
0
grizmin