ES6：

Question

说我有以下复选框：

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

要获得定义我正在寻找的范围边界的两个数字，我使用以下jQuery：

var value = $(this).val();
var lowEnd = Number(value.split('-')[0]);
var highEnd = Number(value.split('-')[1]);

如何创建一个包含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]

Answer 1

var list = [];
for (var i = lowEnd; i <= highEnd; i++) {
    list.push(i);
}

Answer 2

在JavaScript ES6中：

INNER JOIN users ON projects.manager_id = users.user_id 
AND projects.product_owner_id = users.user_id

为了完整性，这里有一个可选的SELECT projects.project_name, projects.manager_id, projects.product_owner_id, projects.project_description, projects.status, sprints.sprint_name, sprints.sprint_start_date, sprints.sprint_length, sprints.work_mon, sprints.work_tue, sprints.work_wed, sprints.work_thu, sprints.work_fri, sprints.work_sat, sprints.work_sun, projects.project_id, sprints.project_id AS Expr1, sprints.sprint_id, users.username FROM projects INNER JOIN users ON projects.manager_id = users.user_id INNER JOIN sprints ON projects.project_id = sprints.project_id WHERE (projects.project_id = @project_id)参数。

function range(start, end) {
  return Array(end - start + 1).fill().map((_, idx) => start + idx)
}
var result = range(9, 18); // [9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
console.log(result);

我会在实际项目中使用range-inclusive中的npm。它甚至支持向后的步骤，所以很酷。

Answer 3

我强烈推荐使用下划线或lo-dash库：

http://underscorejs.org/#range

（几乎完全兼容，显然lodash跑得更快，但下划线有更好的doco恕我直言）

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

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

Answer 4

我的循环版本;）

var lowEnd = 1;
var highEnd = 25;
var arr = [];
while(lowEnd <= highEnd){
   arr.push(lowEnd++);
}

Answer 5

用例

var genArr=(1)['..'](10)  //[1,2,3,4,5,6,7,8,9,10]

API;

Number.prototype['..']=function(to,step){
     var arr = [],from=this;
     while(from <= to){
        arr.push(from++);
     }
     return arr;
};

FIDDLE：

http://jsfiddle.net/abdennour/mcpnvsmm/

ES6：

＆＃13;

console.log(
   Array.from({length:10},(v,k)=>k+1)
)

＆＃13;

Answer 6

最快的方式

while--在大多数浏览器上速度更快
直接设置变量比推送

功能：

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

编辑

可读版本

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

<强>演示

http://jsfiddle.net/W3CUn/

对于下行者

<强>性能

http://jsperf.com/for-push-while-set/2

在ie中更快，在firefox中快3倍

仅在aipad air上，for循环更快一些。

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

使用chrome，ff，即safari，移动游猎。

我希望在较旧的浏览器上看到for循环没有优化的性能！

Answer 7

function range(j, k) { 
    return Array
        .apply(null, Array((k - j) + 1))
        .map(function(_, n){ return n + j; }); 
}

这大致相当于

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

然后

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

将稀疏矩阵作为参数列表传递给Array构造函数，该构造函数生成（实际）长度targetLength的密集矩阵，其中所有元素都具有未定义的值。第一个论点是＆＃39;这个＆＃39;数组构造函数执行上下文的值，并且在此处不起作用，因此为null。

现在，

 console.log(b);

产量

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

最后

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

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

那么

console.log(c);

产量

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

Answer 8

如果开始总是小于结束，我们可以这样做：

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]

如果我们希望能够采用第三个参数来修改用于构建数组的步骤，并使其工作即使开头大于结束：

function otherRange(start, end, step) {
  otherArray = [];
  if (step == undefined) {
    step = 1;
  };
  if (step > 0) {
    for (var i = start; i <= end; i += step) {
      otherArray.push(i);
    }
  } else {
    for (var i = start; i >= end; i += step) {
      otherArray.push(i);
    }
  };
  return otherArray;
};
console.log(otherRange(10, 0, -2));        // → [10, 8, 6, 4, 2, 0]
console.log(otherRange(10, 15));           // → [10, 11, 12, 13, 14, 15]
console.log(otherRange(10, 20, 2));        // → [10, 12, 14, 16, 18, 20]

这样，该函数接受正步和负步，如果没有给出步，则默认为1.

Answer 9

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;

可能有一种DRYer方式来进行循环，但这是基本的想法。

Answer 10

function createNumberArray(lowEnd, highEnd) {
    var start = lowEnd;
    var array = [start];
    while (start < highEnd) {
        array.push(start);
        start++;
    }
}

Answer 11

您可以设计一种范围方法，将“从”数字增加所需的数量，直到达到“到”数字。此示例将向上或向下“计数”，具体取决于from是大于还是小于。

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（0,1，.01）您将需要截断任何浮点不精确的值。否则你将返回类似的数字 0.060000000000000005而不是.06。

这会给其他版本增加一点开销，但对于整数或小数步骤可以正常工作。

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

Answer 12

我的五分钱：

两个方向整数数组。

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

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

基于this回答。

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

P.S。要在现实生活中使用，您还应检查isFinite()和isNaN()的参数。

Answer 13

将http://minifiedjs.com/添加到答案列表中：）

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

observeEvent()

这里的文件： http://minifiedjs.com/api/range.html

我使用minified.js因为它以低占用空间和易于理解的语法解决了我的所有问题。对我来说，它是一个框架中jQuery，MustacheJS和Underscore / SugarJS的替代品。

当然，它并不像下划线那样受欢迎。这可能是一些人关注的问题。

Tim Jansen使用CC-0（公共领域）许可证提供了缩小版。

Answer 14

        function getRange(a,b)
        {
            ar = new Array();
            var y = a - b > 0 ? a - b : b - a;
            for (i=1;i<y;i++)
            {
                ar.push(i+b);
            }
            return ar;
        }

Answer 15

在underscore

中解决

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

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

15 个答案:

用例

API;

FIDDLE：

ES6：