Javascript 复制对象数组

我在创建对象数组的副本时遇到问题。我无法获取指向新独立数组的新引用

function OBJ1(name, tags) {
    this.myname = name;
    this.mytags = tags;
    this.myvalue = 0;
}

function OBJ2(arg1) {
    this.arg1 = arg1;
    this.myarray = [];
}

var OBJ1_array = [];
var result_array2 = null;
var result;
OBJ1_array = createarray1();
for (i = 0; i < 2; i++) {
    result = createarray2();
}

function createarray1() {
    var myarray = [];
    myarray.push(new OBJ1("NAME", [1, 2, 3]));
    myarray.push(new OBJ1("others", [1, 2, 3]));
    myarray.push(new OBJ1("total", [1, 2, 3]));
    return myarray;
}

function createarray2() {
    var newarray = $.extend(true, [], OBJ1_array); // newarray should refer to a new array, not the same one as OBJ1_array
    OBJ1_array[0].myname = "CHANGED";
    console.log("categories", JSON.parse(JSON.stringify(OBJ1_array)));
    console.log("newarray", JSON.parse(JSON.stringify(newarray)));
}

我需要

OBJ1\u数组[0].myname=“已更改”

对新创建的数组没有影响

newArray

。 我尝试过但没有成功的事情：

var newArray = OBJ1_array.map(a => ({...a}));
var newarray=$.extend(true,[],OBJ1_array);

---

如何解决此问题？

解决了使用

甚至更短

---

更新了答案。实现所需功能的最简单方法是使用

JSON.stringify

和

JSON.parse

创建对象数组的未链接副本

const OBJ1=（名称、标记）=>({
我的名字：，
mytags:tags，
myvalue:0，
})
函数createarray1（）{
var myarray=[]；
push（OBJ1（“NAME”，[1,2,3]）；
myarray.push（OBJ1（“其他”[1,2,3]）；
myarray.push（OBJ1（“总计”[1,2,3]）；
返回myarray；
}
常量arr=createarray1（）
//在这里，您可以创建数组的副本
const newArr=JSON.parse（JSON.stringify（arr））
//将更改直接应用于副本
newArr[0]。myname=“其他内容”
console.log（newArr）
console.log（arr）

数组和对象是引用类型，这意味着当您通过赋值进行复制时，您只是复制引用，而不是底层数组/对象。在本例中，复制阵列时，复制所有对象引用，这些引用仍将指向原始阵列中的对象。你也需要克隆对象，它才能工作

用于迭代数组并复制每个项

用于对每个对象进行浅克隆。此函数使用原型和属性描述符创建新对象。您可以使用将输入对象的原型和属性描述符传递给它

功能OBJ1（名称）{
this.myname=name；
}
常量数组1=[新对象J1（“名称”）]；
常量array2=array1.map（obj=>
Object.create(
Object.getPrototypeOf（obj），
Object.getOwnPropertyDescriptors（obj）
)
);
array2[0]。myname='Jack'；
console.log（array1[0].myname）；
console.log（array2[0].myname）问题出在循环和OBJ1函数中。第一次使用OBJ1\u数组时可以，但第二次使用时，其值已更改

你可以试试这个代码

function OBJ1(name, tags) {
   return {myname:name, tags:tags}
    //this.myvalue = 0;
}

function OBJ2(arg1) {
    this.arg1 = arg1;
    this.myarray = [];
}

var OBJ1_array = [];
var result_array2 = null;
var result;
OBJ1_array = createarray1();

for (i = 0; i < 2; i++) {
let tempArr = $.extend(true, [], OBJ1_array);
    result = createarray2();
OBJ1_array = tempArr;
}

function createarray1() {
    let myarray = [];
   myarray.push(new OBJ1("NAME", [1, 2, 3]));
    myarray.push(new OBJ1("others", [1, 2, 3]));
    myarray.push(new OBJ1("total", [1, 2, 3]));
    return myarray;
}

function createarray2() {
    let newarray =$.extend(true, [], OBJ1_array);// newarray should refer to a new array, not the same one as OBJ1_array

    OBJ1_array[0].myname = "CHANGED";
    console.log("categories", JSON.parse(JSON.stringify(OBJ1_array)));
    console.log("newarray", JSON.parse(JSON.stringify(newarray)));
}

