我发现了一个与PHP中的函数相当的JS范围函数，在这里工作得非常棒。向前和向后工作，可以处理整数、浮点数和字母！

function range(low, high, step) {
  //  discuss at: http://phpjs.org/functions/range/
  // original by: Waldo Malqui Silva
  //   example 1: range ( 0, 12 );
  //   returns 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
  //   example 2: range( 0, 100, 10 );
  //   returns 2: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
  //   example 3: range( 'a', 'i' );
  //   returns 3: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
  //   example 4: range( 'c', 'a' );
  //   returns 4: ['c', 'b', 'a']

  var matrix = [];
  var inival, endval, plus;
  var walker = step || 1;
  var chars = false;

  if (!isNaN(low) && !isNaN(high)) {
    inival = low;
    endval = high;
  } else if (isNaN(low) && isNaN(high)) {
    chars = true;
    inival = low.charCodeAt(0);
    endval = high.charCodeAt(0);
  } else {
    inival = (isNaN(low) ? 0 : low);
    endval = (isNaN(high) ? 0 : high);
  }

  plus = ((inival > endval) ? false : true);
  if (plus) {
    while (inival <= endval) {
      matrix.push(((chars) ? String.fromCharCode(inival) : inival));
      inival += walker;
    }
  } else {
    while (inival >= endval) {
      matrix.push(((chars) ? String.fromCharCode(inival) : inival));
      inival -= walker;
    }
  }

  return matrix;
}

这是缩小版：

function range(h,c,b){var i=[];var d,f,e;var a=b||1;var g=false;if(!isNaN(h)&&!isNaN(c)){d=h;f=c}else{if(isNaN(h)&&isNaN(c)){g=true;d=h.charCodeAt(0);f=c.charCodeAt(0)}else{d=(isNaN(h)?0:h);f=(isNaN(c)?0:c)}}e=((d>f)?false:true);if(e){while(d<=f){i.push(((g)?String.fromCharCode(d):d));d+=a}}else{while(d>=f){i.push(((g)?String.fromCharCode(d):d));d-=a}}return i};

您可以使用以下一行代码使事情简短明了

var启动=4；var端=20；console.log（数组（end-start+1）.fill（start）.map（（x，y）=>x+y））；

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

功能范围（开始、结束、步长、偏移）{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*索引将为我们提供所需的值

这里有一个基于@benmcdonald和其他人的简单方法，尽管不止一行。。。

设K=[]；对于（i=“A”.charCodeAt（0）；i<=“Z”.charCodeAt（0）；i++）{K.push（字符串来自CharCode（i））};console.log（K）；

数字

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

字符迭代

String.fromCharCode(...[...Array('D'.charCodeAt(0) - 'A'.charCodeAt(0) + 1).keys()].map(i => i + 'A'.charCodeAt(0)));
 => "ABCD"

迭代

for (const x of Array(5).keys()) {
  console.log(x, String.fromCharCode('A'.charCodeAt(0) + x));
}
 => 0,"A" 1,"B" 2,"C" 3,"D" 4,"E"

作为函数

function range(size, startAt = 0) {
    return [...Array(size).keys()].map(i => i + startAt);
}

function characterRange(startChar, endChar) {
    return String.fromCharCode(...range(endChar.charCodeAt(0) -
            startChar.charCodeAt(0), startChar.charCodeAt(0)))
}

类型化函数

function range(size:number, startAt:number = 0):ReadonlyArray<number> {
    return [...Array(size).keys()].map(i => i + startAt);
}

function characterRange(startChar:string, endChar:string):ReadonlyArray<string> {
    return String.fromCharCode(...range(endChar.charCodeAt(0) -
            startChar.charCodeAt(0), startChar.charCodeAt(0)))
}

lodash.js_.range（）函数

_.range(10);
 => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11);
 => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5);
 => [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1);
 => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
String.fromCharCode(..._.range('A'.charCodeAt(0), 'D'.charCodeAt(0) + 1));
 => "ABCD"

没有库的旧非es6浏览器：

Array.apply(null, Array(5)).map(function (_, i) {return i;});
 => [0, 1, 2, 3, 4]

console.log（[…Array（5）.keys（）]）；

（ES6归功于尼尔斯·彼得索恩和其他评论者）

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']