Как определить, является ли число нечетным в JavaScript

245

Может кто-нибудь указать мне код, чтобы определить, является ли число в JavaScript четным или нечетным?

javascript 
— Янни Теуниссен
источник
6
— epascarello
1
@DavidThomas Я частично согласен, но у меня есть два предостережения: 1. Если бы мне пришлось выбирать, я бы предпочел начинающему программисту знать об %операторе, чем &, и 2. Хотя &теоретически это быстрее, это действительно не имеет значения .
— Кодзиро
3
@kojiro: Я предпочел бы, чтобы больше (действительных) вариантов было представлено ученику; Кроме того, я никогда не думал использовать битовую - и таким образом, так что это интересный вариант. Во всяком случае, так как это простофиля, я пометил для слияния с ранее существовавшим вопросом. Надеюсь, что ответы здесь (по крайней мере, этот конкретный ответ) не будут потеряны.
— Дэвид говорит восстановить Монику
1
@kojiro Боюсь сказать, что ваша скрипка совершенно бесполезна, так как большая часть вычислительного времени уходит на вызовы функций. Но никто не будет использовать вызов функции, чтобы определить, является ли число нечетным или четным ... Я сделал третью версию вашего теста, но я сейчас на своем телефоне ...
— MaxArt
1
— bummi

Ответы:

347

Используйте следующий код:

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 представляет нечетное число, а 0 представляет четное число.

— чий
источник
97
Обратите внимание, что это вернет 0или 1(или NaNесли вы передадите ему что-то, что не является числом и не может быть приведено к одному), что будет хорошо работать в большинстве ситуаций. Но если вам нужен настоящий trueили false:return (num % 2) == 1;
— TJ Crowder
3
да хорошая заметка о NaN. Но обычно вы хотите, чтобы javascript был правдивым или фальшивым, поэтому я написал так, как сделал.
— Chii
9
Просто чтобы уточнить, оператор по модулю (%) дает остаток от деления. Таким образом, 3% 2 будет 3/2, оставляя 1 в качестве остатка, поэтому 3% 2 вернется 1.
— Abuh
6
В дополнение к тому, что сказал TJ, это вернет дробь, если numне является целым числом. Который все еще будет работать, если вы сравните isOdd(1.5)==true(потому что дробное значение не равно true), но было бы лучше, если бы функция возвращала trueили falseподразумевала имя «isOdd».
— nnnnnn
6
Вы также можете сделать, return !!(num % 2)чтобы получить логическое значение
— Дункан
115

Используйте побитовый ANDоператор.

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>
Развернуть фрагмент

Если вам не нужно возвращаемое строковое значение, а скорее логическое, используйте это:

var isOdd = function(x) { return x & 1; };
var isEven  = function(x) { return !( x & 1 ); };
— 0x499602D2
источник
5
+1, ваш ответ определенно превосходит мой, не говоря уже о том, что у вас есть единственный ответ, который не использует X % Y!
— s0d4pop
4
Я не уверен, что мой тест точен, но побитовое И кажется в 40 раз медленнее, чем оператор по модулю для фиксированного числа, и в 2 раза медленнее для случайного числа: jsperf.com/odd-or-even
— Blender
8
Обратите внимание, что это вернет «нечетное» или «четное» для чисел, которые не являются (например, 3.14).
— nnnnnn
2
Или: function isEven(n){return !(n & 1);}.
— RobG
7
@Gnuey Каждое число состоит из серии битов. Все нечетные числа имеют младший значащий (самый правый) бит, установленный в 1, все четные числа 0. x & 1Проверяет, установлен ли последний бит в числе (потому что 1 - это число со всеми битами, установленными в 1, за исключением младшего значащего бита. ): Если это число нечетное, иначе даже.
— 0x499602D2
31

Вы могли бы сделать что-то вроде этого:

function isEven(value){
    if (value%2 == 0)
        return true;
    else
        return false;
}
— TNC
источник
9
Не похоже, что вы знаете, что такое логическое значение. if (condition) { answer=true; } else { answer=false; }это просто излишне многословная версия answer = (bool) condition;. Снизь свою функцию function isEven(value) { return (bool) (value%2 == 0); }и мы все будем счастливы.
— AWM
9
Не нужно зацикливаться, потому что я программирую что-то по-другому.
— TNC
5
@awm - Кажется, ты не знаешь JavaScript. Вы не можете привести к логическому значению с (bool)(что return value%2 == 0;приведет к ошибке), и в любом случае вам не нужно: выполнит работу, так как ==оператор возвращает логическое значение.
— nnnnnn
2
Вау, я действительно это написал? Да, это явно не так; должно быть что - то вроде answer = !!(condition). Конечно, я хотел сказать, что вы можете просто return value%2==0и не нужно беспокоиться об условном.
— AWM
Я нахожу это элегантным: value%2===0
— Карлодурсо
13

Должен ли я сделать массив действительно большой, который имеет много четных чисел

