Y a-t-il un sélecteur jQuery:contains insensible à la casse?

pour le rendre optionnellement insensible à la casse: http://bugs.jquery.com/ticket/278

$.extend($.expr[':'], {
  'containsi': function(elem, i, match, array)
  {
    return (elem.textContent || elem.innerText || '').toLowerCase()
    .indexOf((match[3] || "").toLowerCase()) >= 0;
  }
});

alors utiliser :containsi au lieu de :contains

à partir de jQuery 1.3, cette méthode est dépréciée. Pour obtenir que cela fonctionne, il doit être défini comme une fonction:

jQuery.expr[':'].Contains = function(a,i,m){
    return jQuery(a).text().toUpperCase().indexOf(m[3].toUpperCase())>=0;
};

si quelqu'un (comme moi) est intéressé que faire a et m[3] moyen dans contient définition.

légende: Params mis à disposition par jQuery pour utilisation dans le sélecteur définitions:

r = tableau d'éléments en cours d'examen. (eg: R. longueur = nombre de elements)

I = index de l'élément faisant actuellement l'objet d'un examen, dans la rangée r .

a = élément actuellement à l'étude. L'instruction Selector doit retourner true pour l'inclure dans ses résultats appariés.

m[2] = nom de code ou * que nous cherchons (à gauche de colon).

m[3] = param passe dans le sélecteur: (param). Typiquement un numéro d'index, comme dans : nth-of-type(5) , ou une chaîne, comme dans : couleur(Bleu) .

dans jQuery 1.8, vous devrez utiliser

jQuery.expr[":"].icontains = jQuery.expr.createPseudo(function (arg) {                                                                                                                                                                
    return function (elem) {                                                            
        return jQuery(elem).text().toUpperCase().indexOf(arg.toUpperCase()) >= 0;        
    };                                                                                  
});

une variation qui semble effectuer un peu plus rapide et que aussi permet des expressions régulières est:

jQuery.extend (
    jQuery.expr[':'].containsCI = function (a, i, m) {
        //-- faster than jQuery(a).text()
        var sText   = (a.textContent || a.innerText || "");     
        var zRegExp = new RegExp (m[3], 'i');
        return zRegExp.test (sText);
    }
);

non seulement ce cas est insensible, mais il permet des recherches puissantes comme:

• $("p:containsCI('\bup\b')") (Correspond à "Haut" ou "en haut", mais pas "supérieur", "réveil", etc.)
• $("p:containsCI('(?:Red|Blue) state')") (Correspond à "l'état rouge" ou "bleu de l'état", mais pas "d'état", etc.)
• $("p:containsCI('^\s*Stocks?')") (correspond à "stock" ou "stocks", mais seulement au début du paragraphe (sans tenir compte d'un espace principal).)

peut être en retard.... mais,

je préfère aller par là..

$.extend($.expr[":"], {
"MyCaseInsensitiveContains": function(elem, i, match, array) {
return (elem.textContent || elem.innerText || "").toLowerCase().indexOf((match[3] || "").toLowerCase()) >= 0;
}
});

de cette façon, vous ne pas trafiquer avec natif de jQuery."contient ... Vous pouvez avoir besoin d'un seul plus tard...en cas d'altération, vous pourriez vous retrouver à stackOverFlow ...

jQuery.expr[':'].contains = function(a,i,m){
    return jQuery(a).text().toUpperCase().indexOf(m[3].toUpperCase())>=0;
};

le code de mise à jour fonctionne bien en 1.3, mais" contains " devrait être en minuscules sur la première lettre contrairement à l'exemple précédent.

utiliser le code ci-dessous pour utiliser": contient "pour trouver du texte ignorant sa sensibilité à la casse à partir d'un code HTML,

 $.expr[":"].contains = $.expr.createPseudo(function(arg) {
            return function( elem ) {
                return $(elem).text().toUpperCase().indexOf(arg.toUpperCase()) >= 0;
            };
        });
        $("#searchTextBox").keypress(function() {
          if($("#searchTextBox").val().length > 0){
            $(".rows").css("display","none");
            var userSerarchField = $("#searchTextBox").val();
            $(".rows:contains('"+ userSerarchField +"')").css("display","block");
          } else {
            $(".rows").css("display","block");
          }              
        });

, Vous pouvez utiliser ce lien pour en savoir plus sur cette, utilisez jQuery pour rechercher du texte HTML et afficher ou cacher en conséquence

vous pouvez également utiliser ce lien pour trouver le code case igonring basé sur votre version jquery, marque jQuery: contient la Case insensible

j'ai eu un problème similaire avec ce qui suit ne fonctionne pas...

// This doesn't catch flac or Flac
$('div.story span.Quality:not(:contains("FLAC"))').css("background-color", 'yellow');

cela fonctionne et sans la nécessité d'une extension

$('div.story span.Quality:not([data*="flac"])').css("background-color", 'yellow');

cela fonctionne aussi, mais tombe probablement dans la catégorie" boucle manuelle"....

$('div.story span.Quality').contents().filter(function()
{
  return !/flac/i.test(this.nodeValue);
}).parent().css("background-color", 'yellow');

une version plus rapide utilisant des expressions régulières.

$.expr[':'].icontains = function(el, i, m) { // checks for substring (case insensitive)
    var search = m[3];
    if (!search) return false;

    var pattern = new RegExp(search, 'i');
    return pattern.test($(el).text());
};