Comment déterminer si un nombre est impair en JavaScript

245

Quelqu'un peut-il m'indiquer du code pour déterminer si un nombre en JavaScript est pair ou impair?

javascript 
— Jannie Theunissen
source
6
— epascarello
1
@DavidThomas Je suis partiellement d'accord, mais j'ai deux mises en garde: 1. Si je devais choisir, je préférerais qu'un programmeur débutant connaissait l' %opérateur plutôt que &, et 2. Bien que &théoriquement plus rapide, cela n'a vraiment pas d'importance .
— kojiro
3
@kojiro: Je préfère que davantage d'options (valides) soient présentées à un apprenant; De plus, je n'avais jamais pensé à utiliser au niveau du bit et de cette manière auparavant, c'est donc une prise intéressante. Quoi qu'il en soit, car il est dupe, j'ai trouve en position de fusion avec la question préexistante. Espérons donc que les réponses ici (cette réponse au moins) ne seront pas perdues.
— David dit de réintégrer Monica
1
@kojiro J'ai peur de dire que votre violon est tout à fait inutile, car la plupart du temps de calcul est pris par les appels de fonction. Mais personne n'utilisera un appel de fonction pour déterminer si un nombre est pair ou impair ... J'ai fait une troisième révision de votre test, mais je suis sur mon téléphone maintenant ...
— MaxArt
1
— bummi

Réponses:

347

Utilisez le code ci-dessous:

function isOdd(num) { return num % 2;}
console.log("1 is " + isOdd(1));
console.log("2 is " + isOdd(2));
console.log("3 is " + isOdd(3));
console.log("4 is " + isOdd(4));
Développer l'extrait

1 représente un nombre impair, tandis que 0 représente un nombre pair.

— Chii
source
97
Notez que cela retournera 0ou 1(ou NaNsi vous l'introduisez quelque chose qui n'est pas un nombre et ne peut pas être contraint en un), ce qui fonctionnera bien dans la plupart des situations. Mais si vous voulez un vrai trueou false:return (num % 2) == 1;
— TJ Crowder
3
oui bonne note sur le NaN. Mais généralement, vous voulez que javascript soit véridique ou falsey, c'est pourquoi je l'ai écrit comme je l'ai fait.
— Chii
9
Juste pour clarifier, l'opérateur modulo (%) donne le reste d'une division. Donc 3% 2 serait 3/2, laissant 1 comme reste, donc 3% 2 retournera 1.
— Abuh
6
Suite à ce que TJ a dit, cela retournera une fraction s'il numn'est pas un entier. Ce qui fonctionnera toujours si vous comparez isOdd(1.5)==true(car une valeur fractionnaire n'est pas égale à true), mais il serait préférable que la fonction retourne trueou falsecomme l'indique le nom "isOdd".
— nnnnnn
6
Vous pouvez également faire return !!(num % 2)pour obtenir un booléen
— Duncan
115

Utilisez l' ANDopérateur au niveau du bit .

function oddOrEven(x) {
  return ( x & 1 ) ? "odd" : "even";
}

function checkNumber(argNumber) {
  document.getElementById("result").innerHTML = "Number " + argNumber + " is " + oddOrEven(argNumber);
}
 
checkNumber(17);
<div id="result" style="font-size:150%;text-shadow: 1px 1px 2px #CE5937;" ></div>
Développer l'extrait

Si vous ne voulez pas une valeur de retour de chaîne, mais plutôt une valeur booléenne, utilisez ceci:

var isOdd = function(x) { return x & 1; };
var isEven  = function(x) { return !( x & 1 ); };
— 0x499602D2
source
5
+1, vous avez réponse à moi bat sans aucun doute, pour ne pas mentionner que vous avez la seule réponse qui n'utilise ! X % Y
— s0d4pop
4
Je ne sais pas si mon test est précis, mais l'ET au niveau du bit semble être 40 fois plus lent que l'opérateur modulo pour un nombre fixe et 2 fois plus lent pour un nombre aléatoire: jsperf.com/odd-or-even
— Blender
8
Notez que cela renverra "impair" ou "pair" pour les nombres qui ne le sont pas non plus (par exemple, 3.14).
— nnnnnn
2
Ou: function isEven(n){return !(n & 1);}.
— RobG
7
@Gnuey Chaque nombre est composé d'une série de bits. Tous les nombres impairs ont le bit le moins significatif (le plus à droite) défini sur 1, tous les nombres pairs 0. La x & 1vérification si le dernier bit est défini dans le nombre (car 1 est un nombre avec tous les bits définis sur 1, à l'exception du bit le moins significatif ): Si c'est , le nombre est impair, sinon même.
— 0x499602D2
31

