blocks|key|1260775|text|ES6引入了Array.prototype.fill。它可以像这样使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1260776|new+Array(len).fill(0);|code-block|syntax|javascript|1260777|不确定它是不是很快，但我喜欢它，因为它很简短，而且是自我描述的。|1260778|它仍然不在IE+(check+compatibility)中，但有一个polyfill+available。|1260779|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill#Browser_compatibility|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill#Polyfill^0|6|K|6|K|0|0|0|0|9|J|1|Z|I|2|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|O|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]|Y|$5|R|S|T|E|$U|Z]]]]

ES6 introduces <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill" rel="noreferrer"><code>Array.prototype.fill</code></a>. It can be used like this:

<pre><code>new Array(len).fill(0);
</code></pre>

Not sure if it's fast, but I like it because it's short and self-describing.

It's still not in IE (<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill#Browser_compatibility" rel="noreferrer">check compatibility</a>), but there's a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill#Polyfill" rel="noreferrer">polyfill available</a>.

blocks|key|1475714|text|前面提到的ES+6+fill方法很好地解决了这一点。到目前为止，大多数现代桌面浏览器已经支持所需的数组原型方法(Chromium、FF、Edge和Safari)+[1]。您可以在MDN上查找详细信息。一个简单的用法示例是|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1475715|a+=+new+Array(10).fill(0);|code-block|syntax|javascript|1475716|考虑到当前的浏览器支持，您应该谨慎使用它，除非您确定您的受众使用的是最新的桌面浏览器。|1475717|entityMap|0|LINK|mutability|MUTABLE|url|http://kangax.github.io/compat-table/es6/#test-Array.prototype_methods|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill^0|2A|1|0|2H|3|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

The already mentioned ES 6 fill method takes care of this nicely. Most modern desktop browsers already support the required Array prototype methods as of today (Chromium, FF, Edge and Safari) [<a href="http://kangax.github.io/compat-table/es6/#test-Array.prototype_methods">1</a>]. You can look up details on <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill">MDN</a>. A simple usage example is

<pre><code>a = new Array(10).fill(0);
</code></pre>

Given the current browser support you should be cautious to use this unless you are sure your audience uses modern Desktop browsers.

blocks|key|1261186|text|如果你使用ES6，你可以像这样使用Array.from()：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1261187|Array.from({+length:+3+},+()+=>+0);
//[0,+0,+0]|code-block|syntax|javascript|1261188|具有相同的结果|1261189|Array.from({+length:+3+}).map(()+=>+0)
//[0,+0,+0]|1261190|因为|1261191|Array.from({+length:+3+})
//[undefined,+undefined,+undefined]|1261192|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from^0|H|C|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

If you use ES6, you can use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from" rel="noreferrer">Array.from()</a> like this:

<pre><code>Array.from({ length: 3 }, () =&gt; 0);
//[0, 0, 0]
</code></pre>

Has the same result as

<pre><code>Array.from({ length: 3 }).map(() =&gt; 0)
//[0, 0, 0]
</code></pre>

Because 

<pre><code>Array.from({ length: 3 })
//[undefined, undefined, undefined]
</code></pre>

blocks|key|1475288|text|默认情况下，Uint8Array、Uint16Array和Uint32Array类保留0作为其值，因此您不需要任何复杂的填充技术，只需这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1475289|var+ary+=+new+Uint8Array(10);|code-block|syntax|javascript|1475290|默认情况下，数组ary的所有元素都将为零。|1475291|entityMap^0|6|A|H|B|T|B|0|0|8|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

By default <code>Uint8Array</code>, <code>Uint16Array</code> and <code>Uint32Array</code> classes keep zeros as its values, so you don't need any complex filling techniques, just do:

<pre><code>var ary = new Uint8Array(10);
</code></pre>

all elements of array <code>ary</code> will be zeros by default.

blocks|key|1474769|text|function+makeArrayOf(value,+length)+{
++var+arr+=+[],+i+=+length;
++while+(i--)+{
++++arr[i]+=+value;
++}
++return+arr;
}

makeArrayOf(0,+5);+//+[0,+0,+0,+0,+0]

makeArrayOf('x',+3);+//+['x',+'x',+'x']|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1474770|请注意，while通常比for-in、forEach等更有效。|unstyled|offset|length|style|CODE|1474771|entityMap^0|0|4|5|C|6|J|7|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]|$G|S|H|T|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|U|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>function makeArrayOf(value, length) {
 var arr = [], i = length;
 while (i--) {
 arr[i] = value;
 }
 return arr;
}

