看看: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);

来源:链接

克隆数组至少有6种方法:

循环 片 Array.from () concat 扩展语法(最快) map(函数(e){返回e;});

有一个巨大的基准线程，提供以下信息:

对于闪烁的浏览器，slice()是最快的方法，concat()稍慢，while循环慢2.4倍。 对于其他浏览器，while循环是最快的方法，因为这些浏览器没有对切片和连接进行内部优化。

2016年7月依然如此。

下面是一些简单的脚本，您可以将它们复制粘贴到浏览器的控制台，并多次运行以查看图片。它们输出毫秒，越低越好。

while循环

n = 1000*1000;
start = + new Date();
a = Array(n); 
b = Array(n); 
i = a.length;
while(i--) b[i] = a[i];
console.log(new Date() - start);

片

n = 1000*1000;
start = + new Date();
a = Array(n); 
b = a.slice();
console.log(new Date() - start);

请注意，这些方法将克隆Array对象本身，但是数组内容是通过引用复制的，而不是深度克隆。

origAr == clonedArr //returns false
origAr[0] == clonedArr[0] //returns true

看看: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);

来源:链接

正如@Dan所说:“这个答案很快就过时了。使用基准测试来检查实际情况”，有一个特定的答案从jsperf没有自己的答案:while:

var i = a.length;
while(i--) { b[i] = a[i]; }

有960,589次操作/秒，亚军a.c concat()为578,129次操作/秒，占60%。

这是最新的64位Firefox(40)。

@aleclarson创建了一个新的、更可靠的基准。

        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);

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

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

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