这里有一个很好的简单方法，可以在ES6中只使用数字（不知道它的速度比较）：

Array.prototype.map.call(' '.repeat(1 + upper - lower), (v, i) => i + lower)

对于单个字符的范围，可以稍微修改一下：

Array.prototype.map.call(' '.repeat(1 + upper.codePointAt() - lower.codePointAt()), (v, i) => String.fromCodePoint(i + lower.codePointAt()));

对于数字，您可以使用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

它适用于字符和数字，通过可选步骤向前或向后移动。

var range = function(start, end, step) {
    var range = [];
    var typeofStart = typeof start;
    var typeofEnd = typeof end;

    if (step === 0) {
        throw TypeError("Step cannot be zero.");
    }

    if (typeofStart == "undefined" || typeofEnd == "undefined") {
        throw TypeError("Must pass start and end arguments.");
    } else if (typeofStart != typeofEnd) {
        throw TypeError("Start and end arguments must be of same type.");
    }

    typeof step == "undefined" && (step = 1);

    if (end < start) {
        step = -step;
    }

    if (typeofStart == "number") {

        while (step > 0 ? end >= start : end <= start) {
            range.push(start);
            start += step;
        }

    } else if (typeofStart == "string") {

        if (start.length != 1 || end.length != 1) {
            throw TypeError("Only strings with one character are supported.");
        }

        start = start.charCodeAt(0);
        end = end.charCodeAt(0);

        while (step > 0 ? end >= start : end <= start) {
            range.push(String.fromCharCode(start));
            start += step;
        }

    } else {
        throw TypeError("Only string and number types are supported");
    }

    return range;

}

jsFiddle。

如果扩充本机类型是您的事情，那么将其分配给Array.range。

var范围=函数（开始、结束、步骤）{var范围=[]；var typeofStart=启动类型；var typeofEnd=结束类型；如果（步骤==0）{throw TypeError（“步长不能为零。”）；}if（类型开始==“undefined”| |类型结束==“未定义”）{throw TypeError（“必须传递开始和结束参数。”）；}否则如果（typeofStart！=typeofEnd）{throw TypeError（“开始和结束参数必须是相同的类型。”）；}步骤类型==“未定义”&&（步骤=1）；if（结束<开始）{step=-步骤；}if（开始类型==“number”）{while（步骤>0？结束>=开始：结束<=开始）{范围.推（启动）；开始+=步骤；}}否则if（typeofStart==“string”）{如果（start.length！=1 | | end.length；=1）{throw TypeError（“仅支持带有一个字符的字符串。”）；}start=start.charCodeAt（0）；end=end.charCodeAt（0）；while（步骤>0？结束>=开始：结束<=开始）{range.push（String.fromCharCode（开始））；开始+=步骤；}}其他{throw TypeError（“仅支持字符串和数字类型”）；}返回范围；}console.log（范围（“A”，“Z”，1））；console.log（范围（“Z”，“A”，1））；console.log（范围（“A”，“Z”，3））；console.log（范围（0，25，1））；console.log（范围（0，25，5））；console.log（范围（20，5，5））；

d3还具有内置范围功能。

看见https://github.com/d3/d3-array#range:

d3.范围（[开始，]停止[，步骤]）

生成包含算术级数的数组，类似于Python内置范围。此方法通常用于迭代一系列数值或整数值，例如数组中的索引。与Python版本不同，参数不需要是整数，但如果是由于浮点精度，则结果更可预测。如果省略步骤，则默认为1。

例子：

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

nope-在2002年仍然没有原生javascript范围，但这个简洁的ES6箭头函数可以像PHP一样提供升序和降序的数字和字符串（包括步骤）。

//@return数字或字符串的升序或降序范围常量范围=（a，b，d=1）=>类型a==“字符串”? range（a.charCodeAt（），b.charCodeAt（））.map（v=>String.fromCharCode（v））：isNaN（b）? 范围（0，a-1）：b<a? 范围（b，a，d）反向（）：d>1? 范围（a，b）。过滤器（v=>v%d==0）：[a，b].reduce（（min，max）=>阵列（max+1-min）.填充（min）.map（（v，i）=>v+i））；//用途控制台断言(range（3）.toString（）=='0,1,2'&&range（2,4）.toString（）==“2,3,4”&&range（4,2）.toString（）=='4,3,2'&&范围（5,15,5）.toString（）=='5,10,15'&&range（'A'，'C'）.toString（）==“A，B，C”&&range（'C'，'A'）.toString（）=='C，B，A');

如果我们输入类似[4,2]的内容，我们将得到[2,3,4]作为输出，我们可以使用它。

function createRange(array) {
  var range = [];
  var highest = array.reduce(function(a, b) {
    return Math.max(a, b);
  });
  var lowest = array.reduce(function(a, b) {
    return Math.min(a, b);
  });
  for (var i = lowest; i <= highest; i++) {
    range.push(i);
  }
  return range;
}