makeArrayOf(0, 5); // [0, 0, 0, 0, 0]

makeArrayOf('x', 3); // ['x', 'x', 'x']
</code></pre>

Note that <code>while</code> is usually more efficient than <code>for-in</code>, <code>forEach</code>, etc.

blocks|key|1474661|text|使用对象表示法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1474662|var+x+=+[];|code-block|syntax|javascript|1474663|零填充？比如..。|1474664|var+x+=+[0,0,0,0,0,0];|1474665|充满了“未定义的”...|1474666|var+x+=+new+Array(7);|1474667|带零的obj表示法|1474668|var+x+=+[];
for+(var+i+=+0;+i+<+10;+i%2B%2B)+x[i]+=+0;|1474669|顺便说一下，如果您修改了Array的原型，|1474670|var+x+=+new+Array();|1474671|和|1474672|var+y+=+[];|1474673|将会有这些原型修改|1474674|无论如何，我不会过分担心这个操作的效率或速度，你可能会做很多其他的事情，这些事情比实例化一个包含零的任意长度的数组更浪费和更昂贵。|1474675|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1J|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

using object notation

<pre><code>var x = [];
</code></pre>

zero filled? like...

<pre><code>var x = [0,0,0,0,0,0];
</code></pre>

filled with 'undefined'...

<pre><code>var x = new Array(7);
</code></pre>

obj notation with zeros

<pre><code>var x = [];
for (var i = 0; i &lt; 10; i++) x[i] = 0;
</code></pre>

As a side note, if you modify Array's prototype, both

<pre><code>var x = new Array();
</code></pre>

and

<pre><code>var y = [];
</code></pre>

will have those prototype modifications

At any rate, I wouldn't be overly concerned with the efficiency or speed of this operation, there are plenty of other things that you will likely be doing that are far more wasteful and expensive than instanciating an array of arbitrary length containing zeros.

blocks|key|1260291|text|我已经测试了IE6/7/8、Firefox3.5、Chrome和Opera中预分配/非预分配、递增/递减计数和for/while循环的所有组合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1260292|下面的函数在火狐、Chrome和IE8中都是最快或最接近的，但并不比Opera6和IE6中最快的慢多少。在我看来，这也是最简单、最清晰的。我发现有几个浏览器的while循环版本稍微快一些，所以我也将其包含在其中以供参考。|1260293|function+newFilledArray(length,+val)+{
++++var+array+=+[];
++++for+(var+i+=+0;+i+<+length;+i%2B%2B)+{
++++++++array[i]+=+val;
++++}
++++return+array;
}|code-block|syntax|javascript|1260294|或|1260295|function+newFilledArray(length,+val)+{
++++var+array+=+[];
++++var+i+=+0;
++++while+(i+<+length)+{
++++++++array[i%2B%2B]+=+val;
++++}
++++return+array;
}|1260296|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I've tested all combinations of pre-allocating/not pre-allocating, counting up/down, and for/while loops in IE 6/7/8, Firefox 3.5, Chrome, and Opera.

The functions below was consistently the fastest or extremely close in Firefox, Chrome, and IE8, and not much slower than the fastest in Opera and IE 6. It's also the simplest and clearest in my opinion. I've found several browsers where the while loop version is slightly faster, so I'm including it too for reference.

<pre><code>function newFilledArray(length, val) {
 var array = [];
 for (var i = 0; i &lt; length; i++) {
 array[i] = val;
 }
 return array;
}
</code></pre>

or

<pre><code>function newFilledArray(length, val) {
 var array = [];
 var i = 0;
 while (i &lt; length) {
 array[i++] = val;
 }
 return array;
}
</code></pre>

blocks|key|1261371|text|ES6解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1261372|[...new+Array(5)].map(x+=>+0);+//+[0,+0,+0,+0,+0]|code-block|syntax|javascript|1261373|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h1>ES6 solution:</h1>

<pre><code>[...new Array(5)].map(x =&gt; 0); // [0, 0, 0, 0, 0]
</code></pre>

blocks|key|1475998|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475999|const+arr+=+Array.from({+length:+10+}).fill(0);
console.log(arr)|code-block|syntax|javascript|1476000|1476001|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const arr = Array.from({ length: 10 }).fill(0);
console.log(arr)</code></pre>
</div>
</div>

