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

El método transversal jQuery find (..) no incluye el nodo actual, comienza con los hijos 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 me sobresalta de inmediato.

Para jQuery 1.8 y superior, puede usar .addBack(). Se necesita un selector para que no necesite filtrar el resultado:

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

Antes de jQuery 1.8 con el que estaba atrapado .andSelf()(ahora en desuso y eliminado) que luego necesitaba filtrado:

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

No puedes hacer esto directamente, lo más cerca que puedo pensar es en usar .andSelf()y llamar .filter(), así:

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

Lamentablemente .andSelf()no lleva un selector, lo que sería útil.

Definir

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

luego usa

$.findSelf(selector);

en vez de

$find(selector);

Lamentablemente, jQuery no tiene esto 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 ().

$('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 la necesita mucho:

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

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

La respuesta aceptada es muy ineficiente y filtra el conjunto de elementos que ya coinciden.

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

Si desea que el encadenamiento funcione correctamente, use el fragmento a continuación.

$.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 complementos adicionales, estás atascado con esto.

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

En caso de que esté buscando exactamente un elemento , ya sea el elemento actual o uno dentro de él, puede usar:

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

En caso de que esté buscando múltiples elementos , puede usar:

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

El uso de andSelf/ andBackes bastante raro, no estoy seguro de por qué. Quizás por los problemas de rendimiento que algunos tipos mencionaron antes que yo.

(Ahora noté que Tgr ya dio esa segunda solución)

Sé que esta es una vieja pregunta, pero hay una forma más correcta. Si el orden es importante, por ejemplo, cuando está haciendo coincidir un selector como :first, escribí una pequeña función que devolverá exactamente el mismo resultado que si find()realmente incluyera el conjunto actual 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 va a ser eficiente de ninguna manera, pero es lo mejor que he encontrado para mantener el orden adecuado.

Creo que andSelfes lo que quieres:

obj.find(selector).andSelf()

Tenga en cuenta que esto siempre volverá a agregar el nodo actual, ya sea que coincida o no con el selector.

Si está buscando estrictamente en los nodos actuales, simplemente simplemente haga

$(html).filter('selector')

Estaba tratando de encontrar una solución que no se repita (es decir, no ingresar el mismo selector dos veces).

Y esta pequeña extensión jQuery lo hace:

jQuery.fn.findWithSelf = function(...args) {
  return this.pushStack(this.find(...args).add(this.filter(...args)));
};

Combina find()(solo descendientes) con filter()(solo conjunto actual) y admite cualquier argumento que ambos coman. El pushStack()permite .end()trabajar como se esperaba.

Usar así:

$(element).findWithSelf('.target')

Aquí está la verdad correcta (pero triste):

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

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