检查两个数组是否具有具有同一属性的对象

Question

这是我的目标：比较两个对象，并找出是否有1个或更多项目。如果有1个或更多共同点，请返回 true 否则（没有共同的项目），返回 false 。

当前问题：我尝试使用 .some（）方法，其中1个来自API的对象和1个本地对象，但有些困惑，为什么它不起作用。 ..任何想法？它应该返回true，因为John都在两个对象中，但是它返回false false

代码示例：在此示例中，它应该返回 true ，因为John是两个都是对象的名称1（结果1）和对象2（结果2）。但是，它返回 false 。

有人能帮助我了解我在这里做错了什么吗？

var result1 = [
        {id:1, name:'Sandra', type:'user', username:'sandra'},
        {id:2, name:'John', type:'admin', username:'johnny2'},
        {id:3, name:'Peter', type:'user', username:'pete'},
        {id:4, name:'Bobby', type:'user', username:'be_bob'}
    ];

var result2 = [
        {id:2, name:'John', email:'[email protected]'},
        {id:4, name:'Bobby', email:'[email protected]'}
    ];

const hasSimilarElement = result1.some((item) => item.name === result2.name); 

console.log(hasSimilarElement);

Answer 1

您可以创建一个函数，该函数将功能 f 用于查找，然后两个数组 xs ＆amp; ys ：

const checkBy = f => (xs, ys) => {
  let [long, short] = xs.length > ys.length ? [xs, ys] : [ys, xs];
  short = new Set(short.map(f));
  return long.some(x => short.has(f(x)));
};

然后：：

const checkByName = checkBy(x => x.name);

checkByName( [ {id: 1, name:'Sandra', type:  'user', username:  'sandra'}
             , {id: 2, name:  'John', type: 'admin', username: 'johnny2'}
             , {id: 3, name: 'Peter', type:  'user', username:    'pete'}
             , {id: 4, name: 'Bobby', type:  'user', username:  'be_bob'}]

           , [ {id: 2, name:  'John', email: '[email protected]'}
             , {id: 4, name: 'Bobby', email:  '[email protected]'}]);
//=> true

checkByName( [ {id: 1, name:'Sandra', type:  'user', username:  'sandra'}
             , {id: 2, name:  'John', type: 'admin', username: 'johnny2'}
             , {id: 3, name: 'Peter', type:  'user', username:    'pete'}
             , {id: 4, name: 'Bobby', type:  'user', username:  'be_bob'}]

           , [ {id: 2, name:  'xxxx', email: '[email protected]'}
             , {id: 4, name: 'yyyyy', email:  '[email protected]'}]);
//=> false

Answer 2

我将使用CustomCommander提出的技术来解决您的确切情况，并且在任何地方，您都可以从对象中提取一个唯一的键作为原始类型。 （这里 name 是字符串，因此有效。）

如果您需要更通用的东西，则可以提供一个函数，该函数告诉两个元素是否相等并这样使用：

const overlap = (equal) => (xs, ys) => 
  xs .some (x => ys .some (y => equal (x, y)))

const result1 = [{id:1, name:'Sandra', type:'user', username:'sandra'}, {id:2, name:'John', type:'admin', username:'johnny2'}, {id:3, name:'Peter', type:'user', username:'pete'}, {id:4, name:'Bobby', type:'user', username:'be_bob'}]
const result2 = [{id:2, name:'John', email:'[email protected]'}, {id:4, name:'Bobby', email:'[email protected]'}]

console .log (overlap ((x, y) => x .name == y .name) (result1, result2))

在您可以生成唯一键的情况下，这效率较低，但更通用。您甚至可以将其用于两个数组，其中两个数组具有具有不同结构的对象，例如（x，y）=＆gt; x .id == y .primarykey 。

Answer 3

array.prototype.some（）
一些（）方法测试数组中的至少一个元素是否通过提供的函数实现的测试。

