解决方案：

//best performance
var range = function(start, stop, step) {
    var a = [start];
    while (start < stop) {
        start += step || 1;
        a.push(start);
    }
    return a;
};

//or
var range = function(start, end) {
    return Array(++end-start).join(0).split(0).map(function(n, i) {
        return i+start
    });
}

Python风格的方式：

range = (start, end, step) => {
let arr = []
for(let n=start;n<end;n+=(step||1)) arr.push(n)
return arr;
}

标准的Javascript没有生成范围的内置函数。有几个javascript框架添加了对这些功能的支持，或者正如其他人所指出的那样，您可以一直使用自己的功能。

如果您想再次检查，确定的资源是ECMA-262标准。

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

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））；

只是在Elquent JavaScript中做了这样的练习

function range(start, end, step) {
  var ar = [];
  if (start < end) {
    if (arguments.length == 2) step = 1;
    for (var i = start; i <= end; i += step) {
      ar.push(i);
    }
  }
  else {
    if (arguments.length == 2) step = -1;
    for (var i = start; i >= end; i += step) {
      ar.push(i);
    }
  }
  return ar;
}

我很惊讶地看到了这条线索，并没有看到任何类似我的解决方案（也许我错过了答案），所以就在这里。我在ES6语法中使用了一个简单的范围函数：

// [begin, end[
const range = (b, e) => Array.apply(null, Array(e - b)).map((_, i) => {return i+b;});

但它只在向前计数时有效（即begin<end），因此我们可以在需要时对其进行轻微修改，如下所示：

const range = (b, e) => Array.apply(null, Array(Math.abs(e - b))).map((_, i) => {return b < e ? i+b : b-i;});