Рандомный массив

Как создать рандомный массив в JavaScript?

Чаще всего под запросом «рандомный массив» имеют в виду два варианта:

• массив случайных чисел из заданного диапазона;
• массив случайных элементов из уже существующего списка.

Базовый способ в JavaScript – использовать Math.random() для получения случайного числа и Math.floor() для перевода его в индекс массива, как показывают многие руководства по JS, например sky.pro и expange.ru.

Простейший пример: рандомный массив целых чисел в диапазоне [min, max]:

function getRandomInt(min, max) {
  // min и max включительно
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

function getRandomIntArray(length, min, max) {
  const result = [];
  for (let i = 0; i < length; i++) {
    result.push(getRandomInt(min, max));
  }
  return result;
}

console.log(getRandomIntArray(5, 1, 10)); // например: [3, 10, 1, 7, 4]

Калькулятор выше делает то же самое автоматически: вы задаёте длину массива, диапазон значений, тип чисел (целые или дробные) и режим выборки (с повторами или без), а на выходе получаете готовый рандомный массив, который можно сразу использовать в коде или тестах.

Что такое рандомный массив и где он применяется

Рандомный массив – это массив, элементы которого:

• либо сгенерированы случайным образом (например, числа 1–100),
• либо выбраны случайно из исходного набора (например, случайные вопросы теста),
• либо имеют случайный порядок (перемешанный список элементов).

Типичные сценарии:

• игры и квизы – случайные вопросы, карты, враги;
• A/B‑тесты – случайные группы пользователей или вариантов интерфейса;
• генерация тестовых данных для серверов и БД;
• моделирование и статистика – выборка случайных значений, перебор сценариев;
• анимации и визуальные эффекты – случайные цвета, координаты, задержки.

В JS всё это упирается в одно: корректная работа с Math.random() или более продвинутыми генераторами случайных чисел.

Рандомный массив чисел: функции с Math.random()

Диапазон и целые числа

Math.random() возвращает число в диапазоне [0, 1): включая 0 и не включая 1. Чтобы превратить его в целое число в нужном диапазоне:

1. масштабируем результат на длину диапазона;
2. округляем вниз Math.floor;
3. сдвигаем к min.

Формула для min и max включительно:

const randomInt = Math.floor(Math.random() * (max - min + 1)) + min;

На этом принципе построены почти все примеры из статей по рандомизации массивов, в том числе у sky.pro и expange.ru.

Функция для массива целых чисел:

function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

function randomIntArray(length, min, max) {
  const arr = [];
  for (let i = 0; i < length; i++) {
    arr.push(getRandomInt(min, max));
  }
  return arr;
}

Дробные числа

Для дробей всё проще – округление не требуется:

function randomFloatArray(length, min, max) {
  const arr = [];
  for (let i = 0; i < length; i++) {
    arr.push(Math.random() * (max - min) + min);
  }
  return arr;
}

Такие массивы удобны для генерации координат, коэффициентов, вероятностей.

Рандомный массив без повторов

Если нужен рандомный массив чисел без повторов, важно, чтобы длина массива не превышала размер диапазона. Один из надёжных способов (по сути, обобщение идеи getRandomUniqueElements из sky.pro):

function randomUniqueIntArray(length, min, max) {
  const range = max - min + 1;
  if (length > range) {
    throw new Error('Нельзя получить столько уникальных чисел в заданном диапазоне');
  }

  // Заполняем массив всеми целыми числами диапазона
  const pool = [];
  for (let x = min; x <= max; x++) {
    pool.push(x);
  }

  const result = [];
  for (let i = 0; i < length; i++) {
    const index = Math.floor(Math.random() * pool.length);
    result.push(pool[index]);
    pool.splice(index, 1); // удаляем использованное значение
  }

  return result;
}

console.log(randomUniqueIntArray(5, 1, 10)); // 5 разных чисел от 1 до 10

Этот приём эквивалентен выборке без возвращения: мы постепенно «вытаскиваем» элементы из пула доступных значений.

Рандомный массив из существующего массива (подмножество элементов)

Частая задача: есть исходный массив, и нужно получить из него N случайных элементов, обычно без повторов.

Быстро, но не идеально: sort + Math.random

Популярный трюк – перемешать массив с помощью sort(() => Math.random() - 0.5) и взять первые count элементов:

function randomSubsetFast(array, count) {
  return [...array] // создаём копию, чтобы не портить оригинал
    .sort(() => Math.random() - 0.5)
    .slice(0, count);
}

Плюсы:

• компактный однострочник;
• наглядный код.

Минусы, на которые указывают и авторы sky.pro:

• временная сложность O(n log n) из‑за сортировки;
• распределение перестановок не идеально равномерное – некоторые порядки встречаются чаще других.

Для простых задач (мелкие массивы, некритичная случайность) этот вариант всё же широко применяется.

Правильно и равномерно: алгоритм Фишера–Йейтса

Для действительно случайного перемешивания массивов в современных гайдах рекомендуют алгоритм Фишера–Йейтса (Fisher–Yates shuffle). Он:

• работает за O(n);
• даёт равномерное распределение всех перестановок массива;
• не зависит от особенностей реализации sort.

Реализация shuffle + выбор подмножества:

function shuffle(array) {
  const result = [...array]; // не мутируем исходный массив
  for (let i = result.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1)); // 0 ≤ j ≤ i
    [result[i], result[j]] = [result[j], result[i]];
  }
  return result;
}