在您的示例中，您正在尝试比较2个对象。您的结果为false2.名称不确定，您可能需要指定特定元素的索引，例如结果2 [0]

。您可以这样使用以下方式：

var result1 = [
        {id:1, name:'Sandra', type:'user', username:'sandra'},
        {id:2, name:'John', type:'admin', username:'johnny2'},
        {id:3, name:'Peter', type:'user', username:'pete'},
        {id:4, name:'Bobby', type:'user', username:'be_bob'}
    ];

var result2 = [
        {id:2, name:'John', email:'[email protected]'},
        {id:4, name:'Bobby', email:'[email protected]'}
    ];    
const hasSimilarElement = result2.filter((item1) => !result1.some(item2 => item1.name === item2.name ));

console.log(hasSimilarElement);

Answer 4

您的代码失败的原因是，您正在尝试在Result1数组的元素中找到 name result2.name

，但是 result2 也是一个 array ，数组没有 .name ，恰好是所有元素 .name s，以某种方式与一个匹配您正在寻找 - 这不是它的工作方式，

您需要迭代两个阵列才能寻找匹配

var result1 = [
        {id:1, name:'Sandra', type:'user', username:'sandra'},
        {id:2, name:'John', type:'admin', username:'johnny2'},
        {id:3, name:'Peter', type:'user', username:'pete'},
        {id:4, name:'Bobby', type:'user', username:'be_bob'}
    ];

var result2 = [
        {id:2, name:'John', email:'[email protected]'},
        {id:4, name:'Bobby', email:'[email protected]'}
    ];

const hasSimilarElement = result1.some((item) => result2.some(item2 => item.name === item2.name)); 

console.log(hasSimilarElement);

.as-console-wrapper { min-height: 100%!important; top: 0; }

但是，对于非常大的结果集，这是效率低下的 - 我不是“大符号专家，但我相信这将是O（N ² ） - 您可能会比较> result1.length * result.2.length

对于此简单情况，您可以从两个结果中提取 .name /code> ...如果 set 大小小于组合结果 .length s，则表示

这里有一个副本，您将每个结果迭代一次 - 如果这两套都有1000个元素，为2,000次迭代，而使用上面的幼稚方法为1,000,000

var result1 = [
        {id:1, name:'Sandra', type:'user', username:'sandra'},
        {id:2, name:'John', type:'admin', username:'johnny2'},
        {id:3, name:'Peter', type:'user', username:'pete'},
        {id:4, name:'Bobby', type:'user', username:'be_bob'}
    ];

var result2 = [
        {id:2, name:'John', email:'[email protected]'},
        {id:4, name:'Bobby', email:'[email protected]'}
    ];

const hasSimilarElement = new Set([...result1, ...result2].map(({name}) => name)).size < result1.length + result2.length
console.log(hasSimilarElement);

.as-console-wrapper { min-height: 100%!important; top: 0; }

但是，有一个幻影在其中一个结果中有一个重复的名称，这将无法按照预期的那样起作用

，每组迭代两次 - 但是，鉴于2 x 1,000长的结果，4,000次迭代仍然好于1,000,000

var result1 = [
        {id:1, name:'Sandra', type:'user', username:'sandra'},
        {id:2, name:'John', type:'admin', username:'johnny2'},
        {id:3, name:'Peter', type:'user', username:'pete'},
        {id:4, name:'Bobby', type:'user', username:'be_bob'}
    ];

var result2 = [
        {id:2, name:'John', email:'[email protected]'},
        {id:4, name:'Bobby', email:'[email protected]'}
    ];

const set1 = new Set(result1.map(({name}) => name));
const set2 = new Set(result2.map(({name}) => name));
const both = new Set([...set1, ...set2]);
const hasSimilarElement = both.size < set1.size + set2.size;

console.log(hasSimilarElement);

.as-console-wrapper { min-height: 100%!important; top: 0; }

Answer 5

从上面的评论...

