用 JavaScript 从1.20创建整数数组的最简单方法

创建这个数组最简单的方法是什么:

var x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20];

例如，for循环:

var x = [];
for (var i=1;i<=20;i++) {
x.push(i);
}

或者 while循环:

var x = [], i = 1, endInt = 20;
while (i <= endInt) {
x.push(i);
i++;
}

是否还有其他更简洁的例子——换句话说——更少的代码？我认为在 Ruby 中等效的代码应该和 1..20一样简单。我不知道 JavaScript 中是否有这样的语法，但我想知道是否有更短的方法来做同样的事情。

更新: 我并没有考虑去掉问题中的分号或者 var作为答案，但是我必须承认这个问题暗示了这一点。我对算法比对字节更感兴趣。抱歉我没说清楚！而且，把它变成一个函数非常简单，只需要在它周围加上 function range(start, end) { /* guts here */ }就可以了。问题是有没有新颖的方法来解决“内脏”问题

96978 次浏览
小开

据我所知，正如您所提到的，使用 for 循环的选项是最简短的。

就是,

var x = [];
for (var i=1;i<=20;i++) {
x.push(i);
}
小开 
var i = 0;
var x = [];
while (i++ < 20) x.push(i);

JSFiddle

小开

我想不出还有什么方法能比46岁更少的人物:

var a=[];while(a.length<20)a.push(a.length+1);

当然，你可以用它来做一个函数。

读取关于函数的注释，您可以执行以下操作

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


while (start <= end) {
arr.push(start++)
}


return arr;
};

然后 range(1, 20)将按预期返回数组。

小开

如果你想在不考虑可读性的情况下尽可能地去掉字符，我能做的只有下面这些:

var x=[],i=0
while(i<20)
x[i]=i+++1

不过比你的好不了多少。

编辑:

实际上，这样做效果更好，减少了几个角色:

var x=[],i=0
while(i<20)
x[i]=++i

编辑2:

下面是一个最少字符数的通用“ range”函数的条目:

function range(s,e){var x=[];while(s<e+1)x.push(s++);return x}

再次强调，不要用这种方式编写代码。 :)

小开

您可以使用 while 循环来实现这一点，在这个循环中，推送操作发生在条件中。Push 返回数组的长度，该长度恰好与本例中的值相同。因此，您可以执行以下操作:

x = []; //normally would use var here
i = 1;  //normally would use var here
while(x.push(i++)<20){}


//at this point, x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

精简版(31个字符)

x=[];i=1;while(x.push(i++)<20);

JsFiddle 例子

小开

我想这是最短的路:

var i=0, arr = [];
while (i++<20){
arr.push(i);
}

或者与 危险的主人答案中的“反常”代码联系在一起:

var i,arr; while (i=i||1, (arr=arr||[]).push(i++)<20){}
小开

我会扩展 Array 的原型，让它更容易访问:

Array.prototype.range = function(start, end) {
if (!this.length) {
while (end >= start) {
this.push(start++);
}
} else {
throw "You can only call 'range' on an empty array";
}
return this;
};


var array = [].range(1, 20);

虽然上面是我能想到的最接近您正在寻找的语法糖，您可能想尝试 咖啡脚本。

它支持您想要的符号。

咖啡剧本:

test = [1..20]


alert test

JavaScript 渲染:

var test;
test = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
alert(test);

您可以在他们的站点上尝试实时示例，并在键入时查看它的转换。

只要单击顶部的 试试咖啡字条链接，就会得到一个控制台，在那里您可以测试一些代码。

小开

你可以创建一个函数。

function createNumArray(a, b) {
var arr = [],
i = a;


while((arr[arr.length] = i) < b) {i++}
return arr;
}

这样你以后就可以编写简洁的代码，比如..。

var arr = createNumArray(1, 20);
小开
最佳答案

最喜欢的方法

2015年9月13日更新:

刚刚提出了这个新的方法，它可以与支持 ES6标准的浏览器一起工作:

> Array(5).fill().map((x,i)=>i)
[0, 1, 2, 3, 4]

注意，上面的代码做了一点额外的工作(用 undefined填充) ，但是相对于使用 for 循环可以实现的加速来说，这是相对较小的。如果你忘记了 .fill，你可能会困惑为什么你的数组是神秘的 [empty x 5]。您可以将上面的代码封装为一个自定义函数，或者使用一种更有意义的方法:

> Array.from(Array(5),(x,i)=>i)
[0, 1, 2, 3, 4]

当然，你可以直接从那里进入你想做的任何事情，比如 python 的列表理解，例如 [i**2 for i in range(5)]:

> Array.from(Array(5), (_,i)=> i**2)
[0, 1, 4, 9, 16]

或者你想把事情搞得更复杂:

> Array.from(Array(5), (_,i)=> {
const R = /*some computation*/;
return /*etc*/;
});

