JS 中循环读取引用类型，并直接赋值之前的数据会覆盖

如下演示的代码

let newData=[]
				for (let item of d) {
					
					if(arrdata[item.name]){
						
						for (let key in arrdata[item.name]) {
							
							for (let key2 in arrdata[item.name][key]) {
								let data1={
									selBrand:item.selBrand,
									name:item.name,
									num:item.num,
									arrkey:item.arrkey
								}
								// let data1=item //之前这样操作直接赋值，arrdata[item.name][key]有多个值的，那么她循环存储的值都会默认吧之前所有的值都改变所以只能像上面那样每个属性单独写出来
								if(arrdata[item.name][key][key2].prodcut_attr){
									data1.images=arrdata[item.name][key][key2].prodcut_attr.image
									data1.sku=arrdata[item.name][key][key2].prodcut_attr.sku
									data1.price=arrdata[item.name][key][key2].prodcut_attr.price
								}else{
									data1.images=arrdata[item.name][key][key2].product_detail.image
									data1.sku=""
									ata1.price="暂未选择"
								}
								data1.product_id=arrdata[item.name][key][key2].product_detail.product_id
								data1.num=arrdata[item.name][key][key2].num
								data1.unique=key2
								data1.mer_id=arrdata[item.name][key][key2].product_detail.merchant.mer_id
								data1.mer_name=arrdata[item.name][key][key2].product_detail.merchant.mer_name
								newData.push(data1)
							
								
							}
						}
					}else{
						console.log("添加了进来了2222",)
						let data1=item
						newData.push(data1)
					}
					
				}
				console.log("添加了***********",newData)
				let projectNew=JSON.parse(JSON.stringify(that.projectData))
				let nData=[]
				
				that.projectData.forEach((ciiten,cindex)=>{
					projectNew[cindex].data=[]
					newData.forEach((item,indedx)=>{
						if(item.arrkey==ciiten.proName){
							item.dw=ciiten.dw
							let a=ciiten
							nData.push(item)
							
							projectNew[cindex].data.push(item.mer_name)
						}else{
							
						}
					})
				})

变量对象也存在于堆内存中，但是由于变量对象有特殊职能，因此在理解时，建议仍然将其与堆内存空间区分开来

引用数据类型与堆内存空间

引用数据类型的值是保存在堆内存空间中的对象。在 JavaScript 中，不允许直接访问堆内存空间中的数据，因此不能直接操作对象那个的堆内存空间。在操作对象时，实际上是在操作对象的引用而不是实际的对象。因此，引用数据类型都是按引用访问的。这里的引用，可以理解为保存在变量对象中的一个地址，该地址与堆内存中的对象相关联。为了更好地理解变量对象与堆内存，下面用一个示例与图解配合讲解。

function foo() {
    let a1 = 10;
    let a2 = 'hello';
    let a3 = null;
    let b = {
        m: 20
    };
    let c = [1, 2, 3];
}

当我们想要访问堆内存空间中的数据类型时，实际上是通过一个引用（地址指针）来访问的。

let a = 20;
let b = a;
b = 30;

// 这时 a 的值是多少？ 20
let m = {
    a: 10,
    b: 20
}
let n = m;
n.a = 15;

// 这时 m.a 的值是多少？15

• 第一段代码中当变量对象中的数据发生复制行为时，新的变量会被分配到一个新的值。在第一段代码中，通过 let b=a 发生复制之后，虽然 a 与 b 的值都等于 20，但事它们其实已经是相互独立互不影响的值了。因此当我们们修改了 b 的值以后，a 的值并不会发生变化，
• 在第二段代码中，通过 let n = m 发生了一次复制行为。引用类型的复制同样会为新的变量自动分配一个新的值并保存在变量对象之中。但不同的是，这个新的值，仅仅只是引用类型的一个地址指针。当地址指针相同时，尽管它们相互独立，但是它们指向的具体对象实际上是同一个。因此，当修改 n 时，m 也会发生变化，这就是引用类型的特性