具有单个值的阵列的原始化数数

问题描述 投票：0回答：13
有一种更紧凑的方法来执行这种初始化？

for (var i = 0; i < arraySize; i++) array[i] = value;
javascript
13个回答
219
投票
这样做的短暂方式将是：

var arr = Array(arraySize).fill(value); 
例如，如果
arr = Array [ 0, 0, 0, 0, 0 ]

和

arraySize == 5
，例如。 


value == 0



没有初始化（我知道）

    

    
    
    

    

        

            

                

                    
48
投票

                    

                

            

        

        



update



从4年前发布这个答案，人们似乎一直回到这里寻求这个答案。为了进行基准测试，我用一些不同的解决方案制作了一个
jsperf
。


上面的解决方案不是最快的，尽管它很短。坚持相同的短风格，但性能更好：

while(arraySize--) array.push(value);





Update2016年2月
使用更多的测试柜更新了jsperf。


如果表现无关紧要，您想要一个单线：
while(size--) array[size] = value;




有更多的性能解决方案（一，肮脏，线）：


var value = 1234, // can be replaced by a fixed value
    size  = 1000, // can be replaced by a fixed value
    array = Array.apply(null,{length: size}).map(function() { return value; });


    




这个是一个古老的问题，但我在现代JS中使用它：


for(var i = 0, value = 1234, size = 1000, array = new Array(1000); i < size; i++) array[i] = value;

    



在一次性的情况下，OP似乎是紧凑的，而不是效率和可重复性。对于寻求效率的其他人来说，这是尚未提及的优化。由于您知道预先的数组的长度，请在分配值之前继续进行设置。否则，阵列将随时反复调整大小 - 不是理想的！




    

    
    
    

    

        

            

                

                    
17
投票

                    
                

            

        

        

    




这不是紧凑，但可以说是更直接的。


function initArray(length, value) {
    var arr = [], i = 0;
    arr.length = length;
    while (i < length) { arr[i++] = value; }
    return arr;
}

var data = initArray(1000000, false);


    

    
    
    

    

        

            

                

                    
10
投票

                    
                

            

        

        




这不太可能比上面的任何技术都好，但它很有趣...
array = Array.apply(null, new Array(arraySize)).map(function () {return value;});


    

    
    
    

    

        

            

                

                    
9
投票

                    
                

            

        

        



您可以使用JS数组构造函数：


var a = new Array(10).join('0').split('').map(function(e) {return parseInt(e, 10);})




    

    
    
    

    

        

            

                

                    
6
投票

                    
                

            

        

        
const arr = new Array(3)

）

SO创建数组并用一些值初始化它，简单地做：
[null, null, null]

    

    
    
    

    

        

            

                

                    
6
投票

                    
                

            

        

        
雷德
    




提出效率，我会避免
const arr = new Array(3).fill(value)

。所以简单


push



为IE10：



for (var i = 0; i < arraySize; i++) array[i] = value; 

Edit：按照评论中讨论的修改。
    





    

    
    
    

    

        

            

                

                    
3
投票

                    
                

            

        

        



array = new Array(arraySize); 
for (var i = 0; i < arraySize; i++) array[i] = value; 

，只是为了完整（摆弄内置对象的原型通常不是一个好主意）：



function makeArray(howMany, value){
    var output = [];
    while(howMany--){
        output.push(value);
    }
    return output;
}

var data = makeArray(40, "Foo");




因此，您现在可以：



Array.prototype.fill = function(howMany, value){
    while(howMany--){
        this.push(value);
    }
}







update：我刚刚看到您关于

    

    
    
    

    

        

            

                

                    
1
投票

                    
                

            

        

        
是一个不变的或字面意思的注释。如果是这样，只需用良好的旧
arraySize
替换全部
while(howMany--)
。
    




在探索飞机上的数组方法的同时，在这一过程中陷入困境。哦，当我们无聊时我们去的地方。 ：）



for(var i=0; i<howMany; i++)



var initializedArray = new Array(30).join(null).split(null).map(function(item, index){
  return index;
});

和
.map()
赢了！我喜欢null，因为传递像“ 0”之类的字符串或任何其他值都令人困惑。我认为这更明确地说我们正在做一些不同的事情。 



注意
null
跳过非初始化值。这就是为什么
.map()
不起作用。如果可用，则首选新的

    

    
    
    

    

        

            

                

                    
1
投票

                    
                

            

        

        
方法，但是浏览器支持应从
8/23/2015
.
。


desktop（基本支持）



chrome 45（36
1
）

Firefox（壁虎）31（31）


不支持Internet Explorer
eopera不支持
safari7.1


从Mdn：



.fill()

    
    

  • 
the我的测试到目前为止，这是我的PC中最快的。但是请注意，此方法可能不适合所有用例。
1亿元素约为350毫秒。
[1, 2, 3].fill(4);               // [4, 4, 4]
[1, 2, 3].fill(4, 1);            // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
Array(3).fill(4);                // [4, 4, 4]
[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}

    • 

  • 对于相同数量的元素
    • "0".repeat(100000000).split('');

  • 需要大约7000毫秒，那是一个巨大的差异
    • 
    
  • 

    • 

  • 在数量上添加数字：
    • 

[...new Array(100000000)].map(()=>0)

在这里有人在这里寻找。 。 .
    



    

    
    
    

    

        

            

                

                    
0
投票

                    
                

            

        

        
对于巨大的阵列（我的机器上的〜14）的速度非常慢（我的机器上的〜14）在V8中产生一个[漏洞阵列]和（
Https：//v8.dev/blog/elements-kinds
），更糟性能特征比“包装阵列”，因此是次优的。

方法


Array(arraySize).fill(value)


对于较小的阵列（
arraySize=1e8
）比
push

    

    
    
    

    

        

            

                

                    
0
投票

                    
                

            

        

        
let array = []
for(let i = 0; i < arraySize; i++){
    array.push(value)
}

。
答案中的所有其他建议似乎都是愚蠢的骇客，而且性能甚至更糟。

因此，唯一正确的答案是尽可能使用typedarray
：


arraySize <= 1e7



    

    
    
    

    

        

            

                

                    
0
投票

                    
                

            

        

        
fill
使用
1e8
这仅在我的计算机上占4毫秒，而
let array = new Int32Array(arraySize) // this array is already 0-initialized
array.fill(value) // only necessary if value != 0

方法的15ms和70ms的方法。
arraySize = 1e7

（可以随意更正确地基准测试，但是结果似乎是如此一致，以至于不必要。）

    
	



    

    


  

  

    
最新问题


  





  

    © www.soinside.com 2019 - 2025. All rights reserved.