为了在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包含对对象的引用，对象将不会被克隆，但只有引用将被复制，因此两个数组将有对相同对象的引用。 但这不是问题的关键。
我只是在问速度。
当前回答
如果你想在JS中获得一个REAL克隆对象/数组，其中包含所有属性和子对象的克隆引用:
export function clone(arr) {
return JSON.parse(JSON.stringify(arr))
}
所有其他操作都不会创建克隆，因为它们只是改变根元素的基址，而不是所包含对象的基址。
除了递归遍历对象树。
对于一个简单的副本，这些是可以的。对于存储地址相关的操作，我建议(在大多数其他情况下，因为这是快速的!)类型转换为字符串和返回在一个完整的新对象。
其他回答
如果你想在JS中获得一个REAL克隆对象/数组，其中包含所有属性和子对象的克隆引用:
export function clone(arr) {
return JSON.parse(JSON.stringify(arr))
}
所有其他操作都不会创建克隆，因为它们只是改变根元素的基址，而不是所包含对象的基址。
除了递归遍历对象树。
对于一个简单的副本，这些是可以的。对于存储地址相关的操作，我建议(在大多数其他情况下，因为这是快速的!)类型转换为字符串和返回在一个完整的新对象。
ECMAScript 2015的扩展操作符方式:
基本的例子:
var copyOfOldArray = [...oldArray]
var twoArraysBecomeOne = [...firstArray, ..seccondArray]
在浏览器控制台中尝试:
var oldArray = [1, 2, 3]
var copyOfOldArray = [...oldArray]
console.log(oldArray)
console.log(copyOfOldArray)
var firstArray = [5, 6, 7]
var seccondArray = ["a", "b", "c"]
var twoArraysBecomOne = [...firstArray, ...seccondArray]
console.log(twoArraysBecomOne);
参考文献
展开运算符的6大用途 传播的语法
A.map (e => e)是这项工作的另一种选择。到目前为止，.map()在Firefox中非常快(几乎和.slice(0)一样快)，但在Chrome中则不然。
另一方面，如果一个数组是多维的，因为数组是对象，对象是引用类型，没有一个slice或concat方法将是治愈…因此，克隆数组的一种正确方法是array .prototype.clone()的发明，如下所示。
Array.prototype.clone = function(){ 返回。map(e => Array.isArray(e) ?e.clone(): e); }; var arr =[1、2、3、4(1、2(1、2、3),4、5],6], BRR = arr.clone(); Brr [4][2][1] = " 2 "; console.log (JSON.stringify (arr)); console.log (JSON.stringify (brr));
深度克隆数组或对象的最简单方法:
var dup_array = JSON.parse(JSON.stringify(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。