Vous pouvez faire quelque chose comme ça:

function isEven(value){
    if (value%2 == 0)
        return true;
    else
        return false;
}
— TNC
source
9
Il ne semble pas que vous sachiez ce qu'est un booléen. if (condition) { answer=true; } else { answer=false; }est juste une version inutilement verbeuse de answer = (bool) condition;. Réduisez votre fonction à function isEven(value) { return (bool) (value%2 == 0); }et nous serons tous heureux.
— awm
9
Pas besoin d'être sarcastique, car je programme quelque chose différemment.
— TNC
5
@awm - Il semble que vous ne connaissiez pas JavaScript. Vous ne pouvez pas convertir en booléen avec (bool)(cela donnera une erreur) et dans tous les cas vous n'avez pas besoin de: return value%2 == 0;fera le travail puisque l' ==opérateur retourne un booléen.
— nnnnnn
2
Wow, ai-je vraiment écrit ça? Oui, c'est évidemment faux; devrait être quelque chose comme answer = !!(condition). Le point que j'essayais de faire valoir, bien sûr, c'est que vous pouvez return value%2==0et n'avez pas besoin de vous soucier du conditionnel.
— awm
Je le trouve élégant: value%2===0
— carlodurso
17 
function isEven(x) { return (x%2)==0; }
function isOdd(x) { return !isEven(x); }
— CloudyMarble
source
13

Dois-je faire un tableau vraiment grand qui a beaucoup de nombres pairs

Non. Utilisez le module (%). Il vous donne le reste des deux nombres que vous divisez.

Ex. 2 % 2 = 0 because 2/2 = 1 with 0 remainder.

Ex2. 3 % 2 = 1 because 3/2 = 1 with 1 remainder.

Ex3. -7 % 2 = -1 because -7/2 = -3 with -1 remainder.

Cela signifie que si vous modifiez un nombre x par 2, vous obtenez 0 ou 1 ou -1. 0 signifierait que c'est pair. Tout le reste signifierait que c'est étrange.

— Isaac Fife
source
8

Cela peut être résolu avec un petit extrait de code: 

function isEven(value) {
    if (value%2 == 0)
    return true;
else
    return false;
}

J'espère que cela t'aides :)

— s0d4pop
source
6

Comme de nombreuses langues, Javascript a un opérateur de module% , qui trouve le reste de la division. S'il n'y a pas de reste après la division par 2, un nombre est même:

// this expression is true if "number" is even, false otherwise
(number % 2 == 0)

Il s'agit d'un idiome très courant pour tester les entiers pairs.

— pb2q
source
3
Cependant, le module peut être délicat / indéfini pour les valeurs négatives. Assurez-vous de consulter la spécification de langue appropriée.
5

Une fonction simple que vous pouvez faire circuler. Utilise l'opérateur modulo %:

var is_even = function(x) {
    return !(x % 2); 
}

is_even(3)
false
is_even(6)
true
— dgh
source
1
Si vos résultats dans l'opérateur ternaire sont «vrais» ou «faux», vous n'avez vraiment pas besoin de l'opérateur ternaire. Ici, vous pourriez / devriez simplement faire:return !(x % 2);
— dom_watson
4