“ op需要 查找 具有等价 item.name result> result 1 的物品 result> result 2 而不是直接直接比较非现有的（因此未定义） name result 2 的属性。”

。可以交换 noreflow noreferrer“> 对于另一个 再次。

const result1 = [
  { id: 1, name: 'Sandra', type: 'user', username: 'sandra' },
  { id: 2, name: 'John', type: 'admin', username: 'johnny2' },
  { id: 3, name: 'Peter', type: 'user', username: 'pete' },
  { id: 4, name: 'Bobby', type: 'user', username: 'be_bob' },
];
const result2 = [
  { id: 5, name: 'Lea', email: '[email protected]' },
  { id: 2, name: 'John', email: '[email protected]' },
];

const result3 = [
  { id: 5, name: 'Lea', email: '[email protected]' },
];
const result4 = [];

console.log(
  'similar elements within `result1` and `result2` ..?',
  result1.some(itemA =>
    result2.some(itemB => itemB.name === itemA.name)
  )
);
console.log(
  'similar elements within `result1` and `result3` ..?',
  result1.some(itemA =>
    result3.some(itemB => itemB.name === itemA.name)
  )
);
console.log(
  'similar elements within `result1` and `result4` ..?',
  result1.some(itemA =>
    result4.some(itemB => itemB.name === itemA.name)
  )
);

.as-console-wrapper { min-height: 100%!important; top: 0; }

在下一个迭代中，原因可能会带来一个普遍实现的功能，该功能允许可以自由选择属性名称。

实现函数还使摆脱两个嵌套的迭代（尽管某些原因提前退出以进行成功比较）。

这里将从较短的数组构建键（属性名称）特定值索引（单个迭代任务），其中，在迭代较长的数组时，会查找（否迭代）<<代码>键项目相似性的特定值。

function hasSimilarItemsByKey(key, arrA, arrB) {
  const [
    // the shorter array will be the base
    // for a `key` specific value index.
    lookupArray,
    // the longer array will be iterated
    // and have its item `key` specific 
    // values looked up at a value index.
    targetArray,
  ] = [
    arrA,
    arrB,
  ].sort((a, b) => a.length - b.length);

  // create the object based value index
  // (from the shorter array).
  const valueIndex = lookupArray
    .reduce((lookup, item) => {

      const value = item[key];
      lookup[value] ??= value;

      return lookup;
    }, Object.create(null));  // A `prototype`-less object. Thus,
                              // using the `in` operator is safe.
  return targetArray.some(item => item[key] in valueIndex);
}

const result1 = [
  { id: 1, name: 'Sandra', type: 'user', username: 'sandra' },
  { id: 2, name: 'John', type: 'admin', username: 'johnny2' },
  { id: 3, name: 'Peter', type: 'user', username: 'pete' },
  { id: 4, name: 'Bobby', type: 'user', username: 'be_bob' },
];
const result2 = [
  { id: 5, name: 'Lea', email: '[email protected]' },
  { id: 2, name: 'John', email: '[email protected]' },
];

const result3 = [
  // Attention,
  // A matching `id` and a non matching `name`.
  { id: 1, name: 'Lea', email: '[email protected]' },
];
const result4 = [];

console.log(
  'similar elements within `result1` and `result2`\n',
  '...by `name`..?', hasSimilarItemsByKey('name', result1, result2),
  '...by `id`..?', hasSimilarItemsByKey('id', result1, result2),
);
console.log(
  'similar elements within `result1` and `result3`\n',
  '...by `name`..?', hasSimilarItemsByKey('name', result1, result3),
  '...by `id`..?', hasSimilarItemsByKey('id', result1, result3),
);
console.log(
  'similar elements within `result1` and `result4`\n',
  '...by `name`..?', hasSimilarItemsByKey('name', result1, result4),
  '...by `id`..?', hasSimilarItemsByKey('id', result1, result4),
);

.as-console-wrapper { min-height: 100%!important; top: 0; }