Tester si une valeur est pair ou impair
, j'ai décidé de créer simple isEven et isOdd function 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 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 javascript sont testés, tout le reste renvoie false (y compris + et - infinity). 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 toutes les questions ci-dessus? Existe-t-il une version meilleure (c'est-à-dire plus précise, plus rapide ou plus concise sans être obscurcie)?
Il y a plusieurs articles relatifs à d'autres langues, mais je n'arrive pas à trouver une 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 où j'en étais, pas comme quelque chose à revoir. Réponses postées jusqu'à présent semblent obtenir.
Modifier 2
Une fonction finale, 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, numéros de retour soit true ou false. Cela pourrait être une fonction avec un drapeau strict, mais je pense que la comparaison stricte n'est pas vraiment nécessaire.
15 réponses
Utiliser 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 devrait de préférence être effectuée en dehors des fonctions isEven et isOdd, de sorte que vous n'avez pas à dupliquer la gestion des erreurs dans les deux fonctions.
Je préfère utiliser un test de bits:
if(i & 1)
{
// ODD
}
else
{
// EVEN
}
Ceci teste si le premier bit est sur lequel signifie un nombre impair.
Que diriez-vous de ce qui suit? J'ai seulement testé cela dans IE, mais il é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 sontpas 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 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);
}
Pourquoi ne pas simplement faire ceci:
function oddOrEven(num){
if(num % 2 == 0)
return "even";
return "odd";
}
oddOrEven(num);
var isEven = function(number) {
// Your code goes here!
if (number % 2 == 0){
return(true);
}
else{
return(false);
}
};
Une simple modification / amélioration de Steve Mayne réponse!
function isEvenOrOdd(n){
if(n === parseFloat(n)){
return isNumber(n) && (n % 2 == 0);
}
return false;
}
Remarque: renvoie false si invalide!
Manière différente:
var isEven = function(number) {
// Your code goes here!
if (((number/2) - Math.floor(number/2)) === 0) {return true;} else {return false;};
};
isEven(69)
Autrement en utilisant des chaînes parce que pourquoi pas
function isEven(__num){
return String(__num/2).indexOf('.') === -1;
}
if (testNum == 0);
else if (testNum % 2 == 0);
else if ((testNum % 2) != 0 );
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');
}
}
Utiliser le 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)
Moyen Simple de tester si un nombre utilise même JavaScript
function isEven(x) {
//return true if even
if (x % 2 === 0) {
return true;
}
//return false otherwise
else {
return false
}
}
// or much simpler
function isEven(x) {
return x % 2 === 0;
}
Celui - ci est plus simple!
var num = 3 //instead get your value here
var aa = ["Even", "Odd"];
alert(aa[num % 2]);