blocks|key|1260412|text|function+zeroFilledArray(size)+{
++++return+new+Array(size+%2B+1).join('0').split('');
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1260413|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function zeroFilledArray(size) {
 return new Array(size + 1).join('0').split('');
}
</code></pre>

blocks|key|1475341|text|使用lodash或underscore|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1475342|_.range(0,+length+-+1,+0);|code-block|syntax|javascript|1475343|或者，如果您有一个已存在的数组，并且想要一个相同长度的数组|1475344|array.map(_.constant(0));|1475345|entityMap|0|LINK|mutability|MUTABLE|url|http://lodash.com/docs#range|1|http://underscorejs.org/#range^0|2|6|0|9|A|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

Using <a href="http://lodash.com/docs#range">lodash</a> or <a href="http://underscorejs.org/#range">underscore</a>

<pre><code>_.range(0, length - 1, 0);
</code></pre>

Or if you have an array existing and you want an array of the same length

<pre><code>array.map(_.constant(0));
</code></pre>

blocks|key|1475625|text|我不反对：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475626|Array.apply(null,+Array(5)).map(Number.prototype.valueOf,0);
new+Array(5%2B1).join('0').split('').map(parseFloat);|code-block|syntax|javascript|1475627|由Zertosh建议，但在new+ES6数组中，扩展允许您使用fill方法进行本机操作。现在IE+edge，Chrome和FF都支持它，但请检查compatibility+table|offset|length|style|CODE|1475628|new+Array(3).fill(0)将为您提供[0,+0,+0]。您可以用任何值填充数组，如new+Array(5).fill('abc')+(即使是对象和其他数组)。|1475629|在此基础上，您可以使用fill修改前面的数组：|1475630|arr+=+[1,+2,+3,+4,+5,+6]
arr.fill(9,+3,+5)++#+what+to+fill,+start,+end|1475631|这就给了你：[1,+2,+3,+9,+9,+6]|1475632|entityMap|0|LINK|mutability|MUTABLE|url|http://es6-features.org/|1|http://kangax.github.io/compat-table/es6/#Array.prototype_methods_Array.prototype.fill^0|0|0|V|4|D|7|0|20|J|1|0|0|K|P|9|1C|O|0|0|0|6|I|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@$I|19|J|1A|1|1B]|$I|1C|J|1D|1|1E]]|A|$]]|$1|M|3|N|5|6|7|1F|8|@$I|1G|J|1H|K|L]|$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1O|8|@$I|1P|J|1Q|K|L]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]]]

I have nothing against:

<pre><code>Array.apply(null, Array(5)).map(Number.prototype.valueOf,0);
new Array(5+1).join('0').split('').map(parseFloat);
</code></pre>

suggested by Zertosh, but in a <a href="http://es6-features.org/" rel="noreferrer">new ES6</a> array extensions allow you to do this natively with <code>fill</code> method. Now IE edge, Chrome and FF supports it, but check the <a href="http://kangax.github.io/compat-table/es6/#Array.prototype_methods_Array.prototype.fill" rel="noreferrer">compatibility table</a>

<code>new Array(3).fill(0)</code> will give you <code>[0, 0, 0]</code>. You can fill the array with any value like <code>new Array(5).fill('abc')</code> (even objects and other arrays).

On top of that you can modify previous arrays with fill:

<pre><code>arr = [1, 2, 3, 4, 5, 6]
arr.fill(9, 3, 5) # what to fill, start, end
</code></pre>

which gives you: <code>[1, 2, 3, 9, 9, 6]</code>

blocks|key|1261233|text|我没有在answers中看到这个方法，所以这里是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1261234|"0".repeat(+200+).split("").map(+parseFloat+)|code-block|syntax|javascript|1261235|因此，您将得到长度为200的零值数组：|1261236|[+0,+0,+0,+0,+...+0+]|1261237|我不确定这段代码的性能，但如果您将它用于相对较小的数组，这应该不是问题。|1261238|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Didn't see this method in answers, so here it is:

<pre><code>"0".repeat( 200 ).split("").map( parseFloat )
</code></pre>

In result you will get zero-valued array of length 200:

<pre><code>[ 0, 0, 0, 0, ... 0 ]
</code></pre>

I'm not sure about the performance of this code, but it shouldn't be an issue if you use it for relatively small arrays.

blocks|key|1261389|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1261390|let+filled+=+[];
filled.length+=+10;
filled.fill(0);

console.log(filled);|code-block|syntax|javascript|1261391|1261392|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let filled = [];
filled.length = 10;
filled.fill(0);

console.log(filled);</code></pre>
</div>
</div>

blocks|key|1475034|text|那new+Array(51).join('0').split('')呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1475035|entityMap^0|1|X|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

What about <code>new Array(51).join('0').split('')</code>?

blocks|key|1475079|text|我正在测试T.J.Crowder的优秀答案，并提出了一个基于concat解决方案的递归合并，该解决方案在他的Chrome测试中表现优于任何一个(我没有测试其他浏览器)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475080|function+makeRec(len,+acc)+{
++++if+(acc+==+null)+acc+=+[];
++++if+(len+<=+1)+return+acc;
++++var+b+=+makeRec(len+>>+1,+[0]);
++++b+=+b.concat(b);
++++if+(len+&+1)+b+=+b.concat([0]);
++++return+b;
},|code-block|syntax|javascript|1475081|使用makeRec(29)调用该方法。|offset|length|style|CODE|1475082|entityMap^0|0|0|2|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I was testing out the great answer by T.J. Crowder, and came up with a recursive merge based on the concat solution that outperforms any in his tests in Chrome (i didn't test other browsers).

<pre><code>function makeRec(len, acc) {
 if (acc == null) acc = [];
 if (len &lt;= 1) return acc;
 var b = makeRec(len &gt;&gt; 1, [0]);
 b = b.concat(b);
 if (len &amp; 1) b = b.concat([0]);
 return b;
},
</code></pre>

call the method with <code>makeRec(29)</code>.

blocks|key|1475733|text|最短循环代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475734|a=i=[];for(;i<100;)a[i%2B%2B]=0;

edit:
for(a=i=[];i<100;)a[i%2B%2B]=0;
or
for(a=[],i=100;i--;)a[i]=0;|code-block|syntax|javascript|1475735|安全变量版本|1475736|var+a=[],i=0;for(;i<100;)a[i%2B%2B]=0;

edit:
for(var+i=100,a=[];i--;)a[i]=0;|1475737|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Shortest for loop code

<pre><code>a=i=[];for(;i&lt;100;)a[i++]=0;

edit:
for(a=i=[];i&lt;100;)a[i++]=0;
or
for(a=[],i=100;i--;)a[i]=0;
</code></pre>

Safe var version

<pre><code>var a=[],i=0;for(;i&lt;100;)a[i++]=0;

edit:
for(var i=100,a=[];i--;)a[i]=0;
</code></pre>

blocks|key|1474887|text|我知道我在某个地方找到了这个原型:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1474888|Array.prototype.init+=+function(x,n)
{
++++if(typeof(n)=='undefined')+{+n+=+this.length;+}
++++while+(n--)+{+this[n]+=+x;+}
++++return+this;
}

var+a+=+(new+Array(5)).init(0);

var+b+=+[].init(0,4);|code-block|syntax|javascript|1474889|编辑:测试|1474890|作为对Joshua和其他方法的回应，我运行了自己的基准测试，我看到的结果与报道的结果完全不同。|1474891|下面是我测试的内容：|1474892|//my+original+method
Array.prototype.init+=+function(x,n)
{
++++if(typeof(n)=='undefined')+{+n+=+this.length;+}
++++while+(n--)+{+this[n]+=+x;+}
++++return+this;
}

//now+using+push+which+I+had+previously+thought+to+be+slower+than+direct+assignment
Array.prototype.init2+=+function(x,n)
{
++++if(typeof(n)=='undefined')+{+n+=+this.length;+}
++++while+(n--)+{+this.push(x);+}
++++return+this;
}

//joshua's+method
function+newFilledArray(len,+val)+{
++++var+a+=+[];
++++while(len--){
++++++++a.push(val);
++++}
++++return+a;
}

//test+m1+and+m2+with+short+arrays+many+times+10K+*+10

var+a+=+new+Date();
for(var+i=0;+i<10000;+i%2B%2B)
{
++++var+t1+=+[].init(0,10);
}
var+A+=+new+Date();

var+b+=+new+Date();
for(var+i=0;+i<10000;+i%2B%2B)
{
++++var+t2+=+[].init2(0,10);
}
var+B+=+new+Date();

//test+m1+and+m2+with+long+array+created+once+100K

var+c+=+new+Date();
var+t3+=+[].init(0,100000);
var+C+=+new+Date();

var+d+=+new+Date();
var+t4+=+[].init2(0,100000);
var+D+=+new+Date();

//test+m3+with+short+array+many+times+10K+*+10

var+e+=+new+Date();
for(var+i=0;+i<10000;+i%2B%2B)
{
++++var+t5+=+newFilledArray(10,0);
}
var+E+=+new+Date();

//test+m3+with+long+array+created+once+100K

var+f+=+new+Date();
var+t6+=+newFilledArray(100000,+0)
var+F+=+new+Date();|1474893|结果：|1474894|IE7+deltas:
dA=156
dB=359
dC=125
dD=375
dE=468
dF=412

FF3.5+deltas:
dA=6
dB=13
dC=63
dD=8
dE=12
dF=8|1474895|因此，根据我的估算，推送确实是比较慢的，但在FF中使用较长的数组时表现更好，但在IE中表现更差，一般情况下更差(相当令人惊讶)。|1474896|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

I knew I had this proto'd somewhere :)

<pre><code>Array.prototype.init = function(x,n)
{
 if(typeof(n)=='undefined') { n = this.length; }
 while (n--) { this[n] = x; }
 return this;
}

var a = (new Array(5)).init(0);

var b = [].init(0,4);
</code></pre>

Edit: tests

In response to Joshua and others methods I ran my own benchmarking, and I'm seeing completely different results to those reported.

Here's what I tested:

<pre><code>//my original method
Array.prototype.init = function(x,n)
{
 if(typeof(n)=='undefined') { n = this.length; }
 while (n--) { this[n] = x; }
 return this;
}

//now using push which I had previously thought to be slower than direct assignment
Array.prototype.init2 = function(x,n)
{
 if(typeof(n)=='undefined') { n = this.length; }
 while (n--) { this.push(x); }
 return this;
}

//joshua's method
function newFilledArray(len, val) {
 var a = [];
 while(len--){
 a.push(val);
 }
 return a;
}

//test m1 and m2 with short arrays many times 10K * 10

var a = new Date();
for(var i=0; i&lt;10000; i++)
{
 var t1 = [].init(0,10);
}
var A = new Date();

var b = new Date();
for(var i=0; i&lt;10000; i++)
{
 var t2 = [].init2(0,10);
}
var B = new Date();

//test m1 and m2 with long array created once 100K

var c = new Date();
var t3 = [].init(0,100000);
var C = new Date();

var d = new Date();
var t4 = [].init2(0,100000);
var D = new Date();

//test m3 with short array many times 10K * 10

var e = new Date();
for(var i=0; i&lt;10000; i++)
{
 var t5 = newFilledArray(10,0);
}
var E = new Date();

//test m3 with long array created once 100K

var f = new Date();
var t6 = newFilledArray(100000, 0)
var F = new Date();
</code></pre>

Results:

<pre><code>IE7 deltas:
dA=156
dB=359
dC=125
dD=375
dE=468
dF=412

FF3.5 deltas:
dA=6
dB=13
dC=63
dD=8
dE=12
dF=8
</code></pre>

So by my reckoning push is indeed slower generally but performs better with longer arrays in FF but worse in IE which just sucks in general (quel surprise).

blocks|key|1260323|text|我最快的函数是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1260324|function+newFilledArray(len,+val)+{
++++var+a+=+[];
++++while(len--){
++++++++a.push(val);
++++}
++++return+a;
}

var+st+=+(new+Date()).getTime();
newFilledArray(1000000,+0)
console.log((new+Date()).getTime()+-+st);+//+returned+63,+65,+62+milliseconds|code-block|syntax|javascript|1260325|使用原生的push和shift将项添加到数组中要比声明数组作用域并引用每个项来设置其值要快得多(大约10倍)。|1260326|仅供参考:当我在firebug+(firefox扩展)中运行这个程序时，我总是能在第一个循环中获得更快的时间，这是倒计时。|1260327|var+a+=+[];
var+len+=+1000000;
var+st+=+(new+Date()).getTime();
while(len){
++++a.push(0);
++++len+-=+1;
}
console.log((new+Date()).getTime()+-+st);+//+returned+863,+894,+875+milliseconds
st+=+(new+Date()).getTime();
len+=+1000000;
a+=+[];
for(var+i+=+0;+i+<+len;+i%2B%2B){
++++a.push(0);
}
console.log((new+Date()).getTime()+-+st);+//+returned+1155,+1179,+1163+milliseconds|1260328|我很想知道T.J.克劳德是怎么想的？:-)|1260329|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

My fastest function would be:

<pre><code>function newFilledArray(len, val) {
 var a = [];
 while(len--){
 a.push(val);
 }
 return a;
}

var st = (new Date()).getTime();
newFilledArray(1000000, 0)
console.log((new Date()).getTime() - st); // returned 63, 65, 62 milliseconds
</code></pre>

Using the native push and shift to add items to the array is much faster (about 10 times) than declaring the array scope and referencing each item to set it's value.

fyi: I consistently get faster times with the first loop, which is counting down, when running this in firebug (firefox extension).

<pre><code>var a = [];
var len = 1000000;
var st = (new Date()).getTime();
while(len){
 a.push(0);
 len -= 1;
}
console.log((new Date()).getTime() - st); // returned 863, 894, 875 milliseconds
st = (new Date()).getTime();
len = 1000000;
a = [];
for(var i = 0; i &lt; len; i++){
 a.push(0);
}
console.log((new Date()).getTime() - st); // returned 1155, 1179, 1163 milliseconds
</code></pre>

I'm interested to know what T.J. Crowder makes of that ? :-)

blocks|key|1475508|text|匿名函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475509|(function(n)+{+while(n--+&&+this.push(0));+return+this;+}).call([],+5);
//+=>+[0,+0,+0,+0,+0]|code-block|syntax|javascript|1475510|使用for-loop会更短一些：|1475511|(function(n)+{+for(;n--;this.push(0));+return+this;+}).call([],+5);
//+=>+[0,+0,+0,+0,+0]|1475512|适用于任何Object，只需更改this.push()中的内容即可。|offset|length|style|CODE|1475513|你甚至可以保存这个函数：|1475514|function+fill(size,+content)+{
++for(;size--;this.push(content));
++return+this;
}|1475515|使用以下命令调用它：|1475516|var+helloArray+=+fill.call([],+5,+'hello');
//+=>+['hello',+'hello',+'hello',+'hello',+'hello']|1475517|向已存在的数组添加元素：|1475518|var+helloWorldArray+=+fill.call(helloArray,+5,+'world');
//+=>+['hello',+'hello',+'hello',+'hello',+'hello',+'world',+'world',+'world',+'world',+'world']|1475519|性能：http://jsperf.com/zero-filled-array-creation/25|1475520|entityMap|0|LINK|mutability|MUTABLE|url|http://jsperf.com/zero-filled-array-creation/25^0|0|0|0|0|5|6|G|B|0|0|0|0|0|0|0|3|1B|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1E|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1G|8|@$M|1H|N|1I|O|P]|$M|1J|N|1K|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1P|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|1R|8|@]|9|@$M|1S|N|1T|1|1U]]|A|$]]|$1|14|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

Anonymous function:

<pre><code>(function(n) { while(n-- &amp;&amp; this.push(0)); return this; }).call([], 5);
// =&gt; [0, 0, 0, 0, 0]
</code></pre>

A bit shorter with for-loop:

<pre><code>(function(n) { for(;n--;this.push(0)); return this; }).call([], 5);
// =&gt; [0, 0, 0, 0, 0]
</code></pre>

Works with any <code>Object</code>, just change what's inside <code>this.push()</code>. 

You can even save the function:

<pre><code>function fill(size, content) {
 for(;size--;this.push(content));
 return this;
}
</code></pre>

Call it using:

<pre><code>var helloArray = fill.call([], 5, 'hello');
// =&gt; ['hello', 'hello', 'hello', 'hello', 'hello']
</code></pre>

Adding elements to an already existing array:

<pre><code>var helloWorldArray = fill.call(helloArray, 5, 'world');
// =&gt; ['hello', 'hello', 'hello', 'hello', 'hello', 'world', 'world', 'world', 'world', 'world']
</code></pre>

Performance: <a href="http://jsperf.com/zero-filled-array-creation/25" rel="nofollow">http://jsperf.com/zero-filled-array-creation/25</a>

blocks|key|1475902|text|lodash|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1475903|_.fill(array,+value)|code-block|syntax|javascript|1475904|是一种干净且跨浏览器的安全填充数组的方法。|1475905|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs/4.17.4#fill^0|0|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<a href="https://lodash.com/docs/4.17.4#fill" rel="nofollow noreferrer">lodash</a>:

<pre><code>_.fill(array, value)
</code></pre>

is a clean and cross-browser safe way to fill an array.

blocks|key|1260518|text|我只是使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1260519|var+arr+=+[10];
for+(var+i=0;+i<=arr.length;arr[i]+=+i,+i%2B%2B);|code-block|syntax|javascript|1260520|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I just use :

<pre><code>var arr = [10];
for (var i=0; i&lt;=arr.length;arr[i] = i, i++);
</code></pre>

blocks|key|1260809|text|在这里找到另一个不错的选择http://www.2ality.com/2013/11/initializing-arrays.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1260810|function+fillArrayWithNumbers(n)+{
++var+arr+=+Array.apply(null,+Array(n));
++return+arr.map(function+(x,+i)+{+return+i+});
}|code-block|syntax|javascript|1260811|entityMap|0|LINK|mutability|MUTABLE|url|http://www.2ality.com/2013/11/initializing-arrays.html^0|D|1I|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Another nice option found here <a href="http://www.2ality.com/2013/11/initializing-arrays.html" rel="nofollow">http://www.2ality.com/2013/11/initializing-arrays.html</a>

