---更新（感谢@lokhmakov简化）---

另一个使用ES6发生器的版本（参见伟大的Paolo Moretti回答ES6发生器）：

const RANGE = (x,y) => Array.from((function*(){
  while (x <= y) yield x++;
})());

console.log(RANGE(3,7));  // [ 3, 4, 5, 6, 7 ]

或者，如果我们只需要可迭代，那么：

const RANGE_ITER = (x,y) => (function*(){
  while (x <= y) yield x++;
})();

for (let n of RANGE_ITER(3,7)){
  console.log(n);
}

// 3
// 4
// 5
// 6
// 7

---原始代码为：---

const RANGE = (a,b) => Array.from((function*(x,y){
  while (x <= y) yield x++;
})(a,b));

and

const RANGE_ITER = (a,b) => (function*(x,y){
  while (x <= y) yield x++;
})(a,b);

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

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

使用这个。它创建了一个具有给定数量的值（未定义）的数组，在下面的示例中有100个索引，但它并不相关，因为这里只需要键。它在数组中使用100+1，因为数组始终基于0索引。因此，如果要生成100个值，则索引从0开始；因此最后的值总是99而不是100。

范围（2100）；功能范围（开始、结束）{console.log（[…Array（end+1）.keys（）].filter（value=>end>=value&&start<=value））；}

我刚刚通过Object.defineProperty在Array上创建了这个polyfill，以创建整数或字符串的范围。Object.defineProperty是创建polyfills的一种更安全的方法。

更安全的polyfill

if (!Array.range) {
  Object.defineProperty(Array, 'range', {
    value: function (from, to, step) {
      if (typeof from !== 'number' && typeof from !== 'string') {
        throw new TypeError('The first parameter should be a number or a character')
      }

      if (typeof to !== 'number' && typeof to !== 'string') {
        throw new TypeError('The second parameter should be a number or a character')
      }

      var A = []
      if (typeof from === 'number') {
        A[0] = from
        step = step || 1
        while (from + step <= to) {
          A[A.length] = from += step
        }
      } else {
        var s = 'abcdefghijklmnopqrstuvwxyz'
        if (from === from.toUpperCase()) {
          to = to.toUpperCase()
          s = s.toUpperCase()
        }
        s = s.substring(s.indexOf(from), s.indexOf(to) + 1)
        A = s.split('')
      }
      return A
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.range has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when Array.range() is executed.'
  console.log(errorMessage)
}

示例

Array.range(1, 3)

// Return: [1, 2, 3]

Array.range(1, 3, 0.5)

// Return: [1, 1.5, 2, 2.5, 3]

Array.range('a', 'c')

// Return: ['a', 'b', 'c']

Array.range('A', 'C')

// Return: ['A', 'B', 'C']

Array.range(null)
Array.range(undefined)
Array.range(NaN)
Array.range(true)
Array.range([])
Array.range({})
Array.range(1, null)

// Return: Uncaught TypeError: The X parameter should be a number or a character

这是我模仿Python的解决方案。在底部，您可以找到一些如何使用它的示例。它与数字一起工作，就像Python的范围一样：

var assert = require('assert');    // if you use Node, otherwise remove the asserts

var L = {};    // L, i.e. 'list'

// range(start, end, step)
L.range = function (a, b, c) {
    assert(arguments.length >= 1 && arguments.length <= 3);
    if (arguments.length === 3) {
        assert(c != 0);
    }

    var li = [],
        i,
        start, end, step,
        up = true;    // Increasing or decreasing order? Default: increasing.

    if (arguments.length === 1) {
        start = 0;
        end = a;
        step = 1;
    }

    if (arguments.length === 2) {
        start = a;
        end = b;
        step = 1;
    }

    if (arguments.length === 3) {
        start = a;
        end = b;
        step = c;
        if (c < 0) {
            up = false;
        }
    }

    if (up) {
        for (i = start; i < end; i += step) {
            li.push(i);
        }
    } else {
        for (i = start; i > end; i += step) {
            li.push(i);
        }
    }

    return li;
}

示例：

// range
L.range(0) -> []
L.range(1) -> [0]
L.range(2) -> [0, 1]
L.range(5) -> [0, 1, 2, 3, 4]

L.range(1, 5) -> [1, 2, 3, 4]
L.range(6, 4) -> []
L.range(-2, 2) -> [-2, -1, 0, 1]

L.range(1, 5, 1) -> [1, 2, 3, 4]
L.range(0, 10, 2) -> [0, 2, 4, 6, 8]
L.range(10, 2, -1) -> [10, 9, 8, 7, 6, 5, 4, 3]
L.range(10, 2, -2) -> [10, 8, 6, 4]

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

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