为了在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包含对对象的引用,对象将不会被克隆,但只有引用将被复制,因此两个数组将有对相同对象的引用。
但这不是问题的关键。
我只是在问速度。
正如@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创建了一个新的、更可靠的基准。
它取决于数组的长度。如果数组长度<= 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。
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 clonedArray=[...originalArray]
or
var clonedArray = originalArray.slice(0); //with 0 index it's little bit faster than normal slice()
但是克隆数组中的对象仍然指向旧的内存位置。因此改变到clonedArray对象也会改变orignalArray。所以
var clonedArray = originalArray.map(({...ele}) => {return ele})
这不仅将创建新的数组,而且还将克隆对象。
免责声明,如果你正在使用嵌套对象,在这种情况下,展开操作符将工作为浅克隆。在这一点上最好使用
var clonedArray=JSON.parse(JSON.stringify(originalArray));