Come faccio a verificare se 2 selettori jQuery puntano agli stessi elementi?

Question

se provo qualcosa come questo:

$(".foo") === $(".foo") // = false 

... ottengo falso. Se invece provo questa query,

$(".foo").get(0) === $(".foo").get(0) // = true 

... Divento vero.

Questo perché:

{a:myObject} !== {a:myObject}; 
[myObject] !== [myObject]; 
myObject  === myObject; 

mi chiedo se non v'è alcun modo succinto per verificare questa uguaglianza, preferibilmente integrato in jQuery. Il secondo metodo che ho scritto funziona correttamente solo se al massimo c'è un elemento che corrisponde a .foo. La soluzione dovrebbe funzionare per qualsiasi quantità di elementi.

Ovviamente non voglio solo controllare ".foo" === ".foo" poiché le selezioni effettive che sto usando sono più complicate. Li ho semplicemente semplificati per questo esempio. (Ad esempio mi può essere utile per controllare che $(this) sta selezionando la stessa cosa di $(".foo").)

Answer 1

Non c'è nulla nella libreria di base per verificare l'uguaglianza sequenza di oggetti jQuery, ma il seguente dovrebbe fare il trucco:

$.fn.sequenceEqual = function(compareTo) { 
    if (!compareTo || !compareTo.length || this.length !== compareTo.length) { 
    return false; 
    } 
    for (var i = 0, length = this.length; i < length; i++) { 
    if (this[i] !== compareTo[i]) { 
     return false; 
    } 
    } 
    return true; 
} 

che sarebbe utilizzabile in questo modo:

$(".foo").sequenceEqual($(".bar")) 

Per completezza, un contenuto metodo di pari può essere scritto in questo modo:

$.fn.contentsEqual = function(compareTo) { 
    return compareTo && this.length === compareTo.length && this.length === this.filter(compareTo).length; 
} 

Quale sarebbe utilizzabile in questo modo:

$(".foo").contentsEqual($(".bar")) 

Answer 2

Ok, utilizzando solo comandi incorporati jQuery, questo sembra essere quella giusta

$(oneSelector).filter($(anotherSelector)).length == 1 

if ($ (oneSelector) .is ($ (anotherSelector))) ... sono uguali

Answer 3

Se si desidera verificare se entrambi i set contengono esattamente lo stesso eleme nti (possibilmente in un ordine diverso), quindi Array#every in combinazione con $.fn.index potrebbe fare il lavoro:

var $this = $("p"), 
    $other = $("p"); 


// same length and $other contains each element of $this 

var equal = $this.length === $other.length 
       && Array.prototype.every.call($this, function(elem) { 
        return $other.index(elem) > -1; 
       }); 

Answer 4

Penso che si sta cercando $().is. Docs here.

var foo, bar; 

foo = $('foo'); 
bar = $('.bar'); 

// This will check to see foo and bar contain the same elements 
foo.is(bar); // true | false 

Edit: @lolwut fornito un jsfiddle per questa risposta. Dopo aver letto i commenti, l'ho aggiornato e ho stabilito che questa risposta non è affidabile per il caso dell'OP.

Answer 5

In alternativa alla risposta di pimvdb (che è molto bella, la sto fornendo solo per completezza), è possibile sfruttare il fatto che add() non aggiungerà elementi già presenti nell'oggetto jQuery.Pertanto, è possibile scrivere:

$.fn.containsSameElements = function(other) { 
    var len = this.length; 
    return other.length == len && this.add(other).length == len; 
};