Як генерувати діапазон чисел від 0 до n лише в ES2015?

Я завжди знаходив rangeфункцію, відсутню в JavaScript, оскільки вона доступна в python та інших? Чи є якийсь стислий спосіб генерувати діапазон чисел у ES2015?

EDIT: Мій питання відрізняється від згаданого дубліката, оскільки він специфічний для ES2015, а не ECMASCRIPT-5. Також мені потрібно, щоб діапазон починався від 0, а не конкретний стартовий номер (хоча було б добре, якщо він є)

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

[...Array(n).keys()]

або

Array.from(Array(n).keys())

Array.from()Синтаксис необхідний при роботі з машинописом

Я також знайшов ще один інтуїтивний спосіб, використовуючи Array.from:

const range = n => Array.from({length: n}, (value, key) => key)

Тепер ця rangeфункція поверне всі числа, починаючи від 0 до n-1

Модифікована версія діапазону для підтримки startта endє:

const range = (start, end) => Array.from({length: (end - start)}, (v, k) => k + start);

EDIT Як пропонує @ marco6, ви можете розмістити це як статичний метод, якщо він відповідає вашому використанню

Array.range = (start, end) => Array.from({length: (end - start)}, (v, k) => k + start);

і використовувати його як

Array.range(3, 9)

З Дельтою

Для javascript

