在JavaScript中复制数组的最快方法-切片vs。“为”循环

为了在JavaScript中复制数组:下面哪个使用更快?

片的方法

var dup_array = original_array.slice();

For循环

for(var i = 0, len = original_array.length; i < len; ++i)
   dup_array[i] = original_array[i];

我知道这两种方法都只做一个浅拷贝:如果original_array包含对对象的引用，对象将不会被克隆，但只有引用将被复制，因此两个数组将有对相同对象的引用。但这不是问题的关键。

我只是在问速度。

当前回答

它取决于数组的长度。如果数组长度<= 1,000,000,slice和concat方法花费的时间大致相同。但当你给出一个更大的范围时，concat方法胜出。

例如，试试下面的代码:

var original_array = [];
for(var i = 0; i < 10000000; i ++) {
    original_array.push( Math.floor(Math.random() * 1000000 + 1));
}

function a1() {
    var dup = [];
    var start = Date.now();
    dup = original_array.slice();
    var end = Date.now();
    console.log('slice method takes ' + (end - start) + ' ms');
}

function a2() {
    var dup = [];
    var start = Date.now();
    dup = original_array.concat([]);
    var end = Date.now();
    console.log('concat method takes ' + (end - start) + ' ms');
}

function a3() {
    var dup = [];
    var start = Date.now();
    for(var i = 0; i < original_array.length; i ++) {
        dup.push(original_array[i]);
    }
    var end = Date.now();
    console.log('for loop with push method takes ' + (end - start) + ' ms');
}

function a4() {
    var dup = [];
    var start = Date.now();
    for(var i = 0; i < original_array.length; i ++) {
        dup[i] = original_array[i];
    }
    var end = Date.now();
    console.log('for loop with = method takes ' + (end - start) + ' ms');
}

function a5() {
    var dup = new Array(original_array.length)
    var start = Date.now();
    for(var i = 0; i < original_array.length; i ++) {
        dup.push(original_array[i]);
    }
    var end = Date.now();
    console.log('for loop with = method and array constructor takes ' + (end - start) + ' ms');
}

a1();
a2();
a3();
a4();
a5();

如果您将original_array的长度设置为1,000,000,slice方法和concat方法大约需要相同的时间(3-4 ms，取决于随机数)。

如果将original_array的长度设置为10,000,000，则slice方法需要超过60 ms, concat方法需要超过20 ms。

2015-11-18 07:35:52

其他回答

看看:link。重点不是速度，而是舒适度。此外，正如你所看到的，你只能在原始类型上使用slice(0)。

要制作数组的独立副本，而不是对其引用的副本，可以使用数组切片方法。

例子:

To make an independent copy of an array rather than a copy of the refence to it, you can use the array slice method. var oldArray = ["mip", "map", "mop"]; var newArray = oldArray.slice(); To copy or clone an object : function cloneObject(source) { for (i in source) { if (typeof source[i] == 'source') { this[i] = new cloneObject(source[i]); } else{ this[i] = source[i]; } } } var obj1= {bla:'blabla',foo:'foofoo',etc:'etc'}; var obj2= new cloneObject(obj1);

来源:链接

2010-10-20 13:52:05

基准时间!

自单击按钮以来，基准测试将运行10秒。

我的结果:

Chrome (V8引擎):

1. clone1 score: 100% *winner* (4110764)
2. clone3 score: 74.32% speed of winner. (3055225)
3. clone2 score: 30.75% speed of winner. (1264182)
4. clone4 score: 21.96% speed of winner. (902929)

Firefox (SpiderMonkey Engine):

1. clone1 score: 100% *winner* (8448353)
2. clone3 score: 16.44% speed of winner. (1389241)
3. clone4 score: 5.69% speed of winner. (481162)
4. clone2 score: 2.27% speed of winner. (192433)

赢家代码:

function clone1(arr) {
    return arr.slice(0);
}

赢家引擎: SpiderMonkey (Mozilla Firefox)

2019-08-29 11:50:01

        const arr = ['1', '2', '3'];

         // Old way
        const cloneArr = arr.slice();

        // ES6 way
        const cloneArrES6 = [...arr];

// But problem with 3rd approach is that if you are using muti-dimensional 
 // array, then only first level is copied

        const nums = [
              [1, 2], 
              [10],
         ];

        const cloneNums = [...nums];

// Let's change the first item in the first nested item in our cloned array.

        cloneNums[0][0] = '8';

        console.log(cloneNums);
           // [ [ '8', 2 ], [ 10 ], [ 300 ] ]

        // NOOooo, the original is also affected
        console.log(nums);
          // [ [ '8', 2 ], [ 10 ], [ 300 ] ]

所以，为了避免这些情况的发生，使用

        const arr = ['1', '2', '3'];

        const cloneArr = Array.from(arr);

2019-06-07 17:39:30

有一个更干净的解决方案:

var srcArray = [1, 2, 3];
var clonedArray = srcArray.length === 1 ? [srcArray[0]] : Array.apply(this, srcArray);

长度检查是必需的，因为当只使用一个参数调用Array构造函数时，它的行为会有所不同。

2014-04-28 13:31:57

您可以遵循这段代码。不可变方式数组克隆。这是克隆数组的最佳方法


const array = [1, 2, 3, 4]

const newArray = [...array]
newArray.push(6)
console.log(array)
console.log(newArray)

2020-03-14 20:08:38

在JavaScript中复制数组的最快方法-切片vs。“为”循环

推荐文章

最新文章

标签