Utilisez mes extensions: 

Number.prototype.isEven=function(){
     return this % 2===0;
};

Number.prototype.isOdd=function(){
     return !this.isEven();
}

puis 

var a=5; 
 a.isEven();

== Faux

 a.isOdd();

== Vrai

si vous n'êtes pas sûr qu'il s'agisse d'un nombre, testez-le par la branche suivante: 

if(a.isOdd){
    a.isOdd();
}

METTRE À JOUR :

si vous n'utilisez pas de variable: 

(5).isOdd()

Performances:

Il s'avère que le paradigme procédural est meilleur que le paradigme OOP. Soit dit en passant, j'ai effectué le profilage dans ce FIDDLE . Cependant, la méthode OOP est toujours la plus jolie.

entrez la description de l'image ici

— Abdennour TOUMI
source
Merci mec, pour cette logique, une personne interrogée a demandé ce genre de logique, ne pouvait pas répondre, maintenant je l'ai, merci .. mais y a-t-il un avantage en termes de performances en suivant cette méthode? nous aurions pu écrire isEven (x); etc.
— Shoib Mohammed A
@ShoibMohammedA: La comparaison a été faite! jsfiddle.net/abdennour/jL2uyksa/3
— Abdennour TOUMI
-1 ne pas étendre les fonctions natives du prototype. ( stackoverflow.com/questions/14034180/… )
— tfmontague
3

Soustrayez-y récursivement jusqu'à ce que vous atteigniez -1 ou 0 (ne fonctionne évidemment que pour les entiers positifs) :)

— asymétrique
source
Avec des nombres négatifs, vous augmentez plutôt 2
— Hydroper
Et cela prend un temps
— fou
3

Vous pouvez utiliser une instruction for et un conditionnel pour déterminer si un nombre ou une série de nombres est impair:

for (var i=1; i<=5; i++) 
if (i%2 !== 0) {
    console.log(i)
}

Cela imprimera chaque nombre impair compris entre 1 et 5.

— bâtard effronté
source
3

Je viens d'exécuter celui-ci dans Adobe Dreamweaver..il fonctionne parfaitement. j'ai utilisé if (isNaN (mynmb))

pour vérifier si la valeur donnée est un nombre ou non, et j'ai également utilisé Math.abs (mynmb% 2) pour convertir un nombre négatif en positif et calculer

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>

</head>
<body bgcolor = "#FFFFCC">
    <h3 align ="center"> ODD OR EVEN </h3><table cellspacing = "2" cellpadding = "5" bgcolor="palegreen">
        <form name = formtwo>
            <td align = "center">
                <center><BR />Enter a number: 
                    <input type=text id="enter" name=enter maxlength="10" />
                    <input type=button name = b3 value = "Click Here" onClick = compute() />
                      <b>is<b> 
                <input type=text id="outtxt" name=output size="5" value="" disabled /> </b></b></center><b><b>
                <BR /><BR />
            </b></b></td></form>
        </table>

    <script type='text/javascript'>

        function compute()
        {
          var enter = document.getElementById("enter");
          var outtxt = document.getElementById("outtxt");

          var mynmb = enter.value;
          if (isNaN(mynmb)) 
          { 
            outtxt.value = "error !!!"; 
            alert( 'please enter a valid number');
            enter.focus();
            return;
          }
          else 
          { 
             if ( mynmb%2 == 0 ) { outtxt.value = "Even"; }  
             if ( Math.abs(mynmb%2) == 1 ) { outtxt.value = "Odd"; }
          }
        }

    </script>
</body>
</html>
— Srivastav
source
3 
   <script>
        function even_odd(){
            var num =   document.getElementById('number').value;

            if ( num % 2){
                document.getElementById('result').innerHTML = "Entered Number is Odd";
            }
            else{
                document.getElementById('result').innerHTML = "Entered Number is Even";
            }
        }
    </script>