function randomSubset(array, count) {
  if (count > array.length) {
    throw new Error('Нельзя взять больше элементов, чем есть в массиве');
  }
  return shuffle(array).slice(0, count);
}

const questions = ['Q1', 'Q2', 'Q3', 'Q4', 'Q5'];
console.log(randomSubset(questions, 3)); // 3 случайных вопроса без повторов

Идея такая же, как в приведённой в sky.pro функции shuffle: на каждой итерации мы меняем местами текущий элемент с любым случайным из диапазона 0..i.

Один случайный элемент: упрощённый случай

Чтобы получить один случайный элемент массива, достаточно вычислить случайный индекс:

function randomElement(array) {
  if (!Array.isArray(array) || array.length === 0) return undefined;
  const index = Math.floor(Math.random() * array.length);
  return array[index];
}

const langs = ['PHP', 'JavaScript', 'Python', 'Ruby'];
console.log(randomElement(langs)); // например, "Python"

По сути, это аккуратная версия функции arrayRandElement, которую демонстрирует expange.ru, только с защитой от пустых и некорректных массивов.

Взвешенный рандомный массив (с разными вероятностями)

Иногда элементы должны выпадать с разной вероятностью: «обычные», «редкие», «легендарные» предметы. У sky.pro показан классический приём взвешенного выбора, его легко обобщить на массив.

Сначала функция для одного элемента:

function weightedRandomItem(items, weights) {
  if (items.length !== weights.length) {
    throw new Error('Длины items и weights должны совпадать');
  }

  const totalWeight = weights.reduce((sum, w) => sum + w, 0);
  let r = Math.random() * totalWeight;

  for (let i = 0; i < items.length; i++) {
    if (r < weights[i]) return items[i];
    r -= weights[i];
  }

  return items[items.length - 1];
}

Теперь на её основе можно собрать рандомный массив:

function weightedRandomArray(items, weights, length) {
  const result = [];
  for (let i = 0; i < length; i++) {
    result.push(weightedRandomItem(items, weights));
  }
  return result;
}

const rarity = ['Common', 'Uncommon', 'Rare', 'Epic', 'Legendary'];
const weights = [50, 30, 15, 4, 1];

console.log(weightedRandomArray(rarity, weights, 10));

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

Перемешивание массива: Fisher–Yates и sort с Math.random

Сравним два популярных способа получить рандомный массив‑перестановку:

