Javascript 重置多维数组的最快方法？

假设我有一个二维数组：

向量[x][y]

，初始数组结构如下所示：

vectors = [    
 [0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0,]
]

经过一些计算后，数组中的数据将随机化。将阵列恢复到初始状态的最快和最有效的方法是什么

我知道我可以对上面的归零数组进行硬编码，并再次将向量设置为等于它，但我也知道一种算法，例如：

for (var x = 0; x < vectors.length; x++) {
    for (var y = 0; y < vectors[x].length; y++) {
        vectors[x][y] = 0;
    }

}

for（var x=0；x

是O（x*y）

那么哪种方法更好呢？有没有更好、更快/更有效的方法来解决这个问题

---

对于任意长度的多维数组归零的一般情况，哪种方法是最好的？（如果重要的话，我会使用JavaScript）

如果我是你，我会有一个空的数组，每当我重置值时，我都会用空的替换变量。如果您需要重新进行重置和初始化，那么只需再花费一个空数组

更新

也许这会帮助你度过难关：

var empty = function() {
    return [
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0]
    ];
};

var vectors = new empty();

for (var i = 0; i < 10; i++)
{
    for (var x = 0; x < vectors.length; x++)
        for (var y = 0; y < vectors[x].length; y++)
            vectors[x][y] = x * y + 2; // Some values just for changing the array.

    vectors = new empty();
}

var empty=function（）{
返回[
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]
];
};
var向量=新空（）；
对于（变量i=0；i<10；i++）
{
对于（var x=0；x

---

干杯。

我冒昧地说，为所有元素分配相同值的最快方法是调用Array.map（）

---

但是，这里有一个陷阱。请注意，在本机实现该方法的浏览器上，这将具有难以置信的快速性能，并且在其他浏览器中也将具有通常的性能。还要注意的是.map（）在一些旧浏览器中不可用，因此您需要使用underline.js或提供该方法的任何其他库。

到目前为止，我们似乎有两种可能的选择

用零覆盖整个内容。（您的解决方案）

保留所有修改元素的记录，并仅重置这些元素<代码>记录[0]。x=3；记录[0]，y=5等等 但是，您仍然需要在记录中循环一次。为了进一步解释，我的意思是，每当数组中的一个元素被设置为一个值时，您应该记录该元素在数组中的位置。然后，使用循环，可以访问每个元素并将其设置为0。所以，如果你有一个稀疏数组，它会更有效

---

根据实现情况，我可以理解为什么你想要#2而不是#1…但是如果你有一个足够大的矩阵，你需要担心分析算法，你可以考虑做某种服务器预处理。

< P>另一种不同的方法是使用线性数组并在更新时从X、Y索引计算线性索引。 然后，初始化只是一个

循环，时间为O（x+y）
这是我的两分钱：

我会保留原始阵列的干净副本，以获得最快的性能。您可以保留引用的硬编码副本

var vectorsOrig = [    
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]
];

或者使用slice对初始数组进行动态干净克隆（对于深度复制，递归进行）：

不管怎样，采用将向量引用重置为原始副本的方法将比循环并重置每个节点快

话虽如此，问题变成了每次都要获得一个干净的副本。拥有一个硬编码的实例会给你一个干净的副本，你以后必须克隆它。你也不想通过类似于重置选项的for循环进入动态生成。我的建议是编写一个克隆函数，只返回一个新的硬编码实例或初始化的数组：

function newVector() {
    return [    
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0]
    ];
}
var vector = newVector();
vector[1][2] = 11;
console.dir(vector);
vector = newVector();  // your old array will be garbage-collected if no longer referenced by any other reference
console.dir(vector);

理想情况下，最好对各种方法进行基准测试

编辑
多亏了Vega的输入，我修改了他的测试以测试三种方法。在Chrome和IE9中，这个解决方案似乎是最快的，在FF（15.0.1）中，手动迭代似乎更快（在FF中，内存分配/管理可能更慢）.
可能相关：您是否尝试过这两种方法并分析了每种方法？@lc。我将始终知道数组的长度事先，它们是手动初始化的。对于我问题的特殊情况，数组是5x5。为什么我们担心5x5数组的Big-O性能？我想你可以展开整个嵌套循环。@a.Webb：因为纯粹的理论兴趣！（这就是为什么我还要求使用一般情况）我并不特别担心数据将由谁来处理。我更感兴趣的是，通常哪个解决方案最快。我愿意说，我的第二个解决方案将在O（n）中执行时间，其中n是修改的元素数。最坏情况下的性能是n=整个数组。这看起来是一个特别好的解决方案，但我不确定我是否完全理解方法#2。你能重新解释一下吗？谢谢你的重新解释。但是属性访问有多贵？
（var i=0；iI在我的算法课程中，你会说内存访问是1个时间单位。所以，为了评估你刚刚发布的代码，我会说var i=0是一个赋值，1个单位。ifunction newVector() {
    return [    
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0]
    ];
}
var vector = newVector();
vector[1][2] = 11;
console.dir(vector);
vector = newVector();  // your old array will be garbage-collected if no longer referenced by any other reference
console.dir(vector);