Есть ли в JavaScript метод, подобный & ldquo; range () & rdquo; создать диапазон в пределах предоставленных границ?

Можно использовать следующую остроту для хранения вещей короткими и простыми

var start = 4;
var end = 20;
console.log(Array(end - start + 1).fill(start).map((x, y) => x + y));

Мой codegolfing коллега придумал этот (ES6), включительно:

(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)

не включительно:

(s,f)=>[...Array(f-s)].map((e,i)=>i+s)

Это не может быть лучшим способом. Но если Вы надеетесь получать диапазон чисел в одной строке кода. Например, 10 - 50

Array(40).fill(undefined).map((n, i) => i + 10)

, Где 40 (конец - запускаются) и 10 запуск. Это должно возвратиться [10, 11..., 50]

На мое понимание:

• среда выполнения J не поддерживает Оптимизацию последнего вызова. Запись любой рекурсивной функции для генерации большого спектра собирается принести Вам здесь.
• массивы Создания для цикличного выполнения не могли бы быть лучшей вещью сделать, если мы собираемся работать с большими количествами.
• Пишущие большие циклы заставляет очередь событий замедляться.

function range(start, end, step = 1) {
  const _range = _start => f => {
    if (_start < end) {
      f(_start);
      setTimeout(() => _range(_start + step)(f), 0);
    }
  }

  return {
    map: _range(start),
  };
}

range(0, 50000).map(console.log);

Эта функция не ставит вышеупомянутые вопросы.

// range()              0..10, step=1
// range(max)           0..max, step=1
// range(min,max)       min..max, step=1
// range(min,step,max)  min..max, step=step
// Use:
// console.log(...range(3));
// Array.from(range(5))
// [...range(100)]
// for (const v of range(1,10)) { ... 

function* range(...args) {
    let [min, step, max] = {
        0: [0, 1, 10],
        1: [0, args[0] >= 0 ? 1 : -1, args[0]],
        2: [args[0], args[1] >= args[0] ? 1 : -1, args[1]],
        3: args,
    }[args.length] || [];
    if (min === undefined) throw new SyntaxError("Too many arguments");
    let x = min;
    while (step >= 0 ? x < max : x > max) {
        yield x;
        x += step
    }
}
console.log(...range());      // 0 1 2 3 4 5 6 7 8 9
console.log(...range(3));     // 0 1 2
console.log(...range(2, 5));  // 2 3 4
console.log(...range(5, 2));  // 5 4 3
console.log(...range(3, -3)); // 3 2 1 0 -1 -2
console.log(...range(-3, 3)); // -3 -2 -1 0 1 2
console.log(...range(-5, -2));// -5 -4 -3
console.log(...range(-2, -5));// -2 -3 -4

Диапазон с определенным твердым интервалом имеет тонну ответов, но что, если Вы не знаете, что шаг и Вы хотите много промежутков шагов вместо этого?

я написал этот код, чтобы сделать это. Это довольно очевидно.

const stepScale = (min, max, numberOfSteps) => {
  const _numberOfSteps = numberOfSteps - 1
  const scaleBy = (max - min) / _numberOfSteps

  const arr = []
  for (let i = 0; i <= _numberOfSteps; i += 1) {
    arr.push(min + scaleBy * i)
  }
  return arr
}

export default stepScale

stepScale(5, 10, 4)
// [5, 6.666666666666667, 8.333333333333334, 10]

Для npm в https://npm.im / universalstandard/step-scale

Хранение его простой:

// Generator
function* iter(a, b, step = 1) {
  for (let i = b ? a : 0; i < (b || a); i += step) {
    yield i
  }
}

const range = (a, b, step = 1) =>
  typeof a === 'string'
    ? [...iter(a.charCodeAt(), b.charCodeAt() + 1)].map(n => String.fromCharCode(n))
    : [...iter(a, b, step)]

range(4) // [0, 1, 2, 3]
range(1, 4) // [1, 2, 3]
range(2, 20, 3) // [2, 5, 8, 11, 14, 17]
range('A', 'C') // ['A', 'B', 'C']