[ edit May，2021] : 理论上，现在定义这样一个函数最简单的方法是 f=i=>i?[...f(i-1),i]:[]，你可以用 range1或者其他什么名字来代替 f，但是由于中间结构的原因，它会非常慢(二次复杂度) ，所以不应该使用。f=i=>i?f(i-1)&&x.push(i)&&x:x=[]是线性复杂度，但依赖于符号滥用，不可读，并且污染了全局变量。但是，由于现在定义箭头函数(它不绑定而是继承 this)非常简洁，所以您可以包装上面的解决方案:

const range1 = n=> Array.from(Array(n), (_,i)=> i+i);
// range1(5)==[1, 2, 3, 4, 5]

实际上，最简单的方法就是做 range(N)，如果你已经有一个长度正好是 N 的列表，那么你只需要做 map: 例如，你不需要做 Array.from(Array(myArr.length), (_,i)=> i**2)，你只需要做 myArr.map((_,i)=> i**2)。(除非你愿意，否则这没有副作用。)

下面的一切都是历史性的:

经过深思熟虑，这是我能想到的最短的 JavaScript 标准 range(N)函数实现:

function range1(i){return i?range1(i-1).concat(i):[]}

注意 : 不要在生产环境中使用它; 它是 O (N ^ 2)

与当前最受欢迎的答案形成对比:

function range1(i){var x=[];var i=1;while(x.push(i++)<i){};return x}

例如:

> range1(5)
[1, 2, 3, 4, 5]

这就像递归的海报孩子，虽然我期望它会更长，直到我考虑到三元 if 语句，这使得它减少到42个必要的字符。

注意，返回[ start，end)的“标准”range函数可以通过执行 .concat(i-1)编写。

更新: 哦，我发现了一个令人难以置信的简短版本，通过滥用 for 循环，反向排序，赋值返回一个值: for(y=[],i=20;y[--i]=i;){}只包含25个字符(尽管你可以将 var y插入 for 循环，如果你不想要0... 19)。如果你需要定义一个函数，它不会比 i?r(i-1).concat(i):[]短，但是如果你不需要定义一个函数，它会比 i?r(i-1).concat(i):[]短。

添加了一些性能分析测试用例: 似乎除了标准的有序 for-loop 之外的所有东西都要慢10倍，至少在 V8上是这样。< a href = “ https://jsPerf.com/array-range-in-javascript”rel = “ nofollow norefrer”> https://jsperf.com/array-range-in-javascript (当然，如果您使用函数样式编程，并且使用函数调用访问每个元素，那么这些都无关紧要。)

小开

这才是正确的选择

var a=[],b=10;while(b--)a[b]=b+1

返回[1,2,3,4,5,6,7,8,9,10]

用开头和长度解释

var array=[],length=20,start=5;while(length--)array[length]=length+start

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

要射程吗？

用开始和结束来解释

var array=[],end=30,start=25,a=end-start+1;while(a--)array[a]=end--

报税表[25,26,27,28,29,30]

为了..

for(var a=[],b=20;b>0;b--,a[b]=b+1)

对于 + + 

for(var a=[],b=0;b<20;b++,a[b]=b+1)

为什么要走这条路？

  1. 而——可能是最快的循环;

  2. 直接设置快于推动和连接;

  3. []也比 new Array (10)快;

  4. 它的代码并不比其他代码长多少

字节保存技巧:

  1. 使用参数作为 in 函数变量的占位符
  2. 如果不需要，不要使用 new Array ()、 push ()、 concat ()
  3. 仅在需要时放置“(){} ;”。
  4. 在短函数中使用 a，b，c，d。

所以如果你想要一个函数

有开始，结束(范围)

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

所以现在 range (3,7)返回[3,4,5,6,7]

U 在这里用很多方式节省字节，这个函数也很快，因为它不使用 concat，push，new Array，而且它是用 while 制作的

小开

它可以用来自 ES6的特性来完成，目前只支持 Firefox。我在这里找到了一个兼容性表: http://kangax.github.io/compat-table/es6/

Array.from(new Array(20), (x,i) => i+1)

如果你想有一些其他的范围，那么我想你可以做

Array.from(new Array(5), (x,i) => i+5)

那就是[5,6,7,8,9]

小开

使用 ES6

numArr = Array(5).fill(0).reduce(arr=>{ arr.push(arr.length); return arr },[])

小开

如果你接受计数器从0开始而不是1..。

const zeroNineteen = [...Array(20).keys()];
// outputs [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]

如果你真的需要从1开始:

const terserst = [...Array(21).keys()].slice(1);

30个字符而且还可读，你不觉得吗？

小开

如果你对0-20没有意见，这里是我最近代码高尔夫球的最新喜好:

[...'0'.repeat(21)].map((_,i)=>i)
Array.from({length:21},(_,i)=>i)
Array(21).fill().map((_,i)=>i)
[...Array(21)].map((_,i)=>i)
Array(21).map((_,i)=>i)
[...Array(21).keys()]
小开 
Array.from({length: n}).map((_, i) => i);

提交答案