Comment vérifier si deux variables ont la même référence ?

Question

Comment vérifier si deux ou plusieurs objets/vars ont la même référence ?

Answer 1

Vous utilisez == ou === :

var thesame = obj1===obj2;

Du MDN :

Si les deux opérandes sont des objets, alors JavaScript compare les objets internes internes qui sont égales lorsque les opérandes font référence au même objet en mémoire.

Answer 2

Les opérateurs d'égalité et d'égalité stricte vous diront tous deux si deux variables désignent le même objet.

foo == bar
foo === bar

Answer 3

Pour les objets de type référence, \== ou \=== les opérateurs vérifient uniquement sa référence.

Par exemple

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

ici a==b sera faux car la référence des deux variables est différente bien que leur contenu soit le même.

mais si je le change en

a=b

et si je vérifie maintenant a==b alors ce sera vrai, puisque la référence des deux variables est la même maintenant.

Answer 4

A partir de ES2015 une nouvelle méthode Object.is() a été introduit et peut être utilisé pour comparer et évaluer la similitude de deux variables / références :

Vous trouverez ci-dessous quelques exemples :

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

Démonstration :

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));

Note : Cet algorithme diffère de l'algorithme de comparaison d'égalité stricte dans son traitement des zéros signés et des NaN.

Answer 5

Algorithme possible :

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;
}