Вывод:

• для серьёзных задач (тесты, статистика, игры с честным рандомом) используйте Fisher–Yates;
• sort(() => Math.random() - 0.5) годится для небольших, некритичных сценариев, где важнее компактность кода.

Попытки «улучшить» sort() многократными вызовами, как иногда советуют, только увеличивают время работы, но не устраняют фундаментальную проблему неравномерности.

Криптографически стойкий рандомный массив

Math.random() – псевдослучайный генератор. Для интерфейсов этого достаточно, но для паролей, токенов и криптографии его качество и предсказуемость недостаточны.

В браузере для криптографически стойкой случайности используют Web Crypto API:

function secureRandomIntArray(length, min, max) {
  const range = max - min + 1;
  if (range <= 0) throw new Error('Некорректный диапазон');
  if (range > 2 ** 32) throw new Error('Диапазон слишком большой для данного метода');

  const buffer = new Uint32Array(length);
  crypto.getRandomValues(buffer); // криптографически стойкие числа

  const result = [];
  for (let i = 0; i < length; i++) {
    result.push(min + (buffer[i] % range));
  }
  return result;
}

console.log(secureRandomIntArray(5, 1000, 9999)); // 5 «надёжных» псевдослучайных чисел

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

Как выбрать способ генерации рандомного массива

Краткое резюме по выбору подхода:

• Нужен просто массив случайных чисел.
  Используйте Math.random() + Math.floor() для целых, либо масштабирование для дробных чисел.

• Нужен рандомный массив без повторов из числового диапазона.
  Сформируйте пул возможных значений и выбирайте из него без возвращения, либо перемешайте пул алгоритмом Фишера–Йейтса и возьмите первые N.

• Нужен рандомный поднабор из существующего массива.
  Для серьёзных задач – shuffle (Fisher–Yates) + slice. Для быстрых набросков – sort(() => Math.random() - 0.5) + slice.

• Нужны разные вероятности для элементов.
  Используйте взвешенный выбор: массив значений и соответствующий массив весов.

• Нужна повышенная безопасность.
  Для чисел – crypto.getRandomValues. Math.random() в таких сценариях лучше избегать.

Калькулятор «рандомный массив» над текстом закрывает базовые потребности: он генерирует массив по длине и диапазону, умеет исключать повторы и позволяет быстро получить готовый набор случайных чисел для практических задач.

Типичные ошибки при работе со случайными массивами

Чтобы рандомизация не вела к скрытым багам, избегайте нескольких распространённых ошибок:

• Использование Math.round вместо Math.floor.
  Math.round(Math.random() * n) даёт перекос – крайние значения выпадают реже или чаще. Для индексов и целых диапазонов используйте только Math.floor.

• Неправильные границы диапазона.
  Формула без + 1 в max - min + 1 исключает верхнюю границу. Всегда проверяйте, включает ли ваш генератор max.

• Игнорирование пустых массивов.
  Вызов array[Math.floor(Math.random() * array.length)] при length = 0 вернёт undefined. Добавляйте проверки входных данных.

• Мутация исходного массива.
  Функции shuffle и выборки лучше строить на копиях: const result = [...array];. Иначе логика кода, который переиспользует оригинальный массив, может неожиданно ломаться.

• Расширение Object.prototype или Array.prototype в общем коде.
  В старых примерах, вроде кода на expange.ru, встречается добавление метода randElement в прототип объекта. В современном коде от этого подхода лучше отказаться, чтобы не конфликтовать с чужими библиотеками.

• Ожидание «идеальной» равномерности от маленьких выборок.
  Даже корректный генератор может дать серию повторов на коротких дистанциях. Для оценки качества случайности смотрите на статистику в большом числе повторов, а не на несколько тестовых запусков.

Используя проверенные схемы с Math.random, Fisher–Yates и при необходимости crypto.getRandomValues, вы сможете получать рандомные массивы нужного качества – от простых тестовых до криптографически стойких.