</head>
<body>
    <center>
        <div id="error"></div>
        <center>
            <h2> Find Given Number is Even or Odd </h2>
            <p>Enter a value</p>
            <input type="text" id="number" />
            <button onclick="even_odd();">Check</button><br />
            <div id="result"><b></b></div>
        </center>
    </center>
</body>
— Kirandeep Singh
source
2 
if (X % 2 === 0){
} else {
}

Remplacez X par votre numéro (peut provenir d'une variable). L'instruction If s'exécute lorsque le nombre est pair, Else lorsqu'il est impair.

Si vous voulez simplement savoir si un nombre donné est impair:

if (X % 2 !== 0){
}

Encore une fois, remplacez X par un nombre ou une variable.

— Gui Premonsa
source
2

Chaque nombre impair lorsqu'il est divisé par deux feuilles reste comme 1 et chaque nombre pair lorsqu'il est divisé par zéro laisse un zéro comme reste. Par conséquent, nous pouvons utiliser ce code

  function checker(number)  {
   return number%2==0?even:odd;
   }
— Auguste François
source
2

Que dis-tu de ça...

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

    alert(aa[num % 2]);
— AndroidManifester
source
2

C'est ce que j'ai fait

//Array of numbers
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,32,23,643,67,5876,6345,34,3453];
//Array of even numbers
var evenNumbers = [];
//Array of odd numbers
var oddNumbers = [];

function classifyNumbers(arr){
  //go through the numbers one by one
  for(var i=0; i<=arr.length-1; i++){
     if (arr[i] % 2 == 0 ){
        //Push the number to the evenNumbers array
        evenNumbers.push(arr[i]);
     } else {
        //Push the number to the oddNumbers array
        oddNumbers.push(arr[i]);
     }
  }
}

classifyNumbers(numbers);

console.log('Even numbers: ' + evenNumbers);
console.log('Odd numbers: ' + oddNumbers);

Pour une raison quelconque, j'ai dû m'assurer que la longueur du tableau est inférieure de un. Lorsque je ne fais pas cela, j'obtiens "undefined" dans le dernier élément du tableau oddNumbers.

— Zakher Masri
source
2
C'est parce que la condition est inférieure ou égale à "<=" à la longueur du tableau. J'ai supprimé le signe égal et le résultat était comme souhaité.
— Zakher Masri
2

Lorsque vous devez tester si une variable est impaire, vous devez d'abord tester si elle est entière . Notez également que lorsque vous calculez le reste sur un nombre négatif, le résultat sera négatif ( -3 % 2 === -1).

function isOdd(value) {
  return typeof value === "number" && // value should be a number
    isFinite(value) &&                // value should be finite
    Math.floor(value) === value &&    // value should be integer
    value % 2 !== 0;                  // value should not be even
}

Si Number.isInteger est disponible, vous pouvez également simplifier ce code pour:

function isOdd(value) {
  return Number.isInteger(value)      // value should be integer
    value % 2 !== 0;                  // value should not be even
}

Remarque: ici, nous testons value % 2 !== 0au lieu de value % 2 === 1c'est à cause de -3 % 2 === -1. Si vous ne voulez pas -1réussir ce test, vous devrez peut-être modifier cette ligne.

Voici quelques cas de test:

isOdd();         // false
isOdd("string"); // false
isOdd(Infinity); // false
isOdd(NaN);      // false
isOdd(0);        // false
isOdd(1.1);      // false
isOdd("1");      // false
isOdd(1);        // true
isOdd(-1);       // true
— tsh
source
2

L'utilisation %vous aidera à le faire ...

Vous pouvez créer quelques fonctions pour le faire pour vous ... Je préfère les fonctions séparées qui ne sont pas attachées à Number en Javascript comme ceci qui vérifient également si vous passez un nombre ou non:

fonction impaire:

var isOdd = function(num) {
  return 'number'!==typeof num ? 'NaN' : !!(num % 2);
};