№ Используйте модуль (%). Это дает вам остаток от двух чисел, которые вы делите.

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.

Это означает, что если вы измените любое число х на 2, вы получите либо 0, либо 1, либо -1. 0 будет означать, что это даже. Все остальное будет означать, что это странно.

— Исаак Файф
источник
8

Это можно решить с помощью небольшого фрагмента кода: 

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

Надеюсь это поможет :)

— s0d4pop
источник
6

Как и во многих языках, в Javascript есть оператор модуля% , который находит остаток от деления. Если после деления на 2 остатка нет, число четное:

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

Это очень распространенная идиома для проверки четных чисел.

— pb2q
источник
3
Тем не менее, модуль может быть хитрым / неопределенным для отрицательных значений. Обязательно обратитесь к соответствующей спецификации языка.
5

Простая функция, которую вы можете передать. Использует оператор по модулю %:

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

is_even(3)
false
is_even(6)
true
— рБоп
источник
1
Если ваши результаты в тернарном операторе имеют значение «истина» или «ложь», вам действительно не нужен троичный оператор. Здесь вы можете / должны просто сделать:return !(x % 2);
— dom_watson
4

Используйте мои расширения: 

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

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

затем 

var a=5; 
 a.isEven();

== Ложные

 a.isOdd();

== Правда

если вы не уверены, что это число, проверьте его следующим ветвлением: 

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

ОБНОВИТЬ :

если бы вы не использовали переменную: 

(5).isOdd()

Производительность :

Оказывается, что процедурная парадигма лучше, чем парадигма ООП. Кстати, я выполнил профилирование в этой FIDDLE . Тем не менее, ООП способ по-прежнему красивее.

введите описание изображения здесь

— Абденнур ТУМИ
источник
Спасибо, чувак, за эту логику, в интервьюируемом кто-то спросил такую ​​логику, не смог ответить, теперь я понял, спасибо .. но есть ли какая-то выгода в производительности, следуя этому методу? мы могли бы написать isEven (x); и т. д.
— Шойб Мохаммед
@ShoibMohammedA: сравнение было сделано! jsfiddle.net/abdennour/jL2uyksa/3
— Abdennour TOUMI
-1 не расширяют функции собственного прототипа. ( stackoverflow.com/questions/14034180/… )
— tfmontague
3

Вычтите 2 к нему рекурсивно, пока не достигнете -1 или 0 (очевидно, работает только для натуральных чисел) :)

— асимметричный
источник
С отрицательными числами вы вместо того, чтобы увеличить 2 к ней
— Hydroper
И это требует адского времени, когда n = 2 ^ 52, и бесконечного количества для n> 2 ^ 53
— rioV8
3

Вы можете использовать оператор for и условное выражение, чтобы определить, является ли число или серия чисел нечетным:

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

Это будет печатать каждое нечетное число от 1 до 5.

— нахальный ублюдок
источник
3

Только что выполнил этот в Adobe Dreamweaver .. он работает отлично. я использовал, если (isNaN (mynmb))

чтобы проверить, является ли данное значение числом или нет, я также использовал Math.abs (mynmb% 2), чтобы преобразовать отрицательное число в положительное и вычислить

    <!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
источник
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>
— Кирандип Сингх
источник
2 
if (X % 2 === 0){
} else {
}

Замените X своим номером (может быть из переменной). Оператор If выполняется, когда число является четным, иначе, если оно нечетное.

Если вы просто хотите узнать, является ли любое заданное число нечетным:

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

Снова замените X числом или переменной.

— Gui Premonsa
источник
2

Каждое нечетное число при делении на два оставляет остаток как 1, а каждое четное число при делении на ноль оставляет остаток как остаток. Следовательно, мы можем использовать этот код

  function checker(number)  {
   return number%2==0?even:odd;
   }
— Август Фрэнсис
источник
2

Это то что я сделал

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

По какой-то причине мне пришлось убедиться, что длина массива меньше на единицу. Когда я этого не делаю, я получаю «undefined» в последнем элементе массива oddNumbers.

— Захер Масри
источник
2
Это потому, что условие меньше или равно "<=" длине массива. Я удалил знак равенства, и результат был по желанию.
— Захер Масри
2

Когда вам нужно проверить, является ли какая-то переменная нечетной, вы должны сначала проверить, является ли она целочисленной . Также обратите внимание, что когда вы вычисляете остаток по отрицательному числу, результат будет отрицательным ( -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
}

Если Number.isInteger доступен, вы также можете упростить этот код до:

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

Примечание: здесь мы тестируем, value % 2 !== 0а value % 2 === 1не из-за -3 % 2 === -1. Если вы не хотите -1проходить этот тест, вам может потребоваться изменить эту строку.

Вот несколько тестов:

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
— ТТГ
источник
2

С помощью % поможет вам сделать это ...

Вы можете создать несколько функций, чтобы сделать это для вас ... Я предпочитаю отдельные функции, которые не привязаны к числу в Javascript, как это, которое также проверяет, передаете ли вы номер или нет:

