解决方案：

//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
    });
}

对一些不同的范围函数进行了研究。检查执行这些函数的不同方法的jsperf比较。当然不是一个完美或详尽的列表，但应该有帮助：）

获胜者是。。。

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

从技术上讲，它不是firefox上最快的，但铬合金上的疯狂速度差（imho）弥补了这一点。

还有一个有趣的观察是，与firefox相比，chrome使用这些阵列功能的速度要快得多。Chrome速度至少快4或5倍。

简单范围函数：

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

要合并BigInt数据类型，可以包括一些检查，以确保所有变量都是相同的开始类型：

function range(start, stop, step) {
    var a = [start], b = start;
    if (typeof start == 'bigint') {
        stop = BigInt(stop)
        step = step? BigInt(step): 1n;
    } else
        step = step || 1;
    while (b < stop) {
        a.push(b += step);
    }
    return a;
}

要删除高于停止定义的值，例如范围（0,5,2）将包括6，但不应是。

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

我很惊讶地看到了这条线索，并没有看到任何类似我的解决方案（也许我错过了答案），所以就在这里。我在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;});

这是我模仿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]

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]