JavaScript是否有像"range()"这样的方法来生成提供的范围内的范围？

Question

在PHP中,你可以做...

range(1, 3); // Array(1, 2, 3)
range("A", "C"); // Array("A", "B", "C")

也就是说,有一个函数可以通过传递上限和下限来获取一系列数字或字符.

是否内置了JavaScript本身的内容？如果没有,我将如何实施它？

Answer 1

数字

[...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归功于nils petersohn和其他评论者)

Answer 2

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

Answer 3

我最喜欢的表格(ES2015)

Array(10).fill(1).map((x, y) => x + y)

如果你需要一个带step参数的函数:

const range = (start, stop, step = 1) =>
  Array(Math.ceil((stop - start) / step)).fill(start).map((x, y) => x + y * step)

Answer 4

这是我的2美分:

function range(start, count) {
  return Array.apply(0, Array(count))
    .map((element, index) => index + start);
}

Answer 5

它适用于字符和数字,可选步骤前进或后退.

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 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;

}

console.log(range("A", "Z", 1));
console.log(range("Z", "A", 1));
console.log(range("A", "Z", 3));


console.log(range(0, 25, 1));

console.log(range(0, 25, 5));
console.log(range(20, 5, 5));

Answer 6

简单范围功能:

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

Answer 7

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

Answer 8

好的,在JavaScript中我们没有range()像PHP这样的函数,所以我们需要创建一个非常容易的函数,我为你编写了几个单行函数,并将它们分别用于Numbers和Alphabets,如下所示:

对于数字:

function numberRange (start, end) {
  return new Array(end - start).fill().map((d, i) => i + start);
}

并称之为:

numberRange(5, 10); //[5, 6, 7, 8, 9]

对于字母:

function alphabetRange (start, end) {
  return new Array(end.charCodeAt(0) - start.charCodeAt(0)).fill().map((d, i) => String.fromCharCode(i + start.charCodeAt(0)));
}

并称之为:

alphabetRange('c', 'h'); //["c", "d", "e", "f", "g"]

Answer 9

/sf/answers/3470413201/

使用 Delta/Step

最小单线

[...Array(N)].map((_, i) => from + i * step);

示例和其他替代方案

