Javascript 如何比较两个数组并合并它们/覆盖并仅提取相关数据

我有以下数据：

arrayA

 [3 , 4]

阵列b

[
  {
    id: 1,
    user: {
      id: 1,
      username: 'John'
    }
  },
  {
    id: 3,
    user: {
      id: 3,
      username: 'Mary'
    }
  },
  {
    id: 4,
    user: {
      id: 4,
      username: 'Dog'
    }
  }
]

我希望得到结果数组

['Mary' , 'Dog']

---

您可以遍历

arrayB

，查看

id

是否在

arrayA

中，如果是，则获取用户名值

见下文：

const arrayA=[3,4]
常数arrayB=[{
id:1，
用户：{
id:1，
用户名：“John”
}
},
{
id:3，
用户：{
id:3，
用户名：“玛丽”
}
},
{
id:4，
用户：{
id:4，
用户名：“狗”
}
}
]
//通过数组查看该id是否包含在arrayA中
//如果是这样，请获取用户名，因为如果不在，映射将返回false
//arrayA是一个简单的布尔过滤器，它可以去除结果数组中的任何false
const usernames=arrayB.map（i=>arrayA.includes（i.id）和&i.user.username）.filter（布尔）；
console.log（用户名）

您可以遍历

arrayB

并查看

id

是否在

arrayA

中，如果是，则获取用户名值

见下文：

const arrayA=[3,4]
常数arrayB=[{
id:1，
用户：{
id:1，
用户名：“John”
}
},
{
id:3，
用户：{
id:3，
用户名：“玛丽”
}
},
{
id:4，
用户：{
id:4，
用户名：“狗”
}
}
]
//通过数组查看该id是否包含在arrayA中
//如果是这样，请获取用户名，因为如果不在，映射将返回false
//arrayA是一个简单的布尔过滤器，它可以去除结果数组中的任何false
const usernames=arrayB.map（i=>arrayA.includes（i.id）和&i.user.username）.filter（布尔）；
console.log（用户名）

根据

arrayA

获取用户名

• 第一个

  arrayB

  基于

  arrayA

• 用于从

  user

  对象获取所有

  用户名的值

var arrA=[3,4] var arrB=[{id:1，用户：{id:1，用户名：'John'}}， {id:3，用户：{id:3，用户名：'Mary'}， {id:4，用户：{id:4，用户名：'Dog'}] var result=arrB.filter（x=>arrA.includes（x.id））//按id筛选 .map（y=>y.user.username）//选择user.username

---

console.log（结果）根据

arrayA

获取用户名

• 第一个

  arrayB

  基于

  arrayA

• 用于从

  user

  对象获取所有

  用户名的值

var arrA=[3,4] var arrB=[{id:1，用户：{id:1，用户名：'John'}}， {id:3，用户：{id:3，用户名：'Mary'}， {id:4，用户：{id:4，用户名：'Dog'}] var result=arrB.filter（x=>arrA.includes（x.id））//按id筛选 .map（y=>y.user.username）//选择user.username

---

console.log（result）您可以

过滤
匹配
id
的对象，然后
映射到用户名


var arr1=[3,4]；
var arr2=[
{
id:1，
用户：{
id:1，
用户名：“John”
}
},
{
id:3，
用户：{
id:3，
用户名：“玛丽”
}
},
{
id:4，
用户：{
id:4，
用户名：“狗”
}
}
];
var name=arr2.filter（x=>arr1.includes（x.id））
.map（y=>y.user.username）；
console.log（名称）
您可以
过滤
匹配
id
的对象，然后
映射到用户名


var arr1=[3,4]；
var arr2=[
{
id:1，
用户：{
id:1，
用户名：“John”
}
},
{
id:3，
用户：{
id:3，
用户名：“玛丽”
}
},
{
id:4，
用户：{
id:4，
用户名：“狗”
}
}
];
var name=arr2.filter（x=>arr1.includes（x.id））
.map（y=>y.user.username）；
console.log（名称）您可以编写一个函数，在数组的相关元素（arrayA-element，arrayB-element的id）匹配时，循环遍历数组并将相关值推送到新数组

extract（arrayA，arrayB）=>{
设resultar=[]；
对于（设i=0；i），您可以编写一个函数，每当数组的相关元素（arrayA-element，arrayB-element的id）匹配时，循环遍历数组并将相关值推送到新数组

extract（arrayA，arrayB）=>{
设resultar=[]；
对于（设i=0；i），这里可以使用reducer函数。它将迭代数组的每个元素，生成一个满足所需条件的输出数组。
使用
reduce（）
方法，这可以在单个数组迭代中完成

条件：要在id数组中检查的id

const ids = [3 , 4]
const arr = [{id:1, user: {id:1 , username:'John'} },
{id:3, user: {id:3 , username:'Mary'} },
{id:4, user: {id:4 , username:'Dog'} }]

const val = arr.reduce((acc, currentVal) => {
    const {id, user: { username } = {} } = currentVal
    if (ids.indexOf(id) > -1) {
        acc.push(username)
    }
    return acc
}, [])

这里可以使用reducer函数，它将迭代数组的每个元素，生成一个满足所需条件的输出数组。
使用
reduce（）
方法，这可以在单个数组迭代中完成

条件：要在id数组中检查的id

const ids = [3 , 4]
const arr = [{id:1, user: {id:1 , username:'John'} },
{id:3, user: {id:3 , username:'Mary'} },
{id:4, user: {id:4 , username:'Dog'} }]

const val = arr.reduce((acc, currentVal) => {
    const {id, user: { username } = {} } = currentVal
    if (ids.indexOf(id) > -1) {
        acc.push(username)
    }
    return acc
}, [])

我更喜欢reduce，因为你们可以在一个循环中完成所有的事情，而且结果可读性很强


const arrayA=[3,4]；
常数arrayB=[{
id:1，
用户：{
id:1，
用户名：“John”
}
},
{
id:3，
用户：{
id:3，
用户名：“玛丽”
}
},
{
id:4，
用户：{
id:4，
用户名：“狗”
}
}
];
const reducer=（acc，x）=>arrayA.includes（x.id）？[…acc，x.user.username]：acc；
const result=arrayB.reduce（reducer，[]）；
log（{result}）；
我更喜欢reduce，因为您可以在1个循环中完成所有操作。而且结果可读性很强


const arrayA=[3,4]；
常数arrayB=[{
id:1，
用户：{
id:1，
用户名：“John”
}
},
{
id:3，
用户：{
id:3，
用户名：“玛丽”
}
},
{
id:4，
用户：{
id:4，
用户名：“狗”
}
}
];
C