我回顾了这里的答案，并注意到以下几点：

JavaScript没有解决此问题的内置解决方案某些答案生成大小正确但值错误的数组例如，让arr=Array.from（{length:3}）；//给出[null，null，null]然后，使用映射函数将错误的值替换为正确的值例如arr.map（（e，i）=>i）；//给出[0,1,2]需要数学来移动数字范围，以满足从。。符合要求。例如arr.map（（e，i）=>i+1）；//给出[1,2,3]对于问题的字符串版本，需要charCodeAt和fromCharCode将字符串映射到一个数字，然后再返回到一个字符串。例如arr.map（（e，i）=>String.fromCharCode（i+“A”.charCodeAt（0））；//给出[“A”、“B”、“C”]

有一些基于以上部分或全部的简单到花哨的实现。当他们试图将整数和字符串解打包到一个函数中时，答案变得复杂起来。对我来说，我选择在它们自己的函数中实现整数和字符串解决方案。我证明这是合理的，因为在实践中，你会知道你的用例是什么，你会直接使用适当的函数。如果您想间接调用包装器函数，我也会提供它。

让rangeInt=（from，to）=>Array.from（｛length:to from+1｝，（e，i）=>i+from）；let rangeChar=（from，to）=>数组.from（｛length:to.charCodeAt（0）-from.charCodeAt（0）+1｝，（e，i）=>字符串.fromCharCode（i+from.charCode At（1）））；让范围=（从，到）=>（typeof（from）==“string”&&typeof（to）===“string”）? rangeChar（从，到）：（！to）？rangeInt（0，from-1）：范围Int（从，到）；console.log（rangeInt（1,3））；//给出[1,2,3]console.log（rangeChar（“A”，“C”））；//给出[“A”、“B”、“C”]console.log（范围（1,3））；//给出[1,2,3]console.log（范围（“A”、“C”））；//给出[“A”、“B”、“C”]console.log（范围（3））；//给出[0,1,2]

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

在Vue中循环0和长度之间的数字范围：

<div v-for="index in range" />

computed: {
   range () {
        let x = [];

        for (let i = 0; i < this.myLength; i++)
        {
            x.push(i);
        }

        return x;
    }
}
    

…更大范围，使用生成器功能。

function range(s, e, str){
  // create generator that handles numbers & strings.
  function *gen(s, e, str){
    while(s <= e){
      yield (!str) ? s : str[s]
      s++
    }
  }
  if (typeof s === 'string' && !str)
    str = 'abcdefghijklmnopqrstuvwxyz'
  const from = (!str) ? s : str.indexOf(s)
  const to = (!str) ? e : str.indexOf(e)
  // use the generator and return.
  return [...gen(from, to, str)]
}

// usage ...
console.log(range('l', 'w'))
//=> [ 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w' ]

console.log(range(7, 12))
//=> [ 7, 8, 9, 10, 11, 12 ]

// first 'o' to first 't' of passed in string.
console.log(range('o', 't', "ssshhhooooouuut!!!!"))
// => [ 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 't' ]

// only lowercase args allowed here, but ...
console.log(range('m', 'v').map(v=>v.toUpperCase()))
//=> [ 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V' ]

// => and decreasing range ...
console.log(range('m', 'v').map(v=>v.toUpperCase()).reverse())

// => ... and with a step
console.log(range('m', 'v')
          .map(v=>v.toUpperCase())
          .reverse()
          .reduce((acc, c, i) => (i % 2) ? acc.concat(c) : acc, []))

// ... etc, etc.

希望这有用。

对于具有良好向后兼容性的更像红宝石的方法：

范围（[开始]，结束=0），其中开始和结束是数字

var range = function(begin, end) {
  if (typeof end === "undefined") {
    end = begin; begin = 0;
  }
  var result = [], modifier = end > begin ? 1 : -1;
  for ( var i = 0; i <= Math.abs(end - begin); i++ ) {
    result.push(begin + i * modifier);
  }
  return result;
}

示例：

range(3); //=> [0, 1, 2, 3]
range(-2); //=> [0, -1, -2]
range(1, 2) //=> [1, 2]
range(1, -2); //=> [1, 0, -1, -2]

我最喜欢的是生成器generateRange，它带有另一个运行生成器的函数getRange。与许多其他解决方案相比，这样做的一个优点是不需要的阵列不会多次创建。

function* generateRange(start, end, step = 1) {
    let current = start;
    while (start < end ? current <= end : current >= end) {
        yield current;
        current = start < end ? current + step : current - step;
    }
}

function getRange(start, end, step = 1) {
    return [...generateRange(start, end, step)];
}

console.log(getRange(0, 5)) // [ 0, 1, 2, 3, 4, 5 ]
console.log(getRange(10, 0, 2)) // [ 10, 8, 6, 4, 2, 0 ]