Javascript 如何仅在ES2015中生成从0到n的数字范围？

我总是发现JavaScript中缺少

range

函数，因为它在python和其他语言中可用？在ES2015中，是否有任何简洁的方法生成数字范围

---

编辑：我的问题与上述副本不同，因为它是针对ES2015而不是ECMASCRIPT-5的。此外，我还需要范围从0开始，而不是特定的起始数字（尽管如果有，这会很好）

您可以在新创建的数组的键上使用spread操作符

[…数组（n）.keys（）]

或

Array.from（Array（n）.keys（））

---

如果使用TypeScript，则必须使用

Array.from（）

语法。我还发现了一种使用

Array的更直观的方法。from

：

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

现在，这个

范围

函数将返回从0到n-1的所有数字

支持

开始

和

结束

的范围的修改版本是：

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

编辑 正如@marco6所建议的，如果它适合您的用例，您可以将其作为静态方法

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

并将其用作

Array.range(3, 9)

支持三角洲

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

---

在Typescript中，您还可以使用一个带有步进支持的单行程序来执行此操作，如下所示：

（（from，to，step）=>（（add，arr，v）=>add（arr，v，add））（（arr，v，add）=>v

---

结果是

[0,1,2,3,4,5,6,7,8,9]

这里是另一个不使用

数组的变体

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

let range=（n，l=[]，delta=1）=>{
如果（n<0）{
返回l
}
否则{
l、 取消移位（n）
返回范围（n-增量，l）
}
}
带增量/步长
最小和一个班轮
[…数组（N）].map（（u，i）=>from+i*步）；

示例和其他备选方案

[…数组（10）].map（（u，i）=>4+i*2）；
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
数组.from（数组（10））.map（（（uu，i）=>4+i*2）；
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
from（数组（10.keys（））.map（i=>4+i*2）；
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
[…数组（10）.keys（）].map（i=>4+i*-2）；
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]
数组（10）.fill（0）.map（（_，i）=>4+i*2）；
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
数组（10）.fill（）.map（（3;，i）=>4+i*-2）；
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

范围函数
const range=（从、到、步）=>
[…数组（数学地板（（to-from）/步长）+1）].map（（（u，i）=>from+i*步长）；
范围（0,9,2）；
//=> [0, 2, 4, 6, 8]
//也可以将范围函数指定为数组类中的静态方法（但不推荐）
Array.range=（从、到、步长）=>
[…数组（数学地板（（to-from）/步长）+1）].map（（（u，i）=>from+i*步长）；
范围（2,10,2）；
//=> [2, 4, 6, 8, 10]
范围（0,10,1）；
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
范围（2,10，-1）；
//=> []
范围（3,0，-1）；
//=> [3, 2, 1, 0]

作为迭代器
类范围{
构造函数（总计=0，步骤=1，起始=0）{
此[Symbol.iterator]=函数*（）{
对于（设i=0；i [0, 1, 2, 3, 4]
[…新范围（5，2）]；//步骤2的五个要素
//=> [0, 2, 4, 6, 8]
[…新范围（5，-2，10）]；//第10步第2步的五个元素
//=>[10, 8, 6, 4, 2]
[…新范围（5，-2，-10）]；//从-10到步骤-2的五个元素
//=> [-10, -12, -14, -16, -18]
//也适用于for..of循环
对于（新范围（5，-2，10）的i）console.log（i）；
// 10 8 6 4 2

仅作为发电机
const Range=function*（总计=0，步长=1，起始=0）{
对于（设i=0；i [-10, -12, -14, -16, -18]
[…范围（5，-2，-10）]；//从-10到步骤-2的五个元素
//=> [-10, -12, -14, -16, -18]
//也适用于for..of循环
对于（范围（5，-2，10）的i）console.log（i）；
// 10 8 6 4 2
//懒散加载方式
const number0toInf=范围（无穷大）；
number0toInf.next（）.value；
//=> 0
number0toInf.next（）.value；
//=> 1
// ...

从到，带有阶跃/增量
使用迭代器
类别范围2{
构造函数（to=0，step=1，from=0）{
此[Symbol.iterator]=函数*（）{
设i=0，
长度=数学楼层（（到-从）/台阶）+1；
而（i [0, 1, 2, 3, 4, 5]
[…新范围2（5，2）]；//使用步骤2从0到5
//=> [0, 2, 4]
[…新范围2（5，-2，10）]；//使用步骤-2从10到5
//=> [10, 8, 6]

使用发电机
const Range2=function*（to=0，step=1，from=0）{
设i=0，
长度=数学楼层（（到-从）/台阶）+1；
而（i [10, 8, 6]
设even4to10=范围2（10，2，4）；
even4to 10.next（）.值；
//=> 4
even4to 10.next（）.值；
//=> 6
even4to 10.next（）.值；
//=> 8
even4to 10.next（）.值；
//=> 10
even4to 10.next（）.值；
//=>未定义

打字稿
接口_Iterable扩展Iterable{
长度：数字；
}
类_数组扩展了数组{
静态范围（从：编号，到：编号，步骤：编号）：编号[]{
返回数组.from(
{length:Math.floor（（to-from）/step）+1}，
（v，k）=>从+k*步
);
}
}
_范围（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(Math.floor((to - from) / step) + 1)].map(
      (v, k) => from + k * step
    );
  }
}
_Array.range(0, 9, 1);

class\u数组扩展了数组{
静态范围（从：编号，到：编号，步骤：编号）：编号[]{
return[…数组（数学地板（（to-from）/步骤）+1）].map(
（v，k）=>从+k*步
);
}
}
_范围（0,9,1）；

编辑

class\u数组扩展了数组{
静态范围（从：编号，到：编号，步骤：编号）：编号[]{
返回Array.from（Array（Math.floor（（to-from）/step）+1））.map(
（v，k）=>从+k*步
);
}
}
_范围（0,9,1）；
所以，在这种情况下，它会很好
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(Math.floor((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(Math.floor((to - from) / step) + 1)).map(
      (v, k) => from + k * step
    );
  }
}
_Array.range(0, 9, 1);

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

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

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

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 }

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

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 ]

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++;
    }
}

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]

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