变量foo=[]； 对于（var i=1；i<=N；i++）{ foo.push（i）； } 
-
413 在阅读了整个页面后，我得出了这样的结论：您自己的简单for-loop是最简单、可读性最强、最不容易出错的。 – 科科多科 评论 2014年5月8日16:09 -
1 如果有人需要更高级的东西，我创建了一个node.js库，用于数字、字母、负/正范围等。 github.com/jonschlinkert/fill-range 。它用于 github.com/jonschlinkert/braces 用于支撑扩展和 github.com/jonschlinkert/micromatch公司 用于glob模式 – 约翰施林克特 评论 2015年6月9日5:21 -
另一种方法是：Array.from（{length:10}，（_，v）=>v） – 萨希尔·古普塔 评论 2019年8月25日0:15 -
@SahilGupta几乎。 如果我们想要1到10，我们需要加1，例如：Array.from（{length:10}，（_，v）=>v+1） – 教授Francis 评论 2019年10月13日21:54 -
不用数组，将foo定义为对象{}，然后用foo[i]=i添加自己的索引； – SPlatten公司 评论 2020年2月27日13:42
80个答案
变量N=10； Array.apply（null，{length:N}）.map（Number.call，Number）
结果：[0,1,2,3,4,5,6,7,8,9]
Array.apply（null，{length:N}）.map（Function.call，Math.random）
结果：[0.7082694901619107，0.9572225909214467，0.8586748542729765， 0.8653848143294454, 0.008339877473190427, 0.9911756622605026, 0.8133423360995948, 0.8377588465809822, 0.5577575915958732, 0.16363654541783035]
解释
函数Array（）{ if（arguments.length==1&& “number”===参数类型[0]&& 参数[0]>=0&&参数&& 参数[0]<1<<32）{ 返回[…]；// 长度参数数组[0]，由本机代码生成 } 变量a=[]； for（var i=0；i<参数长度；i++）{ a.push（参数[i]）； } 返回a； } 函数Array（）{ 变量a=[]； for（var i=0；i</*参数长度=*/N；i++）{ a.push（/*参数[i]=*/未定义）； } 返回a； }
回调 仅对具有赋值的数组索引调用； 对于已删除或从未赋值的索引，不会调用它。
兼容性
-
73 -
9 -
18 这真的非常聪明（近乎滥用JS）。 这里真正重要的见解是 地图 在我看来，是关于未分配的价值观。 另一个版本（可能稍显清晰，但较长）是： Array.apply（null，{length:N}）.map（function（element，index）{return index；}） – 本·雷奇 评论 2014年10月22日14:23 -
7 @BenReich甚至更好（就JS滥用水平而言）： Array.apply（null，new Array（N））.map（函数（_，i）{return i；}） 或者，如果是es6和箭头功能，则更短： Array.apply（null，new Array（N））.map（（_，i）=>i） – 古怪的 评论 2014年11月25日0:07 -
2
多种方式使用 欧洲标准6
使用排列运算符( ... )和键方法
[…数组（N）.keys（）].map（i=>i+1）； 填充/映射
数组（N）.fill（）.map（（_，i）=>i+1）； 阵列起始位置
数组.from（数组（N），（_，i）=>i+1） 数组从和 {长度：N} 乱劈
数组.from（{长度：N}，（_，i）=>i+1） 关于广义形式的注释
[…数组（N）.keys（）].map（f） 示例：
数组.from（{长度：5}，（v，k）=>k+1）； // [1,2,3,4,5] 显示所有表单的示例
让演示=（N）=>{ 控制台日志( […数组（N）.keys（）].map（（i）=>i+1）， 数组（N）.fill（）.map（（_，i）=>i+1）， 数组.from（数组（N），（_，i）=>i+1）， 数组.from（{长度：N}，（_，i）=>i+1） ) } 演示（5） 带有自定义初始化器函数的更通用示例 （f） 即
[…数组（N）.keys（）].map（（i）=>f（i）） […数组（N）.keys（）].map（f） 让演示=（N，f）=>{ 控制台日志( […数组（N）.keys（）].map（f）， 数组（N）.fill（）.map（（_，i）=>f（i））， 数组.from（数组（N），（_，i）=>f（i））， 数组.from（{长度：N}，（_，i）=>f（i）） ) } 演示（5，i=>2*i+1） 
-
6 -
8 -
5 -
三 -
1 @bluejayke我相信自从我发表评论后，这个答案已经被编辑过了，但我特别谈到了 数组.from（{长度：5}，（v，k）=>k+1）； ，它确实只迭代一次。 – 威勒德 评论 2020年6月16日3:57
var foo=新数组（45）；// 创建长度为45的空数组 for（var i=0；i<foo.length；i++）{ document.write（'项目：'+（i+1）+'的'+foo.length+'<br/>'）； } 
-
7 -
196 -
4 @Godders-要注意，如果您想在创建长度为M的数组后将其大小减小，只需使用 foo.length=米 ---切断信息丢失。 在行动中看到它==> jsfiddle.net/ACMXp – 彼得·阿伊泰 评论 2010年9月20日2:11 -
35 -
112 @斯库利夫：请注意 新阵列（45）； 不“创建45元素数组”（与 [未定义，未定义，..未定义] 确实如此）。 而是“创建长度为45的空数组”( [未定义x 45] )，与相同 变量foo=[]； foo.length=45； .这就是为什么 对于每个 、和 地图 将不适用于这种情况。 – 托马利克 评论 2014年1月24日14:00
var foo=新数组（N）；// 其中N是正整数 /*这将创建一个大小为N的数组，主要用于内存分配， 但不创建任何定义的值 foo.length//数组大小 foo[Math.floor（foo.length/2）]='value'//将值放在数组的中间 */ 欧洲标准6
价差
var foo=[…数组（N）.keys（）]； 填充/映射
var foo=数组（N）.fill（）.map（（v，i）=>i）； 阵列起始位置
数组.from（{length:N}，（v，i）=>i） 如果索引可用，您可以简单地将其增加一（例如。， ++我 ). 在不使用索引的情况下，可能是一种更有效的方法，即创建数组，但使N表示N+1，然后从前面移开。 所以如果你想要100个数字： let arr； （arr=[…数组（101）.keys（）]）.shift（）
-
-
6 就像我说的，我需要用数字1到10填充下拉列表。 这就是全部。 有一个用例，我的用例。 我就是这样找到这个页面的。 因此，手工构建数组比我在这里看到的任何东西都要简单。 所以我的要求不是OP的要求。但我有我的答案。 – 香烟豆 评论 2018年10月24日11:24 -
1 @有一个用例，我也有一个。 在有角度的分页中，我想在页脚中显示可单击的页面。 因此，我使用*ngFor=“let p of pagesCounter”循环视图中的元素。 你有更好的解决方案吗？ BTW，结账 stackoverflow.com/questions/36354325/… – 达利沃尔 评论 2019年3月30日8:47 -
1 -
1
控制台.log( 数组（45）.fill（0）.map（（e，i）=>i+1） ); 
-
4 -
4 -
1 -
9 我不明白为什么 .fill（） 是必要的。 我看到这是在测试节点的repl时，但因为 数组（1）[0]==未定义 ，对fill（）的调用有什么区别 数组（1）.fill（未定义） 制造？ – 多米尼克 评论 2016年10月14日9:45 -
13
//_.范围（[开始]、停止、[步骤]） _.范围（10）；//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] _.范围（1，11）；//=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] _.范围（0，30，5）；//=> [0, 5, 10, 15, 20, 25] _.范围（0，-10，-1）；//=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] _.范围（0）；//=> [] 
-
7 -
-
功能范围（开始、结束）{ 变量foo=[]； for（var i=开始；i<=结束；i++）{ foo.push（i）； } 返回foo； } var foo=范围（1,5）； 功能范围（开始、计数）{ if（arguments.length==1）{ 计数=开始； 开始=0； } var foo=[]； for（var i=0；i<计数；i++）{ foo.push（开始+i）； } 返回foo； } 
[…数组（5）].map（…） 
-
14 -
2 -
1 @jimm101我很好奇为什么 […数组（5）].map（（a）=>7） 给出了7个数组，而 数组（5）.map（（a）=>7） 没有。使用 ... 仍在生成一个未定义值的数组，为什么会有不同？ 评论 2023年10月6日19:01 -
-
@jimm101谢谢你的回复。 我感到困惑的是我不依赖索引 我 这里，就这个项目 一 （无论是空的、空的还是其他什么）。 你是说我们实际上没有为 空的 价值观？ 因为如果我们是这样的话，我想 7 以在存在空值时放置在每个点中。 帮助我理解。 评论 2023年10月8日14:41
性能
结果
解决方案 O（运行） （基于 虽然 )是最快的（除了Firefox的big N，但它在那里很快） 解决方案T在Firefox上实现big N最快 解决方案M、P对于小N来说很快 解决方案V（lodash）对于大N是快速的 对于较小的N，溶液W、X速度较慢 溶液F缓慢
细节
功能A（N）{ return Array.from（{length:N}，（_，i）=>i+1） } 功能B（N）{ return数组（N）.fill（）.map（（_，i）=>i+1）； } 功能C（N）{ return数组（N）.join（）.split（'，'）.map（（_，i）=>i+1）； } 功能D（N）{ return Array.from（数组（N），（_，i）=>i+1） } 功能E（N）{ return Array.from（{length:N}，（_，i）=>i+1） } 函数F（N）{ return Array.from（{length:N}，Number.call，i=>i+1） } 函数G（N）{ return（数组（N）+''）.split（'，'）.map（（_，i）=>i+1） } 功能H（N）{ return[…数组（N）.keys（）].map（i=>i+1）； } 功能I（N）{ return[…数组（N）.keys（）].map（x=>x+1）； } 函数J（N）{ return[…数组（N+1）.keys（）].slice（1） } 函数K（N）{ return[…数组（N）.keys（）].map（x=>+x）； } 函数L（N）{ let arr； （arr=[…数组（N+1）.keys（）]）.shift（）； 返回arr； } 函数M（N）{ var arr=[]； var i=0； 而（N--）arr.push（++i）； 返回arr； } 功能N（N）{ 变量a=[]，b=N； 而（b--）a[b]=b+1； 返回a； } 函数O（N）{ var a=数组（N），b=0； 而（b<N）a[b++]=b； 返回a； } 函数P（N）{ 变量foo=[]； 对于（var i=1；i<=N；i++）foo.push（i）； 返回foo； } 函数Q（N）{ 对于（var a=[]，b=N；b---；a[b]=b+1）； 返回a； } 功能R（N）{ 对于（var i，a=[i=0]；i<N；a[i++]=i）； 返回a； } 功能S（N）{ 设foo，x； 对于（foo=[x=N]；x；foo[x-1]=x---）； 返回foo； } 功能T（N）{ return new Uint8Array（N）.map（（item，i）=>i+1）； } 功能U（N）{ return“_”.repeat（5）.split（“”）.map（（_，i）=>i+1）； } 功能V（N）{ 返回_范围（1，N+1）； } 函数W（N）{ return[…（函数*（）｛设i＝0；而（i＜N）yield++i｝）（）] } 函数X（N）{ 功能序列（最大，步长=1）{ 返回{ [Symbol.iterator]：函数*（）{ 对于（设i＝1；i＜＝max；i＋＝步长），产率i } } } 返回[…序列（N）]； } [A、B、C、D、E、F、G、H、I、J、K、L、M、N、O、P、Q、R、S、T、U、V、W、X]。每个（F=>{ 控制台.log（`${f.name}${f（5）}`）； }) <script src=“ https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js “integrity=”sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovwww==“crossorigin=”anonymous“></script> 此代码段仅显示性能测试中使用的函数-它本身不执行测试！ 
[…数组（5）].map（（_，i）=>i）； 
-
-
-
苛刻，你知道.map的源代码是什么吗？ 我不确定它是否比for循环快，但如果不是，那么理论上我们可以定义Property并创建一个新的 评论 2019年3月27日10:54
[…数组（255）.keys（）].map（x=>x+1） （新Uint8Array（255））.map（（$，i）=>i+1）； for（var i=0，arr=new Uint8Array（255））； i<长度； i++）arr[i]=i+1； 功能范围（最小值、最大值）{ min=min&&min.constructor==数量？ 最小值：0； ! （max&&max.constructor==Number&&max>min）&&//布尔语句也可以与void返回类型一起使用，如单行if语句。 （（最大值=最小值）&（最小值=0））// 如果指定了“max”参数，则首先检查它是否是一个数字，以及它的graeter是否大于min：如果是，则保持不变； 如果不是，那么首先就把它当作没有“max”，“max“变成了“min”（默认情况下min变成了0） 对于（var i=0，arr=new( 最大值<128？ Int8阵列： 最大值<256？ Uint8阵列： 最大值<32768？ Int16阵列： 最大值<65536？ Uint16阵列： 最大值<2147483648？ Int32阵列： 最大值<4294967296？ Uint32阵列： 阵列 )（最大值-最小值）； i<长度； i++）arr[i]＝i+min； 返回arr； } //如果需要，可以使用数组方法轻松地循环它 范围（1,11）.forEach（x=>控制台.log（x））； //或者如果你习惯了蟒蛇。。。 在“你可以用”for做类似的事情。。。 of `如果需要单个值： 对于（范围i（20202025））console.log（i）； //或者如果你真的想用“for…”。。 在`中，您可以，但您只能访问密钥： for（k在范围（25,30）内）console.log（k）； 控制台.log( 范围（1128）。构造函数名称， 范围（200）.constructor.name， 范围（400900）。构造函数名称， 范围（33333）。构造函数名称， 范围（823100000）。构造者名称， range（10,4）//当“min”参数大于“max”时，它就认为没有“max ); 范围（114000）； 
new Array（/*所需的任意数字*/） .joon（）.split（'，'） .map（函数（项，索引）{return++索引；}） 新阵列（10） .joon（）.split（'，'） .map（函数（项，索引）{return++索引；}） [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
-
还有，为什么不呢 new Array（10）.join（）.split（'，'）.map（function（）{return++参数[1]}）； ? – 用户2039981 评论 2016年1月3日20:31 -
1 @在某些情况下，带有内部参数的Murplyx函数不会被JS引擎优化（即使对于V8也是如此，请参阅 jsperf.com/arguments-vs-array-argument/2 ) – nktssh公司 评论 2016年1月5日21:25 -
4 这是一个有趣的解决方案，但它完全不切实际——必须解析数组 3次 （一次到 参加 ，一次到 分裂 ，而一旦你真正想做的事情）就不太好了-我知道他们似乎因为某些原因而失宠了，但简单地使用一种好的老式风格要好得多 环 ! – 罗宾 评论 2016年4月24日19:29
const-arrayOne=新数组（10）； console.log（arrayOne）； const数组Two=[…数组（10）.keys（）]； console.log（arrayTwo）； var arrayThree=数组.from（数组（10）.keys（））； console.log（arrayThree）； const arrayStartWithOne=Array.from（Array（10）.keys（），item=>item+1）； console.log（arrayStartWithOne） 
变量a=[]，b=N； 而（b--）a[b]=b+1； var arr=（函数（a，b）{while（a-）b[a]=a；return b}）（10，[]）； //arr=[0,1,2,3,4,5,6,7,8,9] var arr=（函数（a，b）{while（a-）b[a]=a+1；返回b}）（10，[]）； //arr=[1,2,3,4,5,6,7,8,9,10] 函数范围（a，b，c）{c=[]；而（a-）c[a]=a+b；返回c}// 长度，开始，占位符 var arr=范围（10.5）； //arr=[5,6,7,8,9,10,11,12,13,14] 虽然 是最快的环路 直接设置比 推 [] 比…快 新阵列（10） 它很短。。。 看第一个代码。 然后看看这里的所有其他函数。
对于（var a=[]，b=7；b>0；a[--b]=b+1）// a=[1,2,3,4,5,6,7] 对于（var a=[]，b=7；b---；a[b]=b+1）// a=[1,2,3,4,5,6,7] 
-
8 -
三 哈哈，请马特，因为你不喜欢我的答案，别再投票给我的其他人了。。。 stackoverflow.com/a/18344296/2450730 …使用console.time（）或其调用方式。。。 不是jsperf。 – 真喜志智子 评论 2013年8月21日14:00 -
4 仅供参考：正如John Reisig几年前首次发布的那样，在某些平台（即windows:P）上，时间每16ms向浏览器反馈一次。 在多任务环境中测量执行时间也存在其他问题。 jsperf.com已经实现了运行测试，以便它们在统计上是正确的。 可以跑步了 控制台.time（） 为了获得直觉，但为了证明，您需要jsperf.com，它会显示其他人（不同硬件等）的跨浏览器结果 – 诺格图 评论 2013年9月14日8:58 -
三 -
6 @球菌- 虽然 不是 总是 比其他环路更快。 在某些浏览器中，递减while循环比for循环慢得多，您不能这样概括javascript的性能，因为有太多不同优化的实现。 然而，总的来说，我喜欢你的方法。；-） – 罗布·G 评论 2015年8月9日23:57
_.范围（[start=0]，end，[step=1]）
创建数字数组 （积极和/或消极）从开始到，但不是 包括，结束。 如果指定负启动，则使用步骤-1 没有终点或台阶。 如果未指定结束，则将其设置为开始 使用start，然后设置为0。
_范围（4）； // ➜ [0, 1, 2, 3] _范围（-4）； // ➜ [0, -1, -2, -3] _.范围（1，5）； // ➜ [1, 2, 3, 4] _.范围（0、20、5）； // ➜ [0, 5, 10, 15] _.范围（0，-4，-1）； // ➜ [0, -1, -2, -3] _.范围（1，4，0）； // ➜ [1, 1, 1] _.范围（0）； // ➜ [] 
const数组=[…数组（5）.keys（）] console.log（数组） -
1 -
const[，…result]=数组（11）.keys（）； console.log（'Result:'，Result）； 
使用Delta
对于javascript
[…数组（N）].map（（v，i）=>来自+i*步骤）； Array.from（Array（10）.keys（））.map（i=>4+i*2）； //=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22] […数组（10）.keys（）].map（i=>4+i*-2）； //=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14] 数组（10）.fill（0）.map（（v，i）=>4+i*2）； //=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22] 数组（10）.fill（）.map（（v，i）=>4+i*-2）； //=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14] […数组（10）].map（（v，i）=>4+i*2）； //=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22] 常数范围=（从、到、步进）=> […数组（数学地板（（到-从）/步）+1）].map（（_，i）=>从+i*步）； 范围（0、9、2）； //=> [0, 2, 4, 6, 8] //也可以将范围函数指定为Array类中的静态方法（但不推荐） 数组范围=（从，到，步长）=> […数组（数学地板（（到-从）/步）+1）].map（（_，i）=>从+i*步）； 阵列范围（2，10，2）； //=> [2, 4, 6, 8, 10] 数组范围（0，10，1）； //=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 数组范围（2，10，-1）； //=> [] 数组范围（3，0，-1）； //=> [3, 2, 1, 0] 类别范围{ 构造函数（总数=0，步骤=1，从=0开始）{ this[Symbol.iterator]=函数*（）{ for（设i=0；i<total；+i++*step的产量）{} }; } } […新范围（5）]；// 五大要素 //=> [0, 1, 2, 3, 4] […新范围（5，2）]；// 第二步五要素 //=> [0, 2, 4, 6, 8] […新范围（5，-2，10）]；// 五要素，从10开始第2步 //=>[10, 8, 6, 4, 2] […新范围（5，-2，-10）]；// 五元素与步骤-2从-10 //=> [-10, -12, -14, -16, -18] //也可与for配合使用。。 循环的 对于新范围（5，-2，10）的（i）console.log（i）； // 10 8 6 4 2 常量范围=函数*（总计=0，步长=1，从=0开始）{ for（设i=0；i<total；+i++*step的产量）{} }; 数组起始（范围（5，-2，-10））； //=> [-10, -12, -14, -16, -18] […范围（5，-2，-10）]；// 五要素，从-10开始第2步 //=> [-10, -12, -14, -16, -18] //也可与for配合使用。。 循环的 对于（范围（5，-2，10）的i）控制台.log（i）； // 10 8 6 4 2 //懒惰的加载方式 const number0toInf=范围（无限）； number0toInf.next（）.value； //=> 0 number0toInf.next（）.value； //=> 1 // ... 从-到-带阶梯/增量
类别范围2{ 构造函数（to=0，step=1，from=0）{ this[Symbol.iterator]=函数*（）{ 设i=0， 长度=数学地板（从上到下）/台阶）+1； 而（i<长度）从+i++*步产生； }; } } […新范围2（5）]；// 前5个整数 //=> [0, 1, 2, 3, 4, 5] […新范围2（5，2）]；// 使用步骤2从0到5 //=> [0, 2, 4] […新范围2（5，-2，10）]；// 从10到5，步骤-2 //=> [10, 8, 6] const Range2=函数*（to=0，step=1，from=0）{ 设i=0， 长度=数学地板（从上到下）/台阶）+1； 而（i<长度）从+i++*步产生； }; […范围2（5，-2，10）]；// 从10到5，步骤-2 //=> [10, 8, 6] 设even4to10＝范围2（10，2，4）； even4到10.next（）.value； //=> 4 even4到10.next（）.value； //=> 6 even4到10.next（）.value； //=> 8 even4到10.next（）.value； //=> 10 even4到10.next（）.value； //=>未定义 对于Typescript
class _Array扩展了Array{ 静态范围（从：数字，到：数字，步骤：数字）：数字[]{ return Array.from（Array（Math.floor（to-from）/step）+1）.map( （v，k）=>从+k*步 ); } } _数组范围（0，9，1）； 
快速
设N=10，i=0，a=数组（N）； 而（i<N）a[i++]=i； 控制台.log（a）； 内存在开始时分配一次 a=阵列（N） 递增指数 我++ 使用-看起来比递减索引快30%左右 我-- （可能是因为CPU正向缓存内存更快）
-
然而 阵列（N） 构造函数创建了一个带有“holes”的数组，当以后实际使用时，该数组的性能可能会降低。 引擎对数组使用不同的内部表示，这取决于数组中的内容以及它们是否有“洞”； 如果创建了孔，则内部表示可以降级，但如果删除了所有孔，则不会升级。 用V8的术语来说，此解决方案创建了一个 孔_SMI_构件 数组，其中 打包_SMI_ELEMENTS 最好是数组。 v8.dev/blog/elements-kinds#元素-kind-lattice V8开发人员的建议是使用 推 相反。 – kaya3型 评论 2022年8月14日12:46
数组.from（{长度：10}，（v，i）=>i） 数组.from（{length:10}，（v，i）=>i*2） //打开开发控制台以查看结果 计数=100000 console.time（“来自对象”） for（设i=0；i<count；i++）{ range=数组。from（｛length:10｝，（v，i）=>i） } console.timeEnd（“来自对象”） 控制台.time（“从键”） for（设i=0；i<count；i++）{ range=Array.from（数组（10）.keys（）） } console.timeEnd（“从键”） 控制台.time（“应用”） for（设i=0；i<count；i++）{ range=Array.apply（null，{length:10}）.map（函数（元素，索引）{return index；}） } console.timeEnd（“应用”） 
数组（N）.fill（）.map（（_，i）=>i+1）； 数组.from（数组（5））.map（（_，i）=>i+1） 
-
8 同样，您也可以在ES6中执行以下操作： 数组.from（{length:N}，（v，k）=>k） . 评论 2015年6月8日9:19 -
首选Xappli的方法：Array.from是为几乎完全相同的场景创建的，它意味着一个映射回调。 这是一个很好的解决方案，可以解决希望在类似数组的对象上使用Array方法的一般问题，而无需使用诸如 数组.prototype.map.call ，例如，对于从返回的NodeLists 文档.query选择或全部 . developer.mozilla.org/en/docs/Web/JavaScript/Reference/… – 来自卡里布的乔什 评论 2015年10月16日2:50 -
-
在ES6中：
数组.from（{length:1000}，（_，i）=>i）.slice（1）； 数组.from（{length:1000}，Number.call，i=>i+1） Uint8Array.from（{length:10}，Number.call，i=>i+1） ES5：
Array.apply（0，{length:1000}）.map（function（）{返回参数[1]+1}）； Array.apply（0，｛length:1000｝）.map（Number.call，Number）.sice（1） Array.apply（0，{length:1000}）.map（Number.call，Function（“i”，“return i+1”）） 数组（…数组（9））.map（（_，i）=>i）； console.log（数组（…数组（9））.map（（_，i）=>i）） 
constgen=N=>[…（函数*（）{设i=0；而（i<N）产生i++}）（）] 第（4）代//[0,1,2,3] 常数gen=N=>[…（函数*（）{设i=0； 而（i++<N）生成Math.random（） })()] const-slow=N=>new数组（N）.join（）.split（'，'）.map（（e，i）=>i*5） // [0,5,10,15,...] const-fast=N=>[…（函数*（）{设i=0；而（i++<N）产生i*5}）（）] 