Comment déterminer si un nombre est impair en JavaScript
Quelqu'un peut-il me pointer vers un code pour déterminer si un nombre en JavaScript est pair ou impair?
26 réponses
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));1 représente un nombre impair, tandis que 0 représente un nombre pair.
Utilisez le bit AND opérateur.
function oddOrEven(x) {
return ( x & 1 ) ? "odd" : "even";
}
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 ); };
Vous pouvez faire quelque chose comme ceci:
function isEven(value){
if (value%2 == 0)
return true;
else
return false;
}
function isEven(x) { return (x%2)==0; }
function isOdd(x) { return !isEven(x); }
Dois-je faire un tableau vraiment grand qui a beaucoup de nombres pairs
Oh! mon dieu non. Utiliser le modulo (%). 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. Toute autre chose signifierait que c'est étrange.
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 aide :)
Comme beaucoup de langages, Javascript a un opérateur de module %, Cela trouve le reste de la division. S'il n'y a pas de reste après la division par 2, un nombre est pair:
// this expression is true if "number" is even, false otherwise
(number % 2 == 0)
C'est un idiome très commun pour tester des entiers pairs.
Une fonction simple que vous pouvez passer autour. Utilise l'opérateur modulo % et l'opérateur ternaire ?.
var is_even = function(x) {
return !(x % 2);
}
is_even(3)
false
is_even(6)
true
Utiliser mes extensions :
Number.prototype.isEven=function(){
return this % 2===0;
};
Number.prototype.isOdd=function(){
return !this.isEven();
}
Puis
var a=5;
a.isEven();
= = False
a.isOdd();
= = True
Si vous n'êtes pas sûr qu'il s'agit d'un nombre, testez-le par la ramification suivante:
if(a.isOdd){
a.isOdd();
}
Mise à jour:
Si vous n'utilisez pas la variable:
(5).isOdd()
Performance:
Il s'avère que le paradigme procédural est meilleur que le paradigme POO . Au fait, j'ai effectué profilage dans ce violon . Cependant, la POO est toujours la plus jolie .
Avec bitwise, codegolfing:
var isEven=n=>(n&1)?"odd":"even";
Soustrayez 2 récursivement jusqu'à ce que vous atteigniez -1 ou 0 (ne fonctionne que pour les entiers positifs évidemment):)
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 entre 1 et 5.
Vient d'exécuter celui-ci dans Adobe Dreamweaver..it fonctionne parfaitement. j'ai utilisé if (isNaN(mynmb))
Pour vérifier si la Valeur donnée est un nombre ou non, et j'ai aussi utilisé Mathématiques.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>
<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>
if (X % 2 === 0){
} else {
}
Remplacez X par votre numéro (peut provenir d'une variable). Si l'instruction s'exécute lorsque le nombre est pair, l'Autre quand il est impair.
Si vous voulez juste savoir si un nombre donné est Impair:
if (X % 2 !== 0){
}
Encore une fois, remplacez X par un nombre ou une variable.
Chaque nombre impair lorsqu'il est divisé par deux laisse le 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;
}
Que diriez-vous de ceci...
var num = 3 //instead get your value here
var aa = ["Even", "Odd"];
alert(aa[num % 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, je devais m'assurer que la longueur du tableau est inférieure à un. Quand je ne fais pas cela, je reçois "undefined" dans le dernier élément du tableau oddNumbers.
Lorsque vous devez tester si une variable est impaire, vous devez d'abord tester s'il s'agit d'un entier. Notez également que lorsque vous calculez le reste sur le 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 Nombre.isInteger est disponible, vous pouvez également simplifier ce code:
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 !== 0 au lieu de value % 2 === 1 est à cause de -3 % 2 === -1. Si vous ne voulez pas que -1 réussisse ce test, vous devrez peut-être changer cette ligne.
Voici quelques tests cas:
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
Attention! J'ai vérifié toutes les autres réponses, et elles ne sont pas correctes.
Seul un entier peut être Impair.
-
isOdd("someString")devrait être faux.
Une chaîne n'est pas un entier. -
isOdd(1.223)etisOdd(-1.223)devraient être faux.
Un flotteur 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.
Mon 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/
Raisonnement qui est entré dans le code
- le type de retour doit être un booléen. Les mots-clés
trueoufalsesont natifs, il n'est donc pas nécessaire de retourner-strings, 0 ou 1-qui ont des significations ambiguës. - la convention Javascript consiste à utiliser camel-case
isOdd - Un
ifdéclaration doit avoir des accolades{}. Les accolades manquantes peuvent entraîner problèmes de minification, compilation Javascript plus lente et illisibilité du code si un problème de formatage se produit.
Utiliser % vous aidera à le faire...
, Vous pouvez créer quelques fonctions pour le faire pour vous... Je préfère les fonctions separte qui ne sont pas attachées au nombre en Javascript comme ceci qui vérifie également si vous passez le 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
J'implémenterais ceci pour retourner un booléen:
function isOdd (n) {
return !!(n % 2);
// or ((n % 2) !== 0).
}
Cela fonctionnera à la fois sur les numéros non signés et signés. Lorsque le module retourne -1 ou 1, il sera traduit en true.
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;
}
var sumSoFar = 0;
var oddnumber=0;
function Sum(data){
for(var i=0;i<data.length;i++){
if(data[i] % 2 == 1){
console.log(data[i]);
sumSoFar += data[i];
}else{
oddnumber+= data[i];
} }
console.log(sumSoFar);
console.log(oddnumber);
}
var sumOfNum=Sum([3,2,4,5,4,3,3,4,3,6,4]);
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)
Voici un exemple de travail simple:
function myFunction() {
userInput = document.getElementById("myValue").value;
if (userInput%2 == 0) {
document.getElementById("demo").innerHTML= "even";
} else {
document.getElementById("demo").innerHTML = "odd";
}Input:<input id="myValue">
<button onclick="myFunction()">Try it</button>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);