在Javascript/jQuery中创建两个数字（包括）之间的所有整数数组

假设我有以下复选框：

<input type="checkbox" value="1-25" />

然后如何创建一个数组，该数组包含

lowEnd

和

highEnd

之间的所有整数，包括

lowEnd

和

highEnd

本身？对于此特定示例，显然，生成的数组将是：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]

var values=$（this.val（）.split（'-'），
i=+值[0]，
l=+值[1]，
范围=[]；
而（i

可能有一种更简单的方法来实现循环，但这是基本的想法。

函数createNumberArray（低端，高端）{
function createNumberArray(lowEnd, highEnd) {
    var start = lowEnd;
    var array = [start];
    while (start < highEnd) {
        array.push(start);
        start++;
    }
} 

var开始=下降；
var数组=[start]；
while（开始<高端）{
array.push（启动）；
启动++；
}
} 

var list=[]；
对于（var i=lowEnd；i我的循环版本；）

var-lowEnd=1；
var高端=25；
var-arr=[]；
while（lowEnd您可以设计一种范围方法，将“from”数字增加所需的量，直到它达到“to”数字。
此示例将根据from大于还是小于to向上或向下“计数”

Array.range= function(from, to, step){
    if(typeof from== 'number'){
        var A= [from];
        step= typeof step== 'number'? Math.abs(step):1;
        if(from> to){
            while((from -= step)>= to) A.push(from);
        }
        else{
            while((from += step)<= to) A.push(from);
        }
        return A;
    }   
}

