如何在javascript中快速扩展二维数组？

给定二维数组a：

let a = [
    [0, 0, 1, 0], 
    [0, 1, 1, 1], 
    [0, 0, 1, 0], 
    [0, 0, 1, 1] 
]

我如何根据给定的因子进行缩放？例如，阵列b是按4缩放的阵列a：

let b =[ 
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
]

这是我为执行此操作而编写的代码，但在处理大型阵列（200 x 200）和缩放（比方说通过16倍的facor）时速度很慢（客户端浏览器：Chrome）

// scale an array by a factor of 'scale'

const scaledMatrixArray = (arr, scale) => {
        let newArr = [];
        arr.forEach((el) => {
            let newArrRow = [];
            el.forEach((el) => {
                for (let j = 0; j < scale; j++) {
                    newArrRow.push(el);
                }
            });
            for(let i = 0; i < scale ; i++) {
                newArr.push(newArrRow);
            }
        });
        return newArr;
    };

//按“比例”因子缩放数组
常量缩放矩阵=（arr，scale）=>{
设newArr=[]；
arr.forEach（（el）=>{
设newArrRow=[]；
el.forEach（（el）=>{
对于（设j=0；j

---

我知道我的实现是O（n^2）的一个变体，效率很低。我正在寻找一个更好的方法来做这件事，或者一个能做得更好更快的图书馆。我的最终结果是，超过N>200的N X N数组可以以最高效、最快和内存占用最少的方式扩展到800 X 800的数组。

此方法使用

for循环

，以确定的

N

次迭代一个N维数组

它使用的方法是获取源值并将其插入到数组中的某个索引处

PS：源数组（即

a

）在这里进行了变异。但是，您始终可以克隆原始阵列并根据需要为结果创建

b

var a=[
[0, 0, 1, 0],
[0, 1, 1, 1], 
[0, 0, 1, 0], 
[0, 0, 1, 1] 
],
比例=4，
scaleTheArray=函数（arrayToScale，nTimes）{
对于（变量idx=0，i=0，len=arrayToScale.length*n次；iconsole.timeEnd（'testScale'）有趣的是，如果您没有访问很多值，您可以懒洋洋地执行此操作。虽然没有对这段代码进行过太多测试，但应该可以正常工作


var a=[
[0, 0, 1, 0],
[0, 1, 1, 1], 
[0, 0, 1, 0], 
[0, 0, 1, 42] 
],
比例=4；
对于（var idx=0；idx对于（var j=0；j通常，函数调用越少，开销越小：


功能刻度1d（arr，n）
{
对于（var i=arr.length*=n；i；）
arr[--i]=arr[i/n | 0]
}
功能标度2d（arr，n）
{
对于（var i=arr.length；i；）
标度1d（arr[--i]，n）
刻度1d（arr，n）
}
变量a=[[0,0,1,0]，[0,1,1,1]，[0,0,1,0]，[0,0,1,1]]
控制台时间（1e5）
标度2D（a，1e5）
控制台。时间结束（1e5）
变量b=[[0,0,1,0]，[0,1,1,1]，[0,0,1,0]，[0,0,1,1]]
标度2d（b，4）
console.log（JSON.stringify（b）.replace（/]，/g，']，\n'））
这是一种非常简化的方法，使用
Array（）.fill
，至少在我的浏览器中，它比其他答案运行得更快

我添加了两个版本，一个使用扩展运算符，另一个使用
.apply
。我使用
apply
获得更快的结果


函数scaleSpread（数组、因子）{
常量缩放=[]；
for（数组的常量行）{
设x=[]；
用于（行的常量项）
x、 推送（…数组（因子）.填充（项））；
缩放.push（…数组（因子）.fill（x））；
}
返回标度；
}
函数scaleApply（数组、因子）{
常量缩放=[]；
for（数组的常量行）{
设x=[]；
用于（行的常量项）
x、 推送。应用（x，数组（因子）。填充（项目））；
缩放、推送、应用（缩放、数组（因子）、填充（x））；
}
返回标度；
}
函数scalencat（数组、因子）{
设标度=[]；
for（数组的常量行）{
设x=[]；
用于（行的常量项）
x=x.concat（数组（因子）。填充（项目））；
scaled=scaled.concat（数组（因子）.fill（x））；
}
返回标度；
}
变量a=[[0,0,1,0]，[0,1,1,1]，[0,0,1,0]，[0,0,1,1]]
控制台。时间（“传播”）；
scaleSpread（a，10000）；
控制台。时间结束（“排列”）；
控制台。时间（“应用”）；
规模层（a，10000）；
console.timeEnd（“应用”）；
控制台时间（“concat”）；
Scalencat（a，10000）；
console.timeEnd（'concat'）；
请注意，任何采用
N*N
数组并按某个因子
M
对其进行缩放的实现都将产生总共
N*N*M
值，因此将为O（mn^2）@哈姆斯：所以没有办法让它更快？取决于你到底想做什么，可能有比制作一个巨大的阵列更快/更好的方法。如果你真的关心速度，你可以在任何地方使用
，而不是
forEach
，它在执行大量任务时都会有微小的性能提升重复操作。似乎你可以在50x50矩阵上找到路径，然后将得到的路径点乘以16。上帝之母，这很快。
10000 scale=1328.18995ms
@Zze对你来说太糟糕了，对我来说
10000 scale=302.428955078125ms
8）@今天晚些时候，choz一直在关注我的个人电脑报告！这速度太快了…我得到了
10000 scale=367.779052734375ms
@EmmanuelNK将发布一个答案，然后，我的方法比choz'快，至少在我的浏览器中是如此。C