Buscando el método jQuery find (..) que incluye el nodo actual

Question

El método transversal jQuery find(..) no incluye el nodo actual - comienza con los elementos secundarios del nodo actual. ¿Cuál es la mejor manera de llamar a una operación de búsqueda que incluye el nodo actual en su algoritmo de coincidencia? Mirando a través de los documentos, nada salta de inmediato hacia mí.

Answer 1

para jQuery 1.8 y arriba, puede utilizar .addBack(). Se necesita un selector de modo que no es necesario filtrar el resultado:

object.find('selector').addBack('selector') 

Antes de jQuery 1.8 a usted le toca .andSelf(), (ahora y eliminadas) que a su vez necesita de filtrado:

object.find('selector').andSelf().filter('selector') 

Answer 2

creo andSelf es lo que quiere:

obj.find(selector).andSelf() 

Tenga en cuenta que esto siempre va a volver a agregar el nodo actual, si es o no coincide con el selector.

Answer 3

No se puede hacer esto directamente, lo más cerca que puedo pensar es el uso de .andSelf() y llamando .filter(), así:

$(selector).find(oSelector).andSelf().filter(oSelector) 
//or... 
$(selector).find('*').andSelf().filter(oSelector); 

Desafortunadamente .andSelf() no toma un selector, lo que sería muy útil.

Answer 4

$('selector').find('otherSelector').add($('selector').filter('otherSelector')) 

Puede almacenar $('selector') en una variable para acelerar. Incluso puede escribir una función personalizada para esto si lo necesita mucho:

$.fn.andFind = function(expr) { 
    return this.find(expr).add(this.filter(expr)); 
}; 

$('selector').andFind('otherSelector') 

Answer 5

Sé que esta es una vieja pregunta, pero hay una manera más correcta. Si el orden es importante, por ejemplo, cuando se está a juego un selector como :first, escribí una pequeña función que devolverá el mismo resultado como si find() realidad incluido el actual conjunto de elementos:

$.fn.findAll = function(selector) { 
    var $result = $(); 

    for(var i = 0; i < this.length; i++) { 
    $result = $result.add(this.eq(i).filter(selector)); 
    $result = $result.add(this.eq(i).find(selector)); 
    } 

    return $result.filter(selector); 
}; 

No es va a ser eficiente por cualquier medio, pero es lo mejor que he encontrado para mantener el orden correcto.

Answer 6

Aquí está el derecho (pero triste) la verdad:

$(selector).parent().find(oSelector).filter($(selector).find('*')) 

http://jsfiddle.net/SergeJcqmn/MeQb8/2/

Answer 7

La respuesta aceptada es muy ineficiente y filtra el conjunto de elementos que ya están emparejados.

//find descendants that match the selector 
var $selection = $context.find(selector); 
//filter the parent/context based on the selector and add it 
$selection = $selection.add($context.filter(selector); 

Answer 8

Definir

$.fn.findSelf = function(selector) { 
    var result = this.find(selector); 
    return (this.is(selector)) ? 
     result.add(this) : result; 
}; 

a continuación, utilizar

$.findSelf(selector); 

en lugar de

$find(selector); 

Lamentablemente jQuery no tiene esta incorporado. Realmente extraño por tantos años de desarrollo.Mis controladores AJAX no se aplicaron a algunos elementos principales debido a cómo funciona .find().

Answer 9

Si desea que el encadenamiento funcione correctamente, utilice el siguiente fragmento.

$.fn.findBack = function(expr) { 
    var r = this.find(expr); 
    if (this.is(expr)) r = r.add(this); 
    return this.pushStack(r); 
}; 

Después de la llamada de la función final, devuelve el elemento #foo.

$('#foo') 
    .findBack('.red') 
     .css('color', 'red') 
    .end() 
    .removeAttr('id'); 

Sin definir los complementos adicionales, estás atascado con esto.

$('#foo') 
    .find('.red') 
     .addBack('.red') 
      .css('color', 'red') 
     .end() 
    .end() 
    .removeAttr('id'); 

Answer 10

Si está buscando estrictamente en el nodo (s) actual el que simplemente haces

$(html).filter('selector') 

Answer 11

Si estás buscando exactamente un elemento, ya sea elemento actual o uno dentro de ella , puede utilizar:

result = elem.is(selector) ? elem : elem.find(selector); 

Si estás buscando múltiples elementos que puede utilizar:

result = elem.filter(selector).add(elem.find(selector)); 

El uso de andSelf/andBack es bastante raro, no sé por qué. Tal vez debido a los problemas de rendimiento que algunos chicos mencionaron antes que yo.

(ahora se dio cuenta de que Tgr ya se dio esa segunda solución)