<pre><code>function fillArrayWithNumbers(n) {
 var arr = Array.apply(null, Array(n));
 return arr.map(function (x, i) { return i });
}
</code></pre>

blocks|key|1261317|text|递归解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1261318|正如其他几个人所指出的，利用.concat()通常可以提供快速的解决方案。下面是一个简单的递归解决方案：|offset|length|style|CODE|1261319|​|1261320|function+zeroFill(len,+a){
++return+len+<=+(a+%7C%7C+(a+=+[0])).length+?
++++a.slice(0,+len)+:
++++zeroFill(len,+a.concat(a))
}

console.log(zeroFill(5));|code-block|syntax|javascript|1261321|1261322|和一个通用的递归数组填充函数：|1261323|1261324|function+fill(len,+v){
++return+len+<=+(v+=+[].concat(v,+v)).length+?
++++v.slice(0,+len)+:+fill(len,+v)
}

console.log(fill(5,+'abc'));|1261325|1261326|entityMap^0|0|E|9|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|12|8|@]|9|@]|A|$M|N]]|$1|O|3|I|5|6|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|14|8|@]|9|@]|A|$]]|$1|R|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|16|8|@]|9|@]|A|$M|N]]|$1|U|3|I|5|6|7|17|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|W|$]]

<h2>Recursive solutions</h2>

