Javascript 如何执行我的代码以获得想要的结果

我创建了一个包含对象的数组

我在数组上循环，对于包含y==5的对象，我对该对象影响一个布尔变量，然后通过一个条件阻止访问

但是我看到下一个数组中的同一个对象受到了同一个布尔变量的影响，我的控制台日志显示该影响只会按时执行， 如何阻止对下一个数组的元素的影响

代码

  test: function(req, res){

    console.log("yesss")
    var a = {x:1}
    let b = {x:2}
    let c = {x:3}
    let d = {x:4}

    let tab1 = []
    a.y = 5
    b.y = 10
    c.y = 10
    d.y = 10
    let group1 = [a, c, d]

    let group2 = [a, b, d]


    tab1.push(group1)
    tab1.push(group2)


    let test = false
    async.each(tab1, function(group, next){

        group.forEach(function(elem){

            if(elem.y == 5 && !test)
            {
                console.log("******* executed ******")
                test = true
                elem.bool = true
            }
            console.log("elem : ", elem)

        })

        next()
    }, function(){

      return res.status(200).json({success: true, data: tab1})
    })
},

这是我的控制台日志

控制台日志

    ******* executed ******
elem :  { x: 1, y: 5, bool: true }
elem :  { x: 3, y: 10 }
elem :  { x: 4, y: 10 }
elem :  { x: 1, y: 5, bool: true }
elem :  { x: 2, y: 10 }
elem :  { x: 4, y: 10 }

JsonReturn

{
"success": true,
"data": [
    [
        {
            "x": 1,
            "y": 5,
            "bool": true
        },
        {
            "x": 3,
            "y": 10
        },
        {
            "x": 4,
            "y": 10
        }
    ],
    [
        {
            "x": 1,
            "y": 5,
            "bool": true
        },
        {
            "x": 2,
            "y": 10
        },
        {
            "x": 4,
            "y": 10
        }
    ]
]
}

---

group1

和

group2

是引用相同对象的数组，请使用

JSON.parse（）和
JSON.stringify（）复制：

group1
和
group2
是引用相同对象的数组，请使用
JSON.parse（）和
JSON.stringify（）复制：

对象是通过引用指定的，因此您需要对对象进行深度复制，否则对其中一个对象所做的更改将不可避免地改变另一个对象。在您的示例中，您可以通过简单地定义一个新变量来保存所需的数据来避免这种情况

换句话说，不是这些行：

var a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 10
let group1 = [a, c, d]

let group2 = [a, b, d]

let a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}
let e = {x:5}
let f = {x:6}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 5
e.y = 10
f.y = 10
let group1 = [a, b, c]

let group2 = [d, e, f]

您可以使用以下行：

var a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 10
let group1 = [a, c, d]

let group2 = [a, b, d]

let a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}
let e = {x:5}
let f = {x:6}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 5
e.y = 10
f.y = 10
let group1 = [a, b, c]

let group2 = [d, e, f]

然后，您将看到该行为与您预期的一样。我不确定代码的目的是什么，但我想您知道从这里开始该怎么做。
对象是通过引用分配的，因此您需要对对象进行深度复制，否则对其中一个对象所做的更改将不可避免地改变另一个对象。在您的示例中，您可以通过简单地定义一个新变量来保存所需的数据来避免这种情况

换句话说，不是这些行：

var a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 10
let group1 = [a, c, d]

let group2 = [a, b, d]

let a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}
let e = {x:5}
let f = {x:6}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 5
e.y = 10
f.y = 10
let group1 = [a, b, c]

let group2 = [d, e, f]

您可以使用以下行：

var a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 10
let group1 = [a, c, d]

let group2 = [a, b, d]

let a = {x:1}
let b = {x:2}
let c = {x:3}
let d = {x:4}
let e = {x:5}
let f = {x:6}

let tab1 = []
a.y = 5
b.y = 10
c.y = 10
d.y = 5
e.y = 10
f.y = 10
let group1 = [a, b, c]

let group2 = [d, e, f]

然后，您将看到该行为与您预期的一样。我不确定您的代码的用途是什么，但我想您会知道从这里可以走到哪里。
我尝试对引用的对象进行深度复制，结果成功了

let group1 = [Object.assign({}, a), c, d]

    let group2 = [Object.assign({}, a), b, d]

我试着对引用的对象进行深度复制，结果成功了

let group1 = [Object.assign({}, a), c, d]

    let group2 = [Object.assign({}, a), b, d]

我相信这是因为数组中的对象是引用，而您正在向两个数组添加相同的引用。尝试在添加对象时创建对象的深度副本，它应该有所不同。我相信这是因为数组中的对象是引用，而您正在向两个数组添加相同的引用。在添加对象时尝试对其进行深度复制，它应该有所不同。谢谢，是的，代码的另一个用途有此问题，所以我尝试进行深度复制谢谢，是的，代码的另一个用途有此问题，所以我尝试进行深度复制