même fonction:

var isEven = function(num) {
  return isOdd(num)==='NaN' ? isOdd(num) : !isOdd(num);
};

et appelez-le comme ceci:

isOdd(5); // true
isOdd(6); // false
isOdd(12); // false
isOdd(18); // false
isEven(18); // true
isEven('18'); // 'NaN'
isEven('17'); // 'NaN'
isOdd(null); // 'NaN'
isEven('100'); // true
— Alireza
source
2

Un liner en ES6 juste parce qu'il est propre.

const isEven = (num) => num % 2 == 0;

— damdeez
source
2

Beaucoup de gens comprennent mal le sens de l'étrange

  • isOdd("str")devrait être faux.
    Seul un entier peut être impair.
  • isOdd(1.223)et isOdd(-1.223)devrait être faux.
    Un flottant n'est pas un entier.
  • isOdd(0)devrait être faux.
    Zéro est un entier pair ( https://en.wikipedia.org/wiki/Parity_of_zero ).
  • isOdd(-1)devrait être vrai.
    C'est un entier impair.

Solution

function isOdd(n) {

  // Must be a number
  if (isNaN(n)) {
    return false;
  }

  // Number must not be a float
  if ((n % 1) !== 0) {
    return false;
  }

  // Integer must not be equal to zero
  if (n === 0) {
    return false;
  }

  // Integer must be odd
  if ((n % 2) !== 0) {
    return true;
  }

  return false;
}

JS Fiddle (si nécessaire): https://jsfiddle.net/9dzdv593/8/

1 doublure

Solution Javascript 1 ligne. Pour ceux qui ne se soucient pas de la lisibilité.

const isOdd = n => !(isNaN(n) && ((n % 1) !== 0) && (n === 0)) && ((n % 2) !== 0) ? true : false;
— tfmontague
source
Vous pouvez encore accélérer la solution. c'est-à-dire que dans les déclarations finales, vous pouvez simplement retourner !! (n% 2), cela le fera éventuellement fonctionner avec des nombres signés (c'est-à-dire que lorsque n% 2 renvoie 0, c'est faux, mais lorsque -1 ou 1 sont retournés, cela retour vrai). Votre solution retourne en fait faux pour les nombres impairs car elle vérifie si le module retourne 0, mais devrait vérifier 1, et 1 échouerait pour les nombres négatifs, donc le retour !! (n% 2) est plus sûr. Et de toute façon, {} (instruction de bloc) ne cause pas de problèmes de minification et n'est pas présent dans la discussion.
— Hydroper
@TheProHands - Merci pour les notes. (1) Le problème était que la version Modulus avait une faute de frappe; il aurait dû être (n % 2) !== 0au lieu de (n % 2) === 0. (2) Mon conseil est d'éviter !!(n % 2), parce que (a) il a des performances plus lentes que (n % 2) !== 0( jsperf.com/notnot-vs-strict-not ), (b) c'est un hack - il contraint une valeur de falsey 0dans false, et (c) c'est obscur (les langages de programmation de haut niveau ne devraient pas lire comme Pascal pour des raisons de performances - c'est le travail du compilateur). (3) Oui, les {}déclarations de bloc manquantes entraînent plusieurs problèmes (comme mis à jour dans ma réponse).
— tfmontague
Je n'évite jamais les instructions de bloc parce que je me soucie de la lisibilité, mais j'essaie de dire que la recherche d'instructions de bloc n'entraîne pas de problèmes, uniquement dans la maintenance du code. C'est-à-dire, l'utilisation d'expressions de séquence fusionnées avec une instruction d'expression au lieu d'une instruction de bloc peut rendre le code illisible et laid, c'est-à-dire:, if (0) call1(), assign = 0, call2()mais une seule instruction n'est pas mauvaise if (0) return; if (0) ;; if (0); break; if (0) continue;:, et de toute façon je préfère continuer à utiliser des instructions de bloc de ligne de rupture quand j'ai conditions longues en ligne.
— Hydroper
contrôles de type / null comme votre isNaN(n)sont stupides - que vous avez couvert le NaNcas, mais isOdd(null), isOdd(undefined), isOdd({x:1})tout retour falseque je considère comme une erreur; à moins bien sûr que vous spécifiez seulement que votre fonction a un comportement correct sur un domaine donné: uniquement des entrées de type numérique. Dans ce cas, déposez simplement le isNaNchèque et forcez l'utilisateur à l'appeler avec le type correct. La programmation défensive est horrible. Ensuite, votre fonction est simplifiée isOdd = x => Math.floor(x) === x && x & 1 === 1- renvoyer des valeurs explicites trueou falseinutiles
— Merci
null, undefinedet les objets {}ne sont pas des entiers impairs, et donc la fonction retourne false- vous ne savez pas pourquoi vous considérez cela comme une erreur. Le isNaNcontrôle est pour les performances (pas pour la défense), il permet de quitter la fonction prématurément sans effectuer les autres contrôles.
— tfmontague
1