As noted by several others, utilizing <code>.concat()</code> generally provides fast solutions. Here is a simple recursive solution:

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function zeroFill(len, a){
 return len &lt;= (a || (a = [0])).length ?
 a.slice(0, len) :
 zeroFill(len, a.concat(a))
}

console.log(zeroFill(5));</code></pre>
</div>
</div>


And a general-purpose recursive array fill function:

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function fill(len, v){
 return len &lt;= (v = [].concat(v, v)).length ?
 v.slice(0, len) : fill(len, v)
}

console.log(fill(5, 'abc'));</code></pre>
</div>
</div>

blocks|key|1476054|text|这里最快的是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1476055|(arr+=+[]).length+=+len;+arr.fill(0);|code-block|syntax|javascript|1476056|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The fastest here is 

<pre><code>(arr = []).length = len; arr.fill(0);
</code></pre>

blocks|key|1476123|text|const+item+=+0
const+arr+=+Array.from({length:+10},+()+=>+item)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1476124|​|unstyled|1476125|const+item+=+0
const+arr+=+Array.from({length:+42},+()+=>+item)
console.log('arr',+arr)|1476126|1476127|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|N|8|@]|9|@]|A|$B|C]]|$1|I|3|E|5|F|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|F|7|P|8|@]|9|@]|A|$]]]|K|$]]

