Wie überprüfe ich, ob zwei Vars dieselbe Referenz haben?

Wie können Sie überprüfen, ob zwei oder mehr Objekte / Variablen dieselbe Referenz haben?

Sie verwenden ==oder ===:

var thesame = obj1===obj2;

Aus dem MDN:

Wenn beide Operanden Objekte sind, vergleicht JavaScript interne Referenzen, die gleich sind, wenn Operanden auf dasselbe Objekt im Speicher verweisen.

Die Gleichheitsoperatoren und die strengen Gleichheitsoperatoren geben an, ob zwei Variablen auf dasselbe Objekt verweisen.

foo == bar
foo === bar

Bei referenztypähnlichen Objekten überprüfen die Operatoren == oder === nur die Referenz.

z.B

let a= { text:'my text', val:'my val'}
let b= { text:'my text', val:'my val'}

hier ist a == b falsch, da die Referenz beider Variablen unterschiedlich ist, obwohl ihr Inhalt gleich ist.

aber wenn ich es ändere

a=b

und wenn ich jetzt a == b überprüfe, dann ist es wahr, da die Referenz beider Variablen jetzt gleich ist.

Ab sofort ES2015wurde eine neue Methode Object.is()eingeführt, mit der die Gleichheit zweier Variablen / Referenzen verglichen und bewertet werden kann:

Nachfolgend einige Beispiele:

Object.is('abc', 'abc');     // true
Object.is(window, window);   // true
Object.is({}, {});           // false

const foo = { p: 1 };
const bar = { p: 1 };
const baz = foo;

Object.is(foo, bar);         // false
Object.is(foo, baz);         // true

Demo:

console.log(Object.is('abc', 'abc'));
console.log(Object.is(window, window));
console.log(Object.is({}, {}));

const foo = { p: 1 };
const bar = { p: 1 };
const baz = foo;

console.log(Object.is(foo, bar));
console.log(Object.is(foo, baz));

Hinweis: Dieser Algorithmus unterscheidet sich vom Strict Equality Comparison-Algorithmus durch die Behandlung von vorzeichenbehafteten Nullen und NaNs.

Möglicher Algorithmus:

Object.prototype.equals = function(x)
{
  var p;
  for(p in this) {
      if(typeof(x[p])=='undefined') {return false;}
  }

  for(p in this) {
      if (this[p]) {
          switch(typeof(this[p])) {
              case 'object':
                  if (!this[p].equals(x[p])) { return false; } break;
              case 'function':
                  if (typeof(x[p])=='undefined' ||
                      (p != 'equals' && this[p].toString() != x[p].toString()))
                      return false;
                  break;
              default:
                  if (this[p] != x[p]) { return false; }
          }
      } else {
          if (x[p])
              return false;
      }
  }

  for(p in x) {
      if(typeof(this[p])=='undefined') {return false;}
  }

  return true;
}