Array.range=函数（从，到，步）{
if（typeof from==“number”）{
var A=[from]；
步骤=步骤类型=='number'？Math.abs（步骤）：1；
如果（从>到）{
while（（from-=步骤）>=to）A.push（from）；
}
否则{
while（（从+=步）到）{
而（+（from-=step）.toFixed（prec）>=to）A.push（+from.toFixed（prec））；
}
否则{
while（+（from++=step）.toFixed（prec）最快方式

而在大多数浏览器上速度更快
直接设置变量比推送快
功能：

var x=function(a,b,c,d){d=[];c=b-a+1;while(c--){d[c]=b--}return d},

theArray=x(lowEnd,highEnd);

或

编辑

可读版本

var arr = [],
c = highEnd - lowEnd + 1;
while ( c-- ) {
 arr[c] = highEnd--
}

演示


为下层选民

性能


ie更快，firefox快3倍

只有在aipad上，for循环的速度才稍微快一点

在win8、osx10.8、ubuntu14.04、ipad、ipad air、ipod上测试

使用chrome、ff、ie、safari、mobile safari

我希望在for循环没有优化的旧ie浏览器上看到性能！
我强烈推荐下划线或低破折号库：


（几乎完全兼容，显然lodash运行更快，但下划线具有更好的doco IMHO）

这两个库都有许多非常有用的实用程序。
在

data=[]；
_.times（高端，函数（n）{data.push（lowEnd++）}）；
如果开始总是小于结束，我们可以：

function range(start, end) {
  var myArray = [];
  for (var i = start; i <= end; i += 1) {
    myArray.push(i);
  }
  return myArray;
};
console.log(range(4, 12));                 // → [4, 5, 6, 7, 8, 9, 10, 11, 12]

功能范围（开始、结束）{
var myArray=[]；
对于（变量i=开始；i 0）{
对于（变量i=开始；i=结束；i+=步骤）{
推送（i）；
}
};
返回其他数组；
};
log（其他范围（10,0，-2））；//→ [10, 8, 6, 4, 2, 0]
console.log（其他范围（10,15））；//→ [10, 11, 12, 13, 14, 15]
console.log（其他范围（10,20,2））；//→ [10, 12, 14, 16, 18, 20]

通过这种方式，函数接受正步骤和负步骤，如果没有给出步骤，则默认为1。
ES6:
使用Array.from（文档）：


console.log(
数组.from（{length:5}，（v，k）=>k+1）
)
函数getRange（a，b）
{
ar=新数组（）；
变量y=a-b>0？a-b:b-a；
对于（i=1；i添加到答案列表中：）

代码类似于下划线和其他代码：

var l123 = _.range(1, 4);      // same as _(1, 2, 3)
var l0123 = _.range(3);        // same as _(0, 1, 2)
var neg123 = _.range(-3, 0);   // same as _(-3, -2, -1)
var empty = _.range(2,1);      // same as _()

此处的文档：

我使用minified.js是因为它解决了我所有的问题，占用空间小，语法容易理解。对我来说，它在一个框架中取代了jQuery、MustacheJS和下划线/SugarJS

当然，它不像下划线那么流行。这可能是一些人的担忧

Minified由Tim Jansen使用CC-0（公共域）许可证提供


这大致相当于

function range(j, k) { 
    var targetLength = (k - j) + 1;
    var a = Array(targetLength);
    var b = Array.apply(null, a);
    var c = b.map(function(_, n){ return n + j; });
    return c;
}

细分：

var targetLength = (k - j) + 1;

var a = Array(targetLength);

这将创建一个具有正确标称长度的稀疏矩阵。现在稀疏矩阵的问题是，尽管它具有正确的标称长度，但它没有实际元素，因此，对于

j = 7, k = 13

console.log(a);

给我们

Array [ <7 empty slots> ]

将稀疏矩阵作为参数列表传递给数组构造函数，数组构造函数生成一个长度为（实际）targetLength的密集矩阵，其中所有元素都有未定义的值。第一个参数是数组构造函数执行上下文的“this”值，在这里不起作用，因此为null

那么现在,

 console.log(b);

屈服

 Array [ undefined, undefined, undefined, undefined, undefined, undefined, undefined ]

 Array [ 7, 8, 9, 10, 11, 12, 13 ]

最后

var c = b.map(function(_, n){ return n + j; });

利用Array.map函数将：1.当前元素的值和2.当前元素的索引传递给映射委托/回调的事实。第一个参数被丢弃，而第二个参数在调整开始偏移量后可用于设置正确的序列值

那么

console.log(c);

屈服

 Array [ undefined, undefined, undefined, undefined, undefined, undefined, undefined ]

 Array [ 7, 8, 9, 10, 11, 12, 13 ]

我的五美分：

双向整数数组函数

当范围（0,5）变为
[0,1,2,3,4,5]
时

和范围（5,0）变成
[5,4,3,2,1,0]

根据答案

另外，为了在现实生活中使用，您还应该在JavaScript ES6中检查参数的
isFinite（）
和
isNaN（）
：


功能范围（开始、结束）{
返回数组（end-start+1）.fill（）.map（（\ux，idx）=>start+idx）
}
var结果=范围（9,18）；//[9,10,11,12,13,14,15,16,17,18]
console.log（result）；
仅作为一般信息，在CoffeeScript中它看起来像“1..25”这实际上在JavaScript中转换成了类似的东西。所以没有更简单的方法来实现这一点。@FreeCandies-没错，CoffeeScript有这种方便，但你仍然需要通过编译器运行它-速度慢或不方便，而且你仍然不知道如何手动完成。我真诚地希望我们不会取代“just”
j = 7, k = 13

console.log(a);

Array [ <7 empty slots> ]

var b = Array.apply(null, a);

 console.log(b);

 Array [ undefined, undefined, undefined, undefined, undefined, undefined, undefined ]

var c = b.map(function(_, n){ return n + j; });

console.log(c);

 Array [ 7, 8, 9, 10, 11, 12, 13 ]

function range(start, end) {
  const isReverse = (start > end);
  const targetLength = isReverse ? (start - end) + 1 : (end - start ) + 1;
  const arr = new Array(targetLength);
  const b = Array.apply(null, arr);
  const result = b.map((discard, n) => {
    return (isReverse) ? n + end : n + start;
  });

  return (isReverse) ? result.reverse() : result;
}