JS 怎么判断一个数组中的对象的某个属性的值是否在另一个数组的对象的属性

的值中存在呢？

可以使用数组的 `some()` 方法和对象的 `includes()` 方法来判断。

示例代码：

const arr1 = [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}];
const arr2 = [{id: 2, age: 20}, {id: 4, age: 30}];

const isExist = arr1.some(obj1 => arr2.some(obj2 => obj2.id === obj1.id && obj2.age === 20));

console.log(isExist); // true

解释：

首先，使用数组的 `some()` 方法遍历数组 `arr1` 中的每个对象 `obj1`，判断是否存在一个对象 `obj2`，满足 `obj2.id === obj1.id && obj2.age === 20`。

如果存在这样的对象 `obj2`，则返回 `true`，表示在数组 `arr2` 中存在一个对象的 `id` 属性和 `arr1` 中的某个对象的 `id` 属性相等，且 `age` 属性等于 20。

如果不存在这样的对象 `obj2`，则继续遍历数组 `arr1` 中的下一个对象 `obj1`，直到遍历完整个数组 `arr1`。

最终，如果存在满足条件的对象 `obj2`，则返回 `true`，否则返回 `false`。

相关问题

JS 怎么判断一个数组中的对象的某个属性的值是否在另一个数组的对象的属性 并且删除 对象

可以使用数组的filter方法来过滤不符合条件的对象，再使用forEach方法遍历需要删除的对象并使用splice方法删除。

例如，假设有两个数组arr1和arr2，arr1中的对象有属性id，arr2中的对象有属性parentId，需要判断arr1中的对象的id是否在arr2中的对象的parentId中，如果是则删除该对象。

代码实现如下：

var arr1 = [
  { id: 1, name: 'obj1' },
  { id: 2, name: 'obj2' },
  { id: 3, name: 'obj3' },
  { id: 4, name: 'obj4' }
];

var arr2 = [
  { parentId: 1, content: 'content1' },
  { parentId: 2, content: 'content2' },
  { parentId: 4, content: 'content4' }
];

arr1 = arr1.filter(function(item) {
  // 如果arr2中有parentId等于item.id的对象，则删除该对象
  var hasItem = arr2.some(function(item2) {
    return item2.parentId === item.id;
  });
  return !hasItem;
});

arr2.forEach(function(item, index) {
  // 如果arr1中有id等于item.parentId的对象，则删除该对象
  var hasItem = arr1.some(function(item1) {
    return item1.id === item.parentId;
  });
  if (hasItem) {
    arr2.splice(index, 1);
  }
});

console.log(arr1); // [{ id: 3, name: 'obj3' }]
console.log(arr2); // [{ parentId: 2, content: 'content2' }]

JS 数组对象中某个属性值相同归类成一个数组

可以使用 Array.prototype.reduce() 方法来实现这个功能。具体步骤如下：

1. 遍历数组，对于每个元素，获取需要归类的属性值。
2. 在 reduce() 方法中创建一个对象，用于保存归类后的结果。
3. 对于每个元素，检查对象中是否已经存在该属性值对应的数组，如果不存在，则创建一个新数组，并将该元素添加到数组中；如果已经存在，则将该元素添加到对应的数组中。
4. 最后，将对象中的值转换为数组，即可得到归类后的结果。

下面是一个示例代码：

const arr = [
  { name: 'apple', type: 'fruit' },
  { name: 'banana', type: 'fruit' },
  { name: 'carrot', type: 'vegetable' },
  { name: 'orange', type: 'fruit' },
  { name: 'broccoli', type: 'vegetable' },
  { name: 'pear', type: 'fruit' },
  { name: 'tomato', type: 'vegetable' },
  { name: 'pepper', type: 'vegetable' },
  { name: 'grape', type: 'fruit' },
  { name: 'potato', type: 'vegetable' },
];

const result = arr.reduce((obj, item) => {
  if (obj[item.type]) {
    obj[item.type].push(item);
  } else {
    obj[item.type] = [item];
  }
  return obj;
}, {});

console.log(result);

输出结果为：

{
  fruit: [
    { name: 'apple', type: 'fruit' },
    { name: 'banana', type: 'fruit' },
    { name: 'orange', type: 'fruit' },
    { name: 'pear', type: 'fruit' },
    { name: 'grape', type: 'fruit' }
  ],
  vegetable: [
    { name: 'carrot', type: 'vegetable' },
    { name: 'broccoli', type: 'vegetable' },
    { name: 'tomato', type: 'vegetable' },
    { name: 'pepper', type: 'vegetable' },
    { name: 'potato', type: 'vegetable' }
  ]
}

在这个示例中，我们将 `arr` 数组中的元素按照 `type` 属性进行归类，得到一个包含 `fruit` 和 `vegetable` 两个属性的对象。每个属性对应一个数组，包含相同 `type` 属性值的元素。