Array.range = function(a, b, step){
    var A = [];
    if(typeof a == 'number'){
        A[0] = a;
        step = step || 1;
        while(a+step <= b){
            A[A.length]= a+= step;
        }
    }
    else {
        var s = 'abcdefghijklmnopqrstuvwxyz';
        if(a === a.toUpperCase()){
            b = b.toUpperCase();
            s = s.toUpperCase();
        }
        s = s.substring(s.indexOf(a), s.indexOf(b)+ 1);
        A = s.split('');        
    }
    return A;
}
    
    
Array.range(0,10);
// [0,1,2,3,4,5,6,7,8,9,10]
    
Array.range(-100,100,20);
// [-100,-80,-60,-40,-20,0,20,40,60,80,100]
    
Array.range('A','F');
// ['A','B','C','D','E','F')
    
Array.range('m','r');
// ['m','n','o','p','q','r']

var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l);

也可以使用生成器生成序列。不同之处在于序列中的每个值都是延迟加载的。spread运算符和for为结果工作。星号符号使函数成为生成器。

const range = function*(from,to) {   
    for(let i = from; i <= to; i++) yield I;   
};   

[...range(3,5)]// => [3, 4, 5]

方便的函数来完成这个技巧，请运行下面的代码片段

功能范围（开始、结束、步长、偏移）{var len=（数学.abs（结束-开始）+（（偏移量||0）*2））/（步骤||1）+1；var方向=开始<结束？1 : -1;var startingPoint=开始-（方向*（偏移||0））；var stepSize=方向*（步骤||1）；return Array（len）.fill（0）.map（函数（_，索引）{return startingPoint+（stepSize*索引）；});}console.log（'范围（1，5）=>'+范围（1、5））；console.log（'范围（5，1）=>'+范围（5、1））；console.log（'范围（5，5）=>'+范围（5、5））；console.log（'范围（-5，5）=>'+范围（-5、5））；console.log（'范围（-10，5，5）=>'+范围（-10、5，5））；console.log（'范围（1，5，1，2）=>'+范围（1、5、1，2；

下面是如何使用它

范围（开始，结束，步长=1，偏移=0）；

包括-前进档（5,10）//[5，6，7，8，9，10]包括-向后范围（10,5）//[10，9，8，7，6，5]后退范围（10,2,2）//[10，8，6，4，2]排他-前进范围（5,10,0，-1）//[6,7,8,9]而不是5,10本身偏移-扩展范围（5,10,0,1）//[4，5，6，7，8，9，10，11]偏移-收缩范围（5,10,0，-2）//[7，8]步进-扩展范围（10,0,2,2）//[12，10，8，6，4，2，0，-2]

希望你觉得它有用。

这就是它的工作原理。

基本上，我首先计算得到的数组的长度，并创建一个长度为零的填充数组，然后用所需的值填充

（step | |1）=>其他类似的方法使用step的值，如果没有提供，则使用1我们首先使用（Math.abs（end-start）+（（offset | |0）*2））/（step | |1）+1）计算结果数组的长度，以使其更简单（两个方向上的差值*offset/step）获得长度后，我们使用newArray（length）.fill（0）创建一个带有初始化值的空数组；在此处检查现在我们有一个数组[0,0,0，..]，其长度是我们想要的。我们对其进行映射，并使用array.map（function（）｛｝）返回一个具有所需值的新数组var方向=开始<结束？1 : 0; 显然，如果起点不小于终点，我们就需要后退。我的意思是从0到5，反之亦然在每次迭代中，startingPoint+stepSize*索引将为我们提供所需的值

对于字母，他是我想出的一个生成字母范围的简单JS解决方案。它只用于生成大写或小写字母的数组。

功能范围（第一个，最后一个）{var r=[]，i=first.charCodeAt（0）；而（i<=last.charCodeAt（0））{r.push（String.fromCharCode（i++））；}返回r；}console.dir（范围（“a”，“f”））；console.dir（范围（“G”，“Z”））；

对于数字，您可以使用ES6 Array.from（），它现在可以在除IE以外的任何情况下工作：

较短版本：

Array.from({length: 20}, (x, i) => i);

更长版本：

Array.from(new Array(20), (x, i) => i);​​​​​​

这创建了从0到19（包括0到19）的数组。这可以进一步简化为以下形式之一：

Array.from(Array(20).keys());
// or
[...Array(20).keys()];

也可以指定下限和上限，例如：

Array.from(new Array(20), (x, i) => i + *lowerBound*);

一篇文章对此进行了更详细的描述：http://www.2ality.com/2014/05/es6-array-methods.html