[...Array(10)].map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array.from(Array(10)).map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array.from(Array(10).keys()).map(i => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

[...Array(10).keys()].map(i => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

Array(10).fill(0).map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array(10).fill().map((_, i) => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

范围函数

const range = (from, to, step) =>
  [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);

range(0, 9, 2);
//=> [0, 2, 4, 6, 8]

// can also assign range function as static method in Array class (but not recommended )
Array.range = (from, to, step) =>
  [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);

Array.range(2, 10, 2);
//=> [2, 4, 6, 8, 10]

Array.range(0, 10, 1);
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Array.range(2, 10, -1);
//=> []

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

作为迭代器

class Range {
  constructor(total = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function* () {
      for (let i = 0; i < total; yield from + i++ * step) {}
    };
  }
}

[...new Range(5)]; // Five Elements
//=> [0, 1, 2, 3, 4]
[...new Range(5, 2)]; // Five Elements With Step 2
//=> [0, 2, 4, 6, 8]
[...new Range(5, -2, 10)]; // Five Elements With Step -2 From 10
//=>[10, 8, 6, 4, 2]
[...new Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of new Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

仅作为发电机

const Range = function* (total = 0, step = 1, from = 0) {
  for (let i = 0; i < total; yield from + i++ * step) {}
};

Array.from(Range(5, -2, -10));
//=> [-10, -12, -14, -16, -18]

[...Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

// Lazy loaded way
const number0toInf = Range(Infinity);
number0toInf.next().value;
//=> 0
number0toInf.next().value;
//=> 1
// ...

从到与步骤/增量

使用迭代器

class Range2 {
  constructor(to = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function* () {
      let i = 0,
        length = Math.floor((to - from) / step) + 1;
      while (i < length) yield from + i++ * step;
    };
  }
}
[...new Range2(5)]; // First 5 Whole Numbers
//=> [0, 1, 2, 3, 4, 5]

[...new Range2(5, 2)]; // From 0 to 5 with step 2
//=> [0, 2, 4]

[...new Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

使用发电机

const Range2 = function* (to = 0, step = 1, from = 0) {
  let i = 0,
    length = Math.floor((to - from) / step) + 1;
  while (i < length) yield from + i++ * step;
};

[...Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

let even4to10 = Range2(10, 2, 4);
even4to10.next().value;
//=> 4
even4to10.next().value;
//=> 6
even4to10.next().value;
//=> 8
even4to10.next().value;
//=> 10
even4to10.next().value;
//=> undefined

对于打字稿

class _Array<T> extends Array<T> {
  static range(from: number, to: number, step: number): number[] {
    return Array.from(Array(Math.floor((to - from) / step) + 1)).map(
      (v, k) => from + k * step
    );
  }
}
_Array.range(0, 9, 1);

/sf/answers/4521941861/

单行生成字符列表

class _Array<T> extends Array<T> {
  static range(from: number, to: number, step: number): number[] {
    return Array.from(Array(Math.floor((to - from) / step) + 1)).map(
      (v, k) => from + k * step
    );
  }
}
_Array.range(0, 9, 1);

对于打字稿

const charList = (p: string, q: string, d = 1) => {
  const a = p.charCodeAt(0),
    z = q.charCodeAt(0);
  return [...Array(Math.floor((z - a) / d) + 1)].map((_, i) =>
    String.fromCharCode(a + i * d)
  );
};

Answer 10

如果在 Visual Studio Code 上遇到以下错误：

类型“IterableIterator”不是数组类型或字符串类型。使用编译器选项“--downlevelIteration”允许迭代器进行迭代。

代替

[...Array(3).keys()]

你可以信赖

Array.from(Array(3).keys())

更多关于downlevelIteration

Answer 11

方便的功能来完成这个技巧,运行下面的代码片段

function range(start, end, step, offset) {
  
  var len = (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1;
  var direction = start < end ? 1 : -1;
  var startingPoint = start - (direction * (offset || 0));
  var stepSize = direction * (step || 1);
  
  return Array(len).fill(0).map(function(_, index) {
    return startingPoint + (stepSize * index);
  });
  
}

console.log('range(1, 5)=> ' + range(1, 5));
console.log('range(5, 1)=> ' + range(5, 1));
console.log('range(5, 5)=> ' + range(5, 5));
console.log('range(-5, 5)=> ' + range(-5, 5));
console.log('range(-10, 5, 5)=> ' + range(-10, 5, 5));
console.log('range(1, 5, 1, 2)=> ' + range(1, 5, 1, 2));

这是如何使用它

范围(开始,结束,步骤= 1,偏移= 0);

• 包容性 - 前进 range(5,10) // [5, 6, 7, 8, 9, 10]
• 包容性 - 落后 range(10,5) // [10, 9, 8, 7, 6, 5]
• 步 - 向后 range(10,2,2) // [10, 8, 6, 4, 2]
• 独家 - 前锋 range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• 偏移 - 扩展 range(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]
• 抵消 - 缩小 range(5,10,0,-2) // [7, 8]
• 步骤 - 扩大 range(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)使其更简单(两个方向/步骤的差异*偏移)
• 获得长度后,我们使用check here创建一个带有初始化值的空数组new Array(length).fill(0);
• 现在我们有一个[0,0,0,..]我们想要的长度数组.我们映射它并使用我们需要的值返回一个新数组Array.map(function() {})
• var direction = start < end ? 1 : 0;显然,如果start不小于end我们需要向后移动.我的意思是从0到5,反之亦然
• 在每次迭代中,startingPoint+ stepSize*index将为我们提供所需的价值

Answer 12

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

Answer 13

使用Harmony 传播操作符和箭头函数:

var range = (start, end) => [...Array(end - start + 1)].map((_, i) => start + i);

例:

range(10, 15);
[ 10, 11, 12, 13, 14, 15 ]

Answer 14

标准Javascript没有内置函数来生成范围.一些javascript框架添加了对这些功能的支持,或者正如其他人指出的那样,你可以随时使用自己的功能.

如果您想仔细检查,最终资源是ECMA-262标准.

Answer 15

对一些不同的范围函数进行了一些研究. 检查jsperf比较执行这些功能的不同方法.当然不是一个完美或详尽的清单,但应该帮助:)

获胜者是......

function range(lowEnd,highEnd){
    var arr = [],
    c = highEnd - lowEnd + 1;
    while ( c-- ) {
        arr[c] = highEnd--
    }
    return arr;
}
range(0,31);

从技术上讲,它不是firefox上最快的,但是Chrome上的疯狂速度差异(imho)弥补了它.

同样有趣的观察是这些数组函数的速度比firefox快多少.Chrome的速度至少快4到5倍.

Answer 16

你可以使用lodash或Undescore.js range:

var range = require('lodash/range')
range(10)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

或者,如果您只需要一个连续的整数范围,您可以执行以下操作:

Array.apply(undefined, { length: 10 }).map(Number.call, Number)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

在ES6中range可以使用生成器实现:

function* range(start=0, end=null, step=1) {
  if (end == null) {
    end = start;
    start = 0;
  }

  for (let i=start; i < end; i+=step) {
    yield i;
  }
}

这种实现在迭代大型序列时可以节省内存,因为它不必将所有值都实现为数组:

for (let i of range(1, oneZillion)) {
  console.log(i);
}

Answer 17

(from, to) => [...Array(to - from)].map((_,i)=> i + from)

Answer 18

如果只想使用范围来重复过程 n 次，您可以简单地使用此代码

[...Array(10)].map((item, index) => ( 
    console.log("item:", index)
))

Answer 19

使用ES6发生器的另一个版本(参见伟大的Paolo Moretti回答ES6发生器):

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

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

或者,如果我们只需要迭代,那么:

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

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

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

Answer 20

我个人最喜欢的：

const range = (start, end) => new Array(end-start+1).fill().map((el, ind) => ind + start);

Answer 21

一个有趣的挑战是编写最短的函数来做到这一点.救援的递归!

function r(a,b){return a>b?[]:[a].concat(r(++a,b))}

在大范围内趋于缓慢,但幸运的是量子计算机即将到来.

一个额外的好处是它是混淆的.因为我们都知道将我们的代码隐藏起来是多么重要.

要真正彻底地混淆函数,请执行以下操作:

function r(a,b){return (a<b?[a,b].concat(r(++a,--b)):a>b?[]:[a]).sort(function(a,b){return a-b})}

Answer 22

我会编码这样的代码:

function range(start, end) {
    return Array(end-start).join(0).split(0).map(function(val, id) {return id+start});
}  

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

range(3,9);
// [3,4,5,6,7,8]

它的行为类似于Python范围:

>>> range(-4,2)
[-4, -3, -2, -1, 0, 1]

Answer 23

这个也可以反向工作。

const range = ( a , b ) => Array.from( new Array( b > a ? b - a : a - b ), ( x, i ) => b > a ? i + a : a - i );

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

Answer 24

可以如下创建大量使用ES6的相当简约的实现,特别注意Array.from()静态方法:

const getRange = (start, stop) => Array.from(
  new Array((stop - start) + 1),
  (_, i) => i + start
);

Answer 25

尚未实施！

使用新Number.range 提案（阶段 1）：

[...Number.range(1, 10)]
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Answer 26

虽然这不是来自PHP,而是range来自Python的模仿.

function range(start, end) {
    var total = [];

    if (!end) {
        end = start;
        start = 0;
    }

    for (var i = start; i < end; i += 1) {
        total.push(i);
    }

    return total;
}

console.log(range(10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
console.log(range(0, 10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(range(5, 10)); // [5, 6, 7, 8, 9] 

Answer 27

range(start,end,step)：使用ES6迭代器

您只要求一个上限和下限。在这里，我们也创建了一个步骤。

您可以轻松地创建range()可用作迭代器的生成器函数。这意味着您不必预先生成整个数组。

function * range ( start, end, step = 1 ) {
  let state = start;
  while ( state < end ) {
    yield state;
    state += step;
  }
  return;
};

现在，您可能需要创建一些东西，以便从迭代器中预生成数组并返回一个列表。这对于接受数组的函数很有用。为此，我们可以使用Array.from()

const generate_array = (start,end,step) =>
  Array.from( range(start,end,step) );

现在，您可以轻松生成静态数组，

const array1 = generate_array(1,10,2);
const array1 = generate_array(1,7);

但是，当某些东西需要迭代器（或为您提供使用迭代器的选项）时，您也可以轻松创建一个迭代器。

for ( const i of range(1, Number.MAX_SAFE_INTEGER, 7) ) {
  console.log(i)
}

特别说明

• 如果您使用Ramda，它们R.range和Lodash一样都有自己的

Answer 28

您可以使用以下单行代码来使事情简短而简单

var start = 4;
var end = 20;
console.log(Array(end - start + 1).fill(start).map((x, y) => x + y));

Answer 29

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

range(2, 100);

function range(start, end) {
    console.log([...Array(end + 1).keys()].filter(value => end >= value && start <= value ));
}

Answer 30

使用Harmony生成器,除IE11以外的所有浏览器都支持:

var take = function (amount, generator) {
    var a = [];

    try {
        while (amount) {
            a.push(generator.next());
            amount -= 1;
        }
    } catch (e) {}

    return a;
};

var takeAll = function (gen) {
    var a = [],
        x;

    try {
        do {
            x = a.push(gen.next());
        } while (x);
    } catch (e) {}

    return a;
};

var range = (function (d) {
    var unlimited = (typeof d.to === "undefined");

    if (typeof d.from === "undefined") {
        d.from = 0;
    }

    if (typeof d.step === "undefined") {
        if (unlimited) {
            d.step = 1;
        }
    } else {
        if (typeof d.from !== "string") {
            if (d.from < d.to) {
                d.step = 1;
            } else {
                d.step = -1;
            }
        } else {
            if (d.from.charCodeAt(0) < d.to.charCodeAt(0)) {
                d.step = 1;
            } else {
                d.step = -1;
            }
        }
    }

    if (typeof d.from === "string") {
        for (let i = d.from.charCodeAt(0); (d.step > 0) ? (unlimited ? true : i <= d.to.charCodeAt(0)) : (i >= d.to.charCodeAt(0)); i += d.step) {
            yield String.fromCharCode(i);
        }
    } else {
        for (let i = d.from; (d.step > 0) ? (unlimited ? true : i <= d.to) : (i >= d.to); i += d.step) {
            yield i;
        }
    }
});

例子

采取

例1.

take 只需要尽可能多的钱

take(10, range( {from: 100, step: 5, to: 120} ) )

回报

[100, 105, 110, 115, 120]

例2.

to 不是必要的

take(10, range( {from: 100, step: 5} ) )

回报

[100, 105, 110, 115, 120, 125, 130, 135, 140, 145]

takeAll

例3.

from 不是必要的

takeAll( range( {to: 5} ) )

回报

[0, 1, 2, 3, 4, 5]

例4.

takeAll( range( {to: 500, step: 100} ) )

回报

[0, 100, 200, 300, 400, 500]

例5.

takeAll( range( {from: 'z', to: 'a'} ) )

回报

["z", "y", "x", "w", "v", "u", "t", "s", "r", "q", "p", "o", "n", "m", "l", "k", "j", "i", "h", "g", "f", "e", "d", "c", "b", "a"]

Answer 31

至于为给定范围生成数值数组,我使用:

function range(start, stop)
{
    var array = [];

    var length = stop - start; 

    for (var i = 0; i <= length; i++) { 
        array[i] = start;
        start++;
    }

    return array;
}

console.log(range(1, 7));  // [1,2,3,4,5,6,7]
console.log(range(5, 10)); // [5,6,7,8,9,10]
console.log(range(-2, 3)); // [-2,-1,0,1,2,3]

显然,它不适用于字母数组.

Answer 32

d3 还有一个内置的 range 函数。见https://github.com/mbostock/d3/wiki/Arrays#d3_range：

d3.range([start, ]stop[, step])

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

例子：

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

Answer 33

我的 codegolfing 同事想出了这个（ES6），包括：

(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)

不包括：

(s,f)=>[...Array(f-s)].map((e,i)=>i+s)

Answer 34

这可能不是最好的方法。但是，如果您希望在一行代码中获得一系列数字。例如10-50

Array(40).fill(undefined).map((n, i) => i + 10)

其中40是（结束-开始），而10是开始。这应该返回[10，11，...，50]

Answer 35

你可以使用https://lodash.com/docs#rangelodash函数_.range(10)

Answer 36

使用 range([start, ]stop[, step]) 签名完成 ES6 实现：

function range(start, stop, step=1){
  if(!stop){stop=start;start=0;}
  return Array.from(new Array(int((stop-start)/step)), (x,i) => start+ i*step)
}

如果您想要自动负步进，请添加

if(stop<start)step=-Math.abs(step)

或者更简约：

range=(b, e, step=1)=>{
  if(!e){e=b;b=0}
  return Array.from(new Array(int((e-b)/step)), (_,i) => b<e? b+i*step : b-i*step)
}

如果您的范围很大，请查看 Paolo Moretti 的生成器方法

Answer 37

...更多范围,使用发电机功能.

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.

希望这很有用.

Answer 38

ES6

使用 Array.from（此处为文档）：

const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

Answer 39

您还可以使用生成器来生成序列。\n不同之处在于序列中的每个值都是延迟加载的。扩展运算符和 for of 计算结果。\n星号使该函数成为生成器。

\n

const range = function*(from,to) { \xc2\xa0 \n    for(let i = from; i <= to; i++) yield I; \xc2\xa0 \n}; \xc2\xa0 \n\n[...range(3,5)]// => [3, 4, 5]\n

\n

Answer 40

Op 要求一个范围，比如range(3, 10)，所以它可以是

[...[...Array(10-3).keys()].map(i => i+3)]

回报

[3, 4, 5, 6, 7, 8, 9]