Как проверить является ли число четным в TypeScript?

Как проверить является ли число четным в TypeScript?

Для проверки, является ли число четным в TypeScript, используется оператор остатка от деления (%) - самый простой и универсальный способ. Четное число всегда делится на 2 без остатка.

Базовый способ

function isEven(num: number): boolean {
  return num % 2 === 0;
}

console.log(isEven(4));    // true
console.log(isEven(7));    // false
console.log(isEven(0));    // true (0 четное)
console.log(isEven(-2));   // true (-2 четное)

Стрелочная функция

const isEven = (num: number): boolean => num % 2 === 0;

console.log(isEven(10));   // true
console.log(isEven(11));   // false

Краткая версия

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

// Или используя тип return
const isEven: (n: number) => boolean = (n) => n % 2 === 0;

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

function isOdd(num: number): boolean {
  return num % 2 !== 0; // или num % 2 === 1
}

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

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

const numbers: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Фильтр четных чисел
const evenNumbers = numbers.filter(num => num % 2 === 0);
console.log(evenNumbers); // [2, 4, 6, 8, 10]

// Фильтр нечетных чисел
const oddNumbers = numbers.filter(num => num % 2 !== 0);
console.log(oddNumbers); // [1, 3, 5, 7, 9]

// Проверка, все ли четные
const allEven = numbers.every(num => num % 2 === 0);
console.log(allEven); // false

// Проверка, есть ли четные
const someEven = numbers.some(num => num % 2 === 0);
console.log(someEven); // true

Альтернативные способы

Способ 1: Использование побитового оператора AND

function isEven(num: number): boolean {
  return (num & 1) === 0;
}

console.log(isEven(4));  // true
console.log(isEven(7));  // false

Этот способ работает, потому что последний бит четного числа всегда 0 в двоичном представлении:

• 4 в двоичном: 0100 (& 0001 = 0)
• 7 в двоичном: 0111 (& 0001 = 1)

Способ 2: Использование toString с радиксом

function isEven(num: number): boolean {
  return parseInt(num.toString(2), 10) % 2 === 0;
}

// Менее эффективно, но работает
console.log(isEven(4));  // true

Работа с BigInt

function isEvenBigInt(num: bigint): boolean {
  return num % 2n === 0n;
}

console.log(isEvenBigInt(4n));           // true
console.log(isEvenBigInt(9999999999n));  // false

Класс с методом для проверки

class MathHelper {
  static isEven(num: number): boolean {
    return num % 2 === 0;
  }

  static isOdd(num: number): boolean {
    return num % 2 !== 0;
  }

  static getEvenNumbers(numbers: number[]): number[] {
    return numbers.filter(this.isEven);
  }

  static getOddNumbers(numbers: number[]): number[] {
    return numbers.filter(this.isOdd);
  }
}

console.log(MathHelper.isEven(6));      // true
console.log(MathHelper.getEvenNumbers([1, 2, 3, 4, 5]));
// [2, 4]

Использование в React компоненте

import { useState } from 'react';

function NumberChecker() {
  const [number, setNumber] = useState<number>(0);

  const isEven = (num: number): boolean => num % 2 === 0;
  const checkResult = isEven(number);

  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    setNumber(parseInt(e.target.value, 10));
  };

  return (
    <div>
      <input
        type="number"
        value={number}
        onChange={handleInputChange}
        placeholder="Введите число"
      />
      <p>
        {number} - это {checkResult ? 'четное' : 'нечетное'} число
      </p>
      <p className={checkResult ? 'text-green-600' : 'text-red-600'}>
        {checkResult ? 'Четное число' : 'Нечетное число'}
      </p>
    </div>
  );
}

Проверка с обработкой ошибок

function validateAndCheckEven(value: unknown): boolean {
  if (typeof value !== 'number') {
    throw new TypeError('Ожидается число');
  }

  if (!Number.isInteger(value)) {
    throw new Error('Ожидается целое число');
  }

  return value % 2 === 0;
}

try {
  console.log(validateAndCheckEven(4));  // true
  console.log(validateAndCheckEven(3.5)); // Error: Ожидается целое число
  console.log(validateAndCheckEven('4')); // Error: Ожидается число
} catch (error) {
  console.error(error);
}

Перечисление четных и нечетных в диапазоне

function getEvenNumbersInRange(
  start: number,
  end: number
): number[] {
  const result: number[] = [];
  for (let i = start; i <= end; i++) {
    if (i % 2 === 0) {
      result.push(i);
    }
  }
  return result;
}

function getOddNumbersInRange(
  start: number,
  end: number
): number[] {
  const result: number[] = [];
  for (let i = start; i <= end; i++) {
    if (i % 2 !== 0) {
      result.push(i);
    }
  }
  return result;
}

console.log(getEvenNumbersInRange(1, 10));
// [2, 4, 6, 8, 10]

console.log(getOddNumbersInRange(1, 10));
// [1, 3, 5, 7, 9]

Сравнение производительности

// Способ 1: модуль (самый быстрый и читаемый)
const isEven1 = (n: number) => n % 2 === 0;

// Способ 2: побитовый оператор (немного быстрее, менее читаемо)
const isEven2 = (n: number) => (n & 1) === 0;

// Способ 3: Math.abs + модуль (для отрицательных)
const isEven3 = (n: number) => Math.abs(n) % 2 === 0;

// В реальных приложениях разница незначительна
// Выбирай основываясь на читаемости

Заключение

Для проверки четности в TypeScript:

Основной метод:

num % 2 === 0  // четное
num % 2 !== 0  // нечетное

Почему это лучший способ:

• Простой и понятный
• Быстрый и эффективный
• Работает с целыми и отрицательными числами
• Стандартный способ во всех языках программирования
• Легко читается и поддерживается

Для специальных случаев (производительность) можно использовать побитовый оператор (num & 1) === 0, но в большинстве случаев модуль полностью достаточен.