在下划线中求解

data = [];
_.times( highEnd, function( n ){ data.push( lowEnd ++ ) } );

函数getRange (a, b) ｛ ar = new Array(); Var y = a - b > 0 ?A - b: b - A; (我= 1,< y;我+ +) ｛ ar.push (i + b); ｝ 返回基于“增大化现实”技术; }

var values = $(this).val().split('-'),
    i = +values[0],
    l = +values[1],
    range = [];

while (i < l) {
    range[range.length] = i;
    i += 1;
}

range[range.length] = l;

可能有一个烘干机的方式来做循环，但这是基本的想法。

这里有3个函数，它们应该涵盖了我能想到的一切(包括对其他一些答案中的问题的修复):rangeInt()， range()和between()。在所有情况下都考虑升序和降序。

例子

范围英特（）

包括端点并且只处理整数

rangeInt(1, 4)  // [1, 2, 3, 4] Ascending order
rangeInt(5, 2)  // [5, 4, 3, 2] Descending order
rangeInt(4, 4)  // [4]          Singleton set (i.e. not [4, 4])
rangeInt(-1, 1) // [-1, 0, 1]   Mixing positive and negative

range ()

与rangeInt()相同，除了

不限于整数 允许在第三个参数中指定数量的点

range(0, 10, 2)  // [0, 3.333, 6.666, 10] Gets endpoints and 2 points between
range(0, 1.5, 1) // [0, 0.75, 1.5]        Accepts fractions

间()

与range()相同，除了

不包括端点 没有单例集(将返回一个空数组)

between(0, 10, 2) // [3.333, 6.666]
between(-1, -1.5) // [-1.25]
between(4, 4, 99) // []

源

/**
 * Gets a set of integers that are evenly distributed along a closed interval
 * @param {int} begin - Beginning endpoint (inclusive)
 * @param {int} end   - Ending endpoint (inclusive)
 * @return {Array} Range of integers
 */
function rangeInt( begin, end )  {
    if ( !Number.isInteger(begin) || !Number.isInteger(end) ) {
        throw new Error('All arguments must be integers')
    }
    return range(begin, end, Math.abs(end - begin) - 1)
}

/**
 * Gets a set of numbers that are evenly distributed along a closed interval
 * @param {Number} begin  - Beginning endpoint (inclusive)
 * @param {Number} end    - Ending endpoint (inclusive)
 * @param {int}    points - How many numbers to retrieve from the open interval
 * @return {Array} Range of numbers
 */
function range( begin, end, points ) {
    if ( begin !== end ) {
        return [ begin, ...between(begin, end, points), end ]
    }
    else if ( Number.isFinite(begin) ) {
        return [ begin ] // singleton set
    }
    else throw new Error('Endpoints must be finite')
}

/**
 * Gets a subset of numbers that are evenly distributed along an open interval
 * @param {Number} begin  - Beginning endpoint (exclusive)
 * @param {Number} end    - Ending endpoint (exclusive)
 * @param {int}    points - How many numbers to retrieve from the interval
 * @return {Array} Retrieved numbers
 */
function between( begin, end, points = 1 ) {
    if ( !Number.isFinite(begin) || !Number.isFinite(end) || !Number.isFinite(points) ) {
        throw new Error('All arguments must be finite')
    }
    const set = []
    // Skip if an open interval does not exist
    if ( begin !== end ) {
        const step = (end - begin) / (points + 1)
        for ( let i = 0; i < points; i++ ) {
            set[i] = begin + (i + 1) * step
        }
    }
    return set
}

纯ES6解决方案

受到上面m59的答案的启发，但没有对填充的依赖:

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

你可以这样使用它:

range(3,5)
=> [3, 4, 5]

在JavaScript ES6中:

函数范围(start, end) { 返回Array(end - start + 1).fill()。Map ((_， idx) => start + idx) ｝ Var结果= range(9,18);// [9,10,11,12,13,14,15,16,17,18] console.log(结果);

为了完整起见，这里有一个可选的step参数。

函数范围(start, end, step = 1) { const len =数学。楼层((结束-开始)/台阶)+ 1 返回数组(len) .fill()。Map ((_， idx) => start + (idx * step)) ｝ Var结果= range(9,18,0.83); console.log(结果);

我会在实际项目中使用npm的range-inclusive。它甚至支持后退，这很酷。