The following code obtains all the keys from object x, removes c from the list, and then performs the comparison.

let x = { a: 5, b: 6, c: "string" };
let y = { a: 5, b: 6, c: "another string" };

console.log(
  Object.keys(x)
    .filter((key) => key !== "c")
    .every((key) => x[key] === y[key])
);

array.sort requires a comparator function. You can use the exact same thing here

function myObjComparator (x, y) {
  if (x.a != y.a) return y.a - x.a;
  return y.b - x.b;
}

Generally, I would NOT stringify objects in order to compare them. The reason is quite simple and is that you MUST to be sure that the order of the members are the same, otherwise the result won't be correct.

Ex:

// objects are equals
const y = { a: '1', b: '2' }
const x = { b: '2', b: '1' }
// but result is not what you expect
JSON.stringify(x) === JSON.stringify(y) // false

But, if you can ensure that the order of the members is always the same, stringify is fast and a good option.

You can use the spread syntax in order to avoid the "c" property

const remappedX = { ...x, c: undefined };
const remappedY = { ...y, c: undefined };
JSON.stringify(remappedX) === JSON.stringify(remappedY); // true

Or alternatively

const allowedKeys = Object.keys(x).filter((k) => k !== 'c');
JSON.stringify(x, allowedKeys) === JSON.stringify(y, allowedKeys);

More generic method is to loop over Object key or alternatively to entries

for(const key of Object.keys(x)) {
   if (key === 'c') {
      continue;
   }
   if (x[key] !== y[key]) {
         return false;
   }
}
return true;

But, if your object is nested, you need to use a deep equality algorithm, which is of course slower.

More generic answer has been given here