В этой статье рассмотрим несколько подходов - от простого оператора модуля до битовых операций и регулярных выражений. Каждый метод имеет свои плюсы, и выбор зависит от конкретной ситуации и требований к коду.

Оператор модуля - самый простой способ

Оператор модуля (%) возвращает остаток от деления одного числа на другое. Это самый понятный и распространенный способ проверки четности. Если число четное, то при делении на 2 остаток будет 0, если нечетное - остаток будет 1.

Для четных чисел выражение число % 2 === 0 вернет true, а для нечетных - false. Это работает просто и интуитивно понятно даже начинающим разработчикам. Метод надежен, универсален и не требует дополнительных знаний о битовых операциях или других хитростях.

Вот как это выглядит в коде:

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

let number = 10;
if (isEven(number)) {
  console.log(number + " является четным числом.");
} else {
  console.log(number + " является нечетным числом.");
}

Примеры использования:

• isEven(10) вернет true - число четное
• isEven(3) вернет false - число нечетное
• isEven(0) вернет true - ноль считается четным числом

Битовые операции для большей скорости

Если нужна максимальная производительность, особенно при работе с огромными объемами данных, можно использовать побитовый оператор AND (&). Этот способ работает быстрее, потому что операции на уровне битов выполняются более эффективно процессором.

Логика простая: если сравнить число с 1 используя операцию AND, то для четных чисел результат будет 0 (младший бит равен 0), а для нечетных - 1 (младший бит равен 1). Это работает потому, что в двоичной системе четные числа всегда заканчиваются на 0, а нечетные на 1.

Смотрите, как это работает:

let num = 10;
if ((num & 1) === 0) {
  console.log('четное');
} else {
  console.log('нечетное');
}

Примеры:

• 10 & 1 вернет 0 - число четное
• 11 & 1 вернет 1 - число нечетное
• 0 & 1 вернет 0 - ноль четный

Проверка нечетных чисел

Иногда нужно проверить именно на нечетность, а не на четность. Логика здесь обратная. Для нечетных чисел остаток от деления на 2 равен 1, или младший бит равен 1.

Это может быть полезно при фильтрации массивов, когда нужно оставить только нечетные значения. Синтаксис немного отличается, но принцип остается прежним.

Примеры функций для проверки нечетности:

// Через модуль
const isOdd = (num) => num % 2 !== 0;

// Через побитовую операцию
const isOdd = (num) => (num & 1) === 1;

console.log(isOdd(5)); // true
console.log(isOdd(8)); // false

Использование:

• Проверка 5 % 2 !== 0 вернет true - число нечетное
• Проверка 8 % 2 !== 0 вернет false - число четное

Работа с массивами

Часто нужно отфильтровать массив и оставить только четные или только нечетные числа. JavaScript предоставляет удобные методы для этого - filter() и every(). Они работают с функциями проверки четности, которые мы уже рассмотрели.

Метод filter() создает новый массив с элементами, которые прошли проверку. Метод every() проверяет, все ли элементы массива удовлетворяют условию, и возвращает true или false.

Вот примеры:

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Оставить только четные числа
const evenNumbers = arr.filter(item => (item & 1) === 0);
console.log(evenNumbers); // [2, 4, 6, 8, 10]

// Проверить, все ли числа четные
const allEven = arr.every(item => (item & 1) === 0);
console.log(allEven); // false

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

• arr.filter(item => item % 2 === 0) - отфильтровать четные числа
• arr.every(item => item % 2 === 0) - проверить, все ли четные
• arr.some(item => item % 2 === 0) - проверить, есть ли четные числа

Валидация входных данных

В реальных проектах нельзя просто так доверять входным данным. Может прийти не число, может прийти строка, может прийти null или undefined. Нужно сначала проверить, что это действительно целое число, а потом уже проверять четность.

Это особенно важно, когда данные приходят от пользователя, из API или из других внешних источников. Без валидации код может сломаться или дать неверный результат. Функция Number.isInteger() помогает убедиться, что значение это целое число, а не дробь.

Надежная функция с проверкой:

const isValidNumber = (n) => Number.isFinite(parseFloat(n));

const isEven = (n) => {
  if (!Number.isInteger(n)) {
    throw new Error('Аргумент должен быть целым числом');
  }
  return n % 2 === 0;
};

try {
  console.log(isEven(10)); // true
  console.log(isEven(10.5)); // выбросит ошибку
} catch (e) {
  console.log(e.message);
}

Примеры валидации:

• Number.isInteger(10) вернет true - это целое число
• Number.isInteger(10.5) вернет false - это дробное число
• Number.isFinite(Infinity) вернет false - это не конечное число

Использование регулярных выражений

Если данные приходят как строки, можно использовать регулярные выражения для проверки четности. Это полезно, когда нужно обработать строковые представления чисел, не преобразуя их в числовой тип.

Регулярные выражения проверяют последний символ числа. Четные числа заканчиваются на 0, 2, 4, 6, 8, а нечетные на 1, 3, 5, 7, 9. Паттерн также учитывает возможное наличие минуса перед числом для отрицательных значений.

Примеры с регулярными выражениями:

const isEvenRegex = (str) => /^-?\d*$/.test(str);
const isOddRegex = (str) => /^-?\d*$/.test(str);

console.log(isEvenRegex('10')); // true
console.log(isEvenRegex('-4')); // true
console.log(isOddRegex('13')); // true
console.log(isOddRegex('-5')); // true

Паттерны регулярных выражений:

• ^-?\d*$ - проверка на четность (начинается с опционального минуса, потом цифры, заканчивается четной цифрой)
• ^-?\d*$ - проверка на нечетность (то же самое, но заканчивается нечетной цифрой)
• Такой подход корректно работает с отрицательными числами

Сравнение способов

Практические примеры и советы

В большинстве случаев используйте оператор модуля - он понятный, быстрый и надежный. Не усложняйте код без причины. Читаемость важнее микро-оптимизации - если вы не измерили, что именно эта строка кода является узким местом, не стоит писать хитрые битовые операции.

Для production-кода всегда добавляйте валидацию входных данных. Это защитит от неожиданных ошибок и облегчит отладку. Если работаете с большими массивами и производительность критична, тогда можно попробовать оптимизировать и использовать битовые операции.

Полезные советы:

• Оборачивайте проверку в отдельную функцию - это улучшает читаемость и переиспользование кода
• Для массивов используйте встроенные методы filter(), map(), find() вместо циклов
• Помните, что отрицательные числа подчиняются тем же правилам четности, что и положительные
• Ноль считается четным числом
• При работе с дробными числами используйте Math.abs() для модуля числа

Где это пригодится

Проверка четности встречается в реальных проектах чаще, чем может показаться на первый взгляд. Это нужно при фильтрации результатов в таблицах, при чередовании стилей в списках (четные строки одного цвета, нечетные другого), при распределении данных на четные и нечетные индексы, при создании расписаний и очередей.

Также проверка четности используется в более сложных алгоритмах сортировки, поиска паттернов в данных и математических вычислениях. Если хорошо освоить эту простую операцию, будет проще разбираться с более сложными задачами. Выбирайте подходящий метод в зависимости от вашей ситуации и требований к коду.