比较两个对象中选定属性的最佳方法是什么

Question

I need to compare properties in two objects. object2 is an array of objects and each item in the array has a lot more 'properties' than object1 so I can't do a direct object to object comparison. I only want to compare the properties that exist in object1 with those same properties in object2 (and ignore properties that don't exist in object1 ).

The following works but seems very cumbersome. (Added a sample data. Ignore that you can't itemInArray.prop1 === "" on a number :-)

var object1 =
{
  prop1: "min",
  prop2: 134,
  prop3: 121,
  prop4: 3314,
  prop5: 0
}


var object2 = [
{
    prop1: "min",
    prop2: 237,
    prop3: 563,
    prop4: 23,
    prop5: 5,
    prop6: "mrt",
    prop7: "New York",
    prop8: "usa"
},
{
    prop1: "min",
    prop2: 134,
    prop3: 121,
    prop4: 3314,
    prop5: 0,
    prop6: "mrt",
    prop7: "london",
    prop8: "uk"
  },    
{
    prop1: "min",
    prop2: 1,
    prop3: 12,
    prop4: 14,
    prop5: 2,
    prop6: "mrt",
    prop7: "Berlin",
    prop8: "Germany"      
}
];

var result = object2.filter(
    (itemInArray) =>
      object1.prop0 === itemInArray.prop0 &&
      (object1.prop1 >= itemInArray.prop1 || itemInArray.prop1 === "") &&
      (object1.prop2 <= itemInArray.prop2 || itemInArray.prop2 === "") &&
      (object1.prop3 >= itemInArray.prop3 || itemInArray.prop3 === "") &&
      (object1.prop4 <= itemInArray.prop4 || itemInArray.prop4 === "") &&
      (object1.prop5 <= itemInArray.prop5 || itemInArray.prop5 === "")
)

Answer 1

You could implement it with something like the following:

 // defining initial compare rules for numbers. // You might want to modify them depending on the possible content. const eq = (a, b) => a === b; const lte = (a, b) => a <= b; const lt = (a, b) => a < b; const gte = (a, b) => a >= b; const gt = (a, b) => a > b; const obj1 = { prop1: 1, prop2: 2 }; const obj2 = { prop1: 1, prop2: 1 }; const keyRulesPairs = { prop1: eq, // specifying the compare rule for the certain keyName prop2: gt }; function compareObjects(obj1, obj2, keyRulesPairs) { return Object.keys(keyRulesPairs).every(key => { // every for all the `&&`s. const compare = keyRulesPairs[key]; return compare(obj1[key], obj2[key]); }) } console.log(compareObjects(obj1, obj2, keyRulesPairs));

As for getting only those objects from the array which are true by your compare rules, you just need to call with filter method, like this:

const listOfObjects = [
  { prop1: 1, prop2: 1 },
  { prop1: 1, prop2: 3 }
];

const filteredObjects = listOfObjects.filter(obj2 => {
  return compareObjects(obj1, obj2, keyRulesPairs);
})

console.log(filteredObjects)

Answer 2

I'd recommend using property accessors . This way you can make your code quite generic.

View the next code sample. I will be using TypeScript so it becomes clear what types everything can be.

In a normal case:

const compare = (obj1: object, obj2: object, propertyToCompare: string): boolean => {
      return obj1['propertyToCompare'] === obj2['propertyToCompare'];
}

You can easily loop through all the properties of an object using Object.keys()

Object.keys(obj1).forEach(prop => {
      console.log(compare(obj1, obj2, prop));
});

Ofcourse in your example, you would also loop through all the objects of your array before doing the comparison. As such:

obj2.forEach(obj => { // Going through all the objects from the array of objects (obj2)
   Object.keys(obj1).forEach(prop => { // Only using the properties from obj1
         console.log(compare(obj1, obj, prop)); // Comparing obj (object in array) to obj1
   });
});