J'implémenterais ceci pour retourner un booléen:

function isOdd (n) {
    return !!(n % 2);
    // or ((n % 2) !== 0).
}

Cela fonctionnera sur les numéros non signés et signés. Lorsque le module reviendra -1ou 1il sera traduit entrue .

Solution sans module:

var is_finite = isFinite;
var is_nan = isNaN;

function isOdd (discriminant) {
    if (is_nan(discriminant) && !is_finite(discriminant)) {
        return false;
    }

    // Unsigned numbers
    if (discriminant >= 0) {
        while (discriminant >= 1) discriminant -= 2;

    // Signed numbers
    } else {
        if (discriminant === -1) return true;
        while (discriminant <= -1) discriminant += 2;
    }

    return !!discriminant;
}
— Hydroper
source
1

Une approche plus fonctionnelle en javascript moderne:

const NUMBERS = "nul one two three four five six seven ocho nueve".split(" ")

const negate = f=> (...args)=> !f(...args)
const isOdd  = n=> NUMBERS[n % 10].indexOf("e")!=-1
const isEven = negate(isOdd)
— gunn
source
1

dans ES6:

const isOdd = num => num % 2 == 1;

— Darryl Mendonez
source
3
Lors de l'ajout d'une réponse à une question de huit ans avec 26 réponses existantes, il est vraiment utile d'expliquer quel nouvel aspect de la question votre réponse répond, et si le passage du temps et les nouvelles versions ont un impact sur la réponse. Une réponse codée uniquement peut presque toujours être améliorée par l'ajout d'explications et dans ce cas, d'exemples d'appels montrant l'utilisation.
— Jason Aller
1
le titre est «Comment déterminer si un nombre est impair en JavaScript» et aucune solution ES6 n'a été publiée pour ce qui est demandé.
— Darryl Mendonez
0

En utilisant l'opérateur ternaire, vous pouvez trouver les nombres pairs impairs:

var num = 2;
result = (num % 2 == 0) ? 'even' : 'odd'
console.log(result);
Développer l'extrait

— Mahendra Kulkarni
source
0

cela fonctionne pour les tableaux:

function evenOrOdd(numbers) {
  const evenNumbers = [];
  const oddNumbers = [];
  numbers.forEach(number => {
    if (number % 2 === 0) {
      evenNumbers.push(number);
    } else {
      oddNumbers.push(number);
    }
  });

  console.log("Even: " + evenNumbers + "\nOdd: " + oddNumbers);
}

evenOrOdd([1, 4, 9, 21, 41, 92]);

cela devrait se déconnecter: 4,92 1,9,21,41

pour un certain nombre:

function evenOrOdd(number) {
  if (number % 2 === 0) {
    return "even";
  }

  return "odd";
}

console.log(evenOrOdd(4));

cela devrait sortir même sur la console

— JuicY_Burrito
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.