Array.from(Array(10).keys()).map(i => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

[...Array(10).keys()].map(i => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

Array(10).fill(0).map((v, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array(10).fill().map((v, i) => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

[...Array(10)].map((v, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

const range = (from, to, step) =>
  Array(~~((to - from) / step) + 1) // '~~' is Alternative for Math.floor()
  .fill().map((v, i) => from + i * step);

range(0, 9, 2);
//=> [0, 2, 4, 6, 8]

Array.range = (from, to, step) => Array.from({
    length: ~~((to - from) / step) + 1
  },
  (v, k) => from + k * step
);

Array.range = (from, to, step) => [...Array(~~((to - from) / step) + 1)].map(
  (v, k) => from + k * step
)
Array.range(2, 10, 2);
//=> [2, 4, 6, 8, 10]

Array.range(0, 10, 1);
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Array.range(2, 10, -1);
//=> []

Array.range(3, 0, -1);
//=> [3, 2, 1, 0]


class Range {
  constructor(total = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function*() {
      for (let i = 0; i < total; yield from + i++ * step) {}
    };
  }
}

[...new Range(5)]; // Five Elements
//=> [0, 1, 2, 3, 4]
[...new Range(5, 2)]; // Five Elements With Step 2
//=> [0, 2, 4, 6, 8]
[...new Range(5, -2, 10)]; // Five Elements With Step -2 From 10
//=>[10, 8, 6, 4, 2]
[...new Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of new Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

// Or
const Range = function*(total = 0, step = 1, from = 0){
  for (let i = 0; i < total; yield from + i++ * step) {}
};

Array.from(Range(5, -2, -10));
//=> [-10, -12, -14, -16, -18]
[...Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

class Range2 {
  constructor(to = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function*() {
      let i = 0,
        length = ~~((to - from) / step) + 1;
      while (i < length) yield from + i++ * step;
    };
  }
}
[...new Range2(5)]; // First 5 Whole Numbers
//=> [0, 1, 2, 3, 4, 5]

[...new Range2(5, 2)]; // From 0 to 5 with step 2
//=> [0, 2, 4]

[...new Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

// Or 
const Range2 = function*(to = 0, step = 1, from = 0) {
    let i = 0, length = ~~((to - from) / step) + 1;
    while (i < length) yield from + i++ * step;
};


[...Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

let even4to10 = Range2(10, 2, 4);
even4to10.next().value
//=> 4
even4to10.next().value
//=> 6
even4to10.next().value
//=> 8
even4to10.next().value
//=> 10
even4to10.next().value
//=> undefined

Для Typescript

interface _Iterable extends Iterable < {} > {
  length: number;
}

class _Array < T > extends Array < T > {
  static range(from: number, to: number, step: number): number[] {
    return Array.from(
      ( < _Iterable > { length: Math.floor((to - from) / step) + 1 }),
      (v, k) => from + k * step
    );
  }
}
_Array.range(0, 9, 1);
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

Оновлення

class _Array<T> extends Array<T> {
    static range(from: number, to: number, step: number): number[] {
        return [...Array(~~((to - from) / step) + 1)].map(
            (v, k) => from + k * step
        );
    }
}
_Array.range(0, 9, 1);

Редагувати

class _Array<T> extends Array<T> {
    static range(from: number, to: number, step: number): number[] {
        return Array.from(Array(~~((to - from) / step) + 1)).map(
            (v, k) => from + k * step
        );
    }
}
_Array.range(0, 9, 1);

Для чисел від 0 до 5

[...Array(5).keys()];
=> [0, 1, 2, 3, 4]

Багато цих рішень ґрунтуються на створенні справжніх об’єктів Array, які можуть виконати роботу в багатьох випадках, але не можуть підтримувати такі випадки range(Infinity). Ви можете використовувати простий генератор, щоб уникнути цих проблем і підтримувати нескінченні послідовності:

function* range( start, end, step = 1 ){
  if( end === undefined ) [end, start] = [start, 0];
  for( let n = start; n < end; n += step ) yield n;
}

Приклади:

Array.from(range(10));     // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
Array.from(range(10, 20)); // [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ]

i = range(10, Infinity);
i.next(); // { value: 10, done: false }
i.next(); // { value: 11, done: false }
i.next(); // { value: 12, done: false }
i.next(); // { value: 13, done: false }
i.next(); // { value: 14, done: false }

Отже, у цьому випадку було б непогано, якби об'єкт Number поводився як об’єкт Array з оператором розповсюдження.

Наприклад, об'єкт Array, який використовується разом із оператором розширення:

let foo = [0,1,2,3];
console.log(...foo) // returns 0 1 2 3

Це працює так, тому що об’єкт Array має вбудований ітератор.
У нашому випадку нам потрібен об'єкт Числа, щоб мати подібний функціонал:

[...3] //should return [0,1,2,3]

Для цього ми можемо просто створити ітератор чисел для цієї мети.

Number.prototype[Symbol.iterator] = function *() {
   for(let i = 0; i <= this; i++)
       yield i;
}

Тепер можна створити діапазони від 0 до N за допомогою оператора спред.

[... N] // тепер повертає 0 ... N масив

http://jsfiddle.net/01e4xdv5/4/

Ура.

Ви можете використовувати функцію генератора, яка створює діапазон ліниво лише за потреби:

function* range(x, y) {
  while (true) {
    if (x <= y)
      yield x++;

    else
      return null;
  }
}

const infiniteRange = x =>
  range(x, Infinity);
  
console.log(
  Array.from(range(1, 10)) // [1,2,3,4,5,6,7,8,9,10]
);

console.log(
  infiniteRange(1000000).next()
);

Ви можете використовувати функцію генератора вищого порядку для відображення rangeгенератора:

function* range(x, y) {
  while (true) {
    if (x <= y)
      yield x++;

    else
      return null;
  }
}

const genMap = f => gx => function* (...args) {
  for (const x of gx(...args))
    yield f(x);
};

const dbl = n => n * 2;

console.log(
  Array.from(
    genMap(dbl) (range) (1, 10)) // [2,4,6,8,10,12,14,16,18,20]
);

Якщо ви безстрашні, ви навіть можете узагальнити підхід генератора, щоб вирішити набагато ширший діапазон (призначений для каламбура):

const rangeBy = (p, f) => function* rangeBy(x) {
  while (true) {
    if (p(x)) {
      yield x;
      x = f(x);
    }

    else
      return null;
  }
};

const lte = y => x => x <= y;

const inc = n => n + 1;

const dbl = n => n * 2;

console.log(
  Array.from(rangeBy(lte(10), inc) (1)) // [1,2,3,4,5,6,7,8,9,10]
);

console.log(
  Array.from(rangeBy(lte(256), dbl) (2)) // [2,4,8,16,32,64,128,256]
);

Майте на увазі, що генератори / ітератори за своєю суттю є стаціонарними, тобто відбувається неявна зміна стану при кожному виклику next. Держава - це змішане благо.

Діапазон із кроком ES6, який працює аналогічно python list(range(start, stop[, step])):

const range = (start, stop, step = 1) => {
  return [...Array(stop - start).keys()]
    .filter(i => !(i % Math.round(step)))
    .map(v => start + v)
}

Приклади:

range(0, 8) // [0, 1, 2, 3, 4, 5, 6, 7]
range(4, 9) // [4, 5, 6, 7, 8]
range(4, 9, 2) // [4, 6, 8] 
range(4, 9, 3) // [4, 7]

Для підтримки дельти

const range = (start, end, delta) => {
  return Array.from(
    {length: (end - start) / delta}, (v, k) => (k * delta) + start
  )
};

Ви також можете зробити це за допомогою одного вкладиша з підтримкою кроків, як це:

((from, to, step) => ((add, arr, v) => add(arr, v, add))((arr, v, add) => v < to ? add(arr.concat([v]), v + step, add) : arr, [], from))(0, 10, 1)

Результат - [0, 1, 2, 3, 4, 5, 6 ,7 ,8 ,9].

Ця функція поверне цілу послідовність.

const integerRange = (start, end, n = start, arr = []) =>
  (n === end) ? [...arr, n]
    : integerRange(start, end, start < end ? n + 1 : n - 1, [...arr, n]);

$> integerRange(1, 1)
<- Array [ 1 ]

$> integerRange(1, 3)
<- Array(3) [ 1, 2, 3 ]

$> integerRange(3, -3)
<- Array(7) [ 3, 2, 1, 0, -1, -2, -3 ]

const keys = Array(n).keys();
[...Array.from(keys)].forEach(callback);

в Typescript

Ось ще одна версія, яка не використовується Array.

let range = (n, l=[], delta=1) => {
  if (n < 0) { 
    return l 
  }
  else {
    l.unshift(n)
    return range(n - delta, l) 
  }
}

Зараз генератори дозволяють вам ліниво генерувати числову послідовність і використовувати менше пам'яті для великих діапазонів.

Хоча в питанні конкретно йдеться про ES2015, я очікую, що багато користувачів Typescript закінчуватимуться тут, і перехід до ES простий ...

function range(end: number): IterableIterator<number>;
// tslint:disable-next-line:unified-signatures
function range(begin: number, end: number): IterableIterator<number>;

function *range(begin: number, end: number = NaN): IterableIterator<number> {
    let num = 0;
    if (isNaN(end)) {
        end = begin;
    } else {
        num = begin;
    }
    while (num < end) {
        yield num++;
    }
}

Перші дві функції декларації - це лише надання більш інформативних пропозицій щодо завершення роботи у вашому IDE.

Як щодо просто картографування ...

Масив (n) .map ((значення, індекс) ....) становить 80% шляху туди. Але чомусь це не працює. Але є рішення.

Array(n).map((v,i) => i) // does not work
Array(n).fill().map((v,i) => i) // does dork

Для діапазону

Array(end-start+1).fill().map((v,i) => i + start) // gives you a range

Як не дивно, ці два ітератори повертають однаковий результат: Array(end-start+1).entries()іArray(end-start+1).fill().entries()