功能OBJ1（名称、标签）{
返回{myname:name，tags:tags}
//this.myvalue=0；
}
函数OBJ2（arg1）{
this.arg1=arg1；
this.myarray=[]；
}
变量OBJ1_数组=[]；
var result_array2=null；
var结果；
OBJ1_数组=createarray1（）；
对于（i=0；i<2；i++）{
让tempArr=$.extend（true，[]，OBJ1_数组）；
结果=createarray2（）；
OBJ1_阵列=tempArr；
}
函数createarray1（）{
让myarray=[]；
push（新的OBJ1（“NAME”，[1,2,3]）；
push（新的OBJ1（“其他”[1,2,3]）；
push（新的OBJ1（“总计”[1,2,3]）；
返回myarray；
}
函数createarray2（）{
让newarray=$.extend（true，[]，OBJ1_数组）；//newarray应该引用一个新数组，而不是与OBJ1_数组相同的数组
OBJ1_数组[0]。myname=“已更改”；
log（“categories”，JSON.parse（JSON.stringify（OBJ1_数组））；
log（“newarray”，JSON.parse（JSON.stringify（newarray））；
}
我认为您需要对对象进行深度克隆。请使用下面的功能


函数克隆（src）{
var ret=（数组的src instanceof？[]：{}）；
for（src中的var键）
{
如果（！src.hasOwnProperty（key））{continue；}
var val=src[key]；
如果（val&&typeof（val）='object'）{val=clone（val）；}
ret[key]=val；
}
返回ret；
}
功能OBJ1（名称、标记）{
this.myname=name；
this.mytags=tags；
this.myvalue=0；
}
函数OBJ2（arg1）{
this.arg1=arg1；
this.myarray=[]；
}
变量OBJ1_数组=[]；
var result_array2=null；
var结果；
OBJ1_数组=createarray1（）；
对于（i=0；i<2；i++）{
结果=createarray2（）；
}
函数createarray1（）{
var myarray=[]；
push（新的OBJ1（“NAME”，[1,2,3]）；
push（新的OBJ1（“其他”[1,2,3]）；
push（新的OBJ1（“总计”[1,2,3]）；
返回myarray；
}
函数createarray2（）{
var newarray=clone（OBJ1_数组）；//newarray应引用新数组，而不是与OBJ1_数组相同的数组
OBJ1_数组[0]。myname=“已更改”；
log（“categories”，JSON.parse（JSON.stringify（OBJ1_数组））；
log（“newarray”，JSON.parse（JSON.stringify（newarray））；
}
文档说明如下：

未定义的属性不会被复制。但是，将复制从对象原型继承的属性属性是通过
新建MyCustomObject（args）
构造的对象，或内置JavaScript类型（如Date或RegExp）不会重新构造，并将在生成的对象或数组中显示为普通对象

这意味着包含所有普通对象的数组将被深度合并/复制。但是，使用
new
关键字创建的对象将不会重建。这给我们留下了以下场景：

数组副本工作得很好，但是由于数组中的元素是使用
new
关键字创建的，因此它们不会进一步合并。当更改数组本身（推、弹出等）时，您可以看到该数组实际上是一个副本

这里的问题是访问数组中的一个元素并更改对象（使用
new
关键字创建）。两个数组仍然指向同一个对象，因此，当从另一个数组读取包含相同对象引用的数据时，您也将看到此更改


若要解决此问题，还必须对数组中的每个对象进行排序。根据您的用例，您可以在盲目使用文档之前使用或查看文档

我还为您面临的问题创建了一个最小的示例，以便您更好地理解这个问题


//设置
var array1、array2、array3、array4；
函数虚拟（名称）{this
const newArray = myArray.map(a => Object.assign({}, a));

const newArray = myArray.map(a => ({...a}));

function OBJ1(name, tags) {
   return {myname:name, tags:tags}
    //this.myvalue = 0;
}

function OBJ2(arg1) {
    this.arg1 = arg1;
    this.myarray = [];
}

var OBJ1_array = [];
var result_array2 = null;
var result;
OBJ1_array = createarray1();

for (i = 0; i < 2; i++) {
let tempArr = $.extend(true, [], OBJ1_array);
    result = createarray2();
OBJ1_array = tempArr;
}

function createarray1() {
    let myarray = [];
   myarray.push(new OBJ1("NAME", [1, 2, 3]));
    myarray.push(new OBJ1("others", [1, 2, 3]));
    myarray.push(new OBJ1("total", [1, 2, 3]));
    return myarray;
}

function createarray2() {
    let newarray =$.extend(true, [], OBJ1_array);// newarray should refer to a new array, not the same one as OBJ1_array

    OBJ1_array[0].myname = "CHANGED";
    console.log("categories", JSON.parse(JSON.stringify(OBJ1_array)));
    console.log("newarray", JSON.parse(JSON.stringify(newarray)));
}