<pre><code>const item = 0
const arr = Array.from({length: 10}, () =&gt; item)
</code></pre>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const item = 0
const arr = Array.from({length: 42}, () =&gt; item)
console.log('arr', arr)</code></pre>
</div>
</div>

blocks|key|1475021|text|最快的方法是使用forEach+=)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475022|(我们保持IE+<9的向后兼容性)|1475023|var+fillArray+=+Array.prototype.forEach
++++?+function(arr,+n)+{
+++++++++arr.forEach(function(_,+index)+{+arr[index]+=+n;+});
+++++++++return+arr;
++++++}
++++:+function(arr,+n)+{
+++++++++var+len+=+arr.length;
+++++++++arr.length+=+0;
+++++++++while(len--)+arr.push(n);
+++++++++return+arr;
++++++};

//+test
fillArray([1,2,3],+'X');+//+=>+['X',+'X',+'X']|code-block|syntax|javascript|1475024|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The fastest way to do that is with forEach =)

(we keep backward compatibility for IE &lt; 9)

<pre><code>var fillArray = Array.prototype.forEach
 ? function(arr, n) {
 arr.forEach(function(_, index) { arr[index] = n; });
 return arr;
 }
 : function(arr, n) {
 var len = arr.length;
 arr.length = 0;
 while(len--) arr.push(n);
 return arr;
 };

