Réponses:
Depuis jQuery 1.6, vous pouvez utiliser .is. Voici la réponse d'il y a plus d'un an ...
var a = $('#foo');
var b = a;
if (a.is(b)) {
// the same object!
}
Si vous voulez voir si deux variables sont réellement le même objet, par exemple:
var a = $('#foo');
var b = a;
... alors vous pouvez vérifier leurs identifiants uniques. Chaque fois que vous créez un nouvel objet jQuery, il obtient un identifiant.
if ($.data(a) == $.data(b)) {
// the same object!
}
Bien que la même chose puisse être obtenue avec un simple a === b, ce qui précède pourrait au moins montrer au prochain développeur exactement ce que vous testez.
En tout cas, ce n'est probablement pas ce que vous recherchez. Si vous souhaitez vérifier si deux objets jQuery différents contiennent le même ensemble d'éléments, vous pouvez utiliser ceci:
$.fn.equals = function(compareTo) {
if (!compareTo || this.length != compareTo.length) {
return false;
}
for (var i = 0; i < this.length; ++i) {
if (this[i] !== compareTo[i]) {
return false;
}
}
return true;
};
var a = $('p');
var b = $('p');
if (a.equals(b)) {
// same set
}
$(':first')et$('*:first')
equalsfonction semble être sensible à l'ordre. quelque chose comme stackoverflow.com/a/29648479 fonctionnerait dans plus de cas, bien que ce soit plus lent.
Si vous ne savez toujours pas, vous pouvez récupérer l'objet d'origine en:
alert($("#deviceTypeRoot")[0] == $("#deviceTypeRoot")[0]); //True
alert($("#deviceTypeRoot")[0] === $("#deviceTypeRoot")[0]);//True
car $("#deviceTypeRoot")renvoie également un tableau d'objets que le sélecteur a sélectionnés.
true, car vous comparez la référence de l'élément DOM, ==vs ===vous donneront les mêmes résultats (aucune contrainte de type nécessaire, ce ne sont que deux références d'objet)
La $.fn.equals(...)solution est probablement la plus propre et la plus élégante.
J'ai essayé quelque chose de rapide et sale comme celui-ci:
JSON.stringify(a) == JSON.stringify(b)C'est probablement cher, mais ce qui est confortable, c'est qu'il est implicitement récursif, alors que la solution élégante ne l'est pas.
Juste mes 2 cents.
{a: 1, b: 2}et {b: 2, a: 1}cela reviendra falsequand il devrait revenir true.
C'est, d'une manière générale, une mauvaise idée de comparer $ (foo) avec $ (foo) car cela est fonctionnellement équivalent à la comparaison suivante:
<html>
<head>
<script language='javascript'>
function foo(bar) {
return ({ "object": bar });
}
$ = foo;
if ( $("a") == $("a") ) {
alert ("JS engine screw-up");
}
else {
alert ("Expected result");
}
</script>
</head>
</html>
Bien sûr, vous ne vous attendriez jamais à une "erreur du moteur JS". J'utilise "$" juste pour clarifier ce que fait jQuery.
Chaque fois que vous appelez $ ("# foo"), vous faites en fait un jQuery ("# foo") qui renvoie un nouvel objet . Donc, les comparer et attendre le même objet n'est pas correct.
Cependant, ce que vous POUVEZ faire peut être quelque chose comme:
<html>
<head>
<script language='javascript'>
function foo(bar) {
return ({ "object": bar });
}
$ = foo;
if ( $("a").object == $("a").object ) {
alert ("Yep! Now it works");
}
else {
alert ("This should not happen");
}
</script>
</head>
</html>
Donc, vraiment, vous devriez peut-être comparer les éléments ID des objets jQuery dans votre programme réel, donc quelque chose comme
...
$(someIdSelector).attr("id") == $(someOtherIdSelector).attr("id")
est plus approprié.
Utilisez la méthode Underscore.js isEqual http://underscorejs.org/#isEqual
Commencez par commander votre objet en fonction de la clé en utilisant cette fonction
function sortObject(o) {
return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {});
}
Ensuite, comparez la version stringifiée de votre objet, en utilisant cette fonction
function isEqualObject(a,b){
return JSON.stringify(sortObject(a)) == JSON.stringify(sortObject(b));
}
Voici un exemple
En supposant que les clés des objets sont ordonnées différemment et ont les mêmes valeurs
var obj1 = {"hello":"hi","world":"earth"}
var obj2 = {"world":"earth","hello":"hi"}
isEqualObject(obj1,obj2);//returns true
Si vous voulez vérifier que le contenu est égal ou non, utilisez simplement JSON.stringify (obj)
Par exemple - var a = {clé: val};
var b = {clé: val};
JSON.stringify (a) == JSON.stringify (b) -----> Si le contenu est le même, vous obtenez vrai.
A.selector === B.selector && A.context === B.context. Souvent, le contexte sera toujours le même, il suffit donc de considérer le sélecteur.