нечетная функция:

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

четная функция:

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

и назовите это так:

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
— Алиреза
источник
2

Один вкладыш в ES6 только потому, что он чистый.

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

— damdeez
источник
2

Многие люди неправильно понимают значение странного

  • isOdd("str")должно быть ложным.
    Только целое число может быть нечетным.
  • isOdd(1.223)и isOdd(-1.223)должен быть ложным.
    Число с плавающей запятой не является целым числом.
  • isOdd(0)должно быть ложным.
    Ноль - это четное целое число ( https://en.wikipedia.org/wiki/Parity_of_zero ).
  • isOdd(-1)должно быть правдой.
    Это странное целое число.

Решение

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 (при необходимости): https://jsfiddle.net/9dzdv593/8/

1-лайнер

Javascript 1-лайнер решение. Для тех, кто не заботится о читабельности.

const isOdd = n => !(isNaN(n) && ((n % 1) !== 0) && (n === 0)) && ((n % 2) !== 0) ? true : false;
— tfmontague
источник
Вы можете ускорить решение еще. т. е. в последних выражениях, которые вы можете просто вернуть !! (n% 2), это при желании заставит его работать со знаковыми числами (т. е. когда n% 2 возвращает 0, это ложно, но когда возвращается -1 или 1, это будет верните истину). Ваше решение на самом деле возвращает false для нечетных чисел, так как оно проверяет, равен ли модуль возврата 0, но должно проверять 1, а 1 - для отрицательных чисел, поэтому возврат !! (n% 2) безопаснее. И в любом случае, {} (оператор блока) не вызывает проблем минимизации и не присутствует в обсуждении.
— Hydroper
@TheProHands - Спасибо за заметки. (1) Проблема заключалась в том, что в Модульной версии была опечатка; это должно было быть (n % 2) !== 0вместо (n % 2) === 0. (2) Мой совет , чтобы избежать !!(n % 2), потому что (а) он имеет меньшую производительность , чем (n % 2) !== 0( jsperf.com/notnot-vs-strict-not ), (б) это хак - это принуждает значение falsey 0в false, и (с) это неясно (языки программирования высокого уровня не должны читать как Паскаль ради производительности - это работа компилятора). (3) Да, пропущенные {}операторы блока приводят к нескольким проблемам (как обновлено в моем ответе).
— 17
Я никогда не избегаю блоковых операторов, потому что меня интересует удобочитаемость, но я пытаюсь сказать, что поиск блочных операторов не приводит к проблемам, только в поддержке кода. То есть, использование выражений последовательности, объединенных с оператором выражения вместо оператора блока, может сделать код нечитаемым и уродливым, т. Е. if (0) call1(), assign = 0, call2(), Но один оператор не является плохим if (0) return; if (0) ;; if (0); break; if (0) continue;, и в любом случае я предпочитаю продолжать использовать операторы блока строк, когда долго-линейные условия.
— Hydroper
проверяет тип / нуль , как ваш isNaN(n)глупы - что вы покрыли NaNдело, но isOdd(null), isOdd(undefined), isOdd({x:1})все возвращения , falseкоторые я считаю ошибкой; если, конечно, вы только указываете, что ваша функция ведет себя корректно в данном домене: только входы числового типа. В этом случае просто сбросьте isNaNчек и заставьте пользователя вызывать его с правильным типом. Оборонительное программирование ужасно. Тогда ваша функция упрощается до isOdd = x => Math.floor(x) === x && x & 1 === 1- возвращать явные trueили falseзначения не нужны
— спасибо
null, undefinedи объекты {}не являются нечетными целыми числами, и поэтому функция возвращает false- не уверен, почему вы считаете это ошибкой. isNaNПроверка для выполнения (не для защиты), она позволяет функцию выхода преждевременно , без выполнения других проверок.
— tfmontague
1

Я бы реализовал это, чтобы вернуть логическое значение:

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

Он будет работать как на неподписанных, так и на подписанных номерах. Когда модуль вернется -1или 1будет переведен true.

Немодульное решение:

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
источник
1

Более функциональный подход в современном javascript:

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)
— Ганна
источник
1

в ES6:

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

— Дэррил Мендонес
источник
3
При добавлении ответа на восьмилетний вопрос с 26 существующими ответами действительно полезно объяснить, к какому новому аспекту вопроса относится ваш ответ, и влияет ли время и новые версии на ответ. Ответ только на код почти всегда может быть улучшен добавлением некоторого объяснения, и в этом случае некоторые примеры вызовов показывают использование.
— Джейсон Аллер
1
заголовок «Как определить, является ли число нечетным в JavaScript», и не было опубликовано решение ES6 для ответа на вопрос.
— Дэррил Мендонес
0

это работает для массивов:

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

это должно выйти из системы: 4,92 1,9,21,41

всего за номер:

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

  return "odd";
}

console.log(evenOrOdd(4));

это должно выводиться даже на консоль

— JuicY_Burrito
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.