// test
fillArray([1,2,3], 'X'); // =&gt; ['X', 'X', 'X']
</code></pre>

blocks|key|1475230|text|您可以检查索引是否存在，以便向其追加%2B1。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1475231|这样你就不需要填零的数组了。|1475232|示例：|1475233|var+current_year+=+new+Date().getFullYear();
var+ages_array+=+new+Array();

for+(var+i+in+data)+{
++++if(data[i]['BirthDate']+!=+null+&&+data[i]['BirthDate']+!=+'0000-00-00'){

++++++++var+birth+=+new+Date(data[i]['BirthDate']);
++++++++var+birth_year+=+birth.getFullYear();
++++++++var+age+=+current_year+-+birth_year;

++++++++if(ages_array[age]+==+null){
++++++++++++ages_array[age]+=+1;
++++++++}else{
++++++++++++ages_array[age]+%2B=+1;
++++++++}

++++}
}

console.log(ages_array);|code-block|syntax|javascript|1475234|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can check if index exist or not exist, in order to append +1 to it.

this way you don't need a zeros filled array.

EXAMPLE:

<pre><code>var current_year = new Date().getFullYear();
var ages_array = new Array();

for (var i in data) {
 if(data[i]['BirthDate'] != null &amp;&amp; data[i]['BirthDate'] != '0000-00-00'){

 var birth = new Date(data[i]['BirthDate']);
 var birth_year = birth.getFullYear();
 var age = current_year - birth_year;

 if(ages_array[age] == null){
 ages_array[age] = 1;
 }else{
 ages_array[age] += 1;
 }

 }
}

console.log(ages_array);
</code></pre>

blocks|key|1261743|text|let+arr+=+[...Array(100).fill(0)]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1261744|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>let arr = [...Array(100).fill(0)]
</code></pre>

blocks|key|1260154|text|var+str+=+"0000000...0000";
var+arr+=+str.split("");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1260155|表达式中的用法：arr[i]*1;|unstyled|offset|length|style|CODE|1260156|编辑:如果arr应该在整数表达式中使用，那么请不要介意字符值“0”。您只需按如下方式使用它：a+=+a+*+arr[i]+(假设a具有整数值)。|1260157|entityMap^0|0|8|9|0|5|3|1A|E|1S|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@$G|T|H|U|I|J]|$G|V|H|W|I|J]|$G|X|H|Y|I|J]]|9|@]|A|$]]|$1|M|3|-4|5|F|7|Z|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>var str = "0000000...0000";
var arr = str.split("");
</code></pre>

usage in expressions: <code>arr[i]*1;</code>

EDIT: if <code>arr</code> supposed to be used in integer expressions, then please don't mind the char value of '0'. You just use it as follows: <code>a = a * arr[i]</code> (assuming <code>a</code> has integer value).

blocks|key|1476112|text|我知道这不是这个问题的目的，但这里有一个开箱即用的想法。为什么？我的CSci教授指出，用零“清理”数据并没有什么神奇之处。所以最有效的方法就是根本不去做！只有在数据需要为零作为初始条件(例如某些求和)时才这样做--这通常不是大多数应用程序的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1476113|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I know this isn't the purpose of the question, but here's an out-of-the-box idea. Why? My CSci professor noted that there is nothing magical about 'cleansing' data with zero. So the most efficient way is to NOT do it at all! Only do it if the data needs to be zero as an initial condition (as for certain summations) -- which is usually NOT the case for most applications.

blocks|key|1261121|text|return+Array(+quantity+).fill(1).map(+n+=>+return+n+*+Math.abs(~~(Math.random()+*+(1000+-+1+%2B+1))+%2B+1)+);|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1261122|一句话。|1261123|entityMap^0|0|2X|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

<code>return Array( quantity ).fill(1).map( n =&gt; return n * Math.abs(~~(Math.random() * (1000 - 1 + 1)) + 1) );</code>

One line.

What is the most efficient way to create an arbitrary length zero filled array in JavaScript?

Most efficient way to create a zero filled JavaScript array?

在JavaScript中创建任意长度的填零数组最有效的方法是什么？

问创建一个填零的JavaScript数组的最有效的方法？
EN

回答 32

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问创建一个填零的JavaScript数组的最有效的方法？EN

回答 32

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问创建一个填零的JavaScript数组的最有效的方法？
EN