Comment rendre une expression régulière non gourmande ?

Question

J'utilise jQuery. J'ai une chaîne de caractères avec un bloc de caractères spéciaux (début et fin). Je veux obtenir le texte de ce bloc de caractères spéciaux. J'ai utilisé un objet d'expression régulière pour la recherche dans la chaîne de caractères. Mais comment puis-je dire à jQuery de trouver plusieurs résultats lorsqu'il y a deux caractères spéciaux ou plus ?

Mon HTML :

<div id="container">
    <div id="textcontainer">
     Cuc chin pháp lý gia [|c th|nghim|] th trng [|test2|ây là test ln 2|] chng khoán [|M|day la nuoc my|] và ngân hàng u t quyn lc nht Ph Wall mi ch bt u.
    </div>
</div>

et mon code JavaScript :

$(document).ready(function() {
  var takedata = $("#textcontainer").text();
  var test = 'abcd adddb';
  var filterdata = takedata.match(/(\[.+\])/);

  alert(filterdata); 

  //end write js 
});

Mon résultat est : [|c th|nghim|] th trng [|test2|ây là test ln 2|] chng khoán [|M|day la nuoc my|] . Mais ce n'est pas le résultat que je souhaite :(. Comment obtenir [text] pour le temps 1 et [demo] pour le temps 2 ?

---

Je viens de faire mon travail après avoir cherché des infos sur internet ^^. Je fais un code comme ceci :

var filterdata = takedata.match(/(\[.*?\])/g);

• mon résultat est : [|c th|nghim|], [|test2|ây là test ln 2|] C'est vrai ! mais je ne comprends pas vraiment. Pouvez-vous répondre à mon pourquoi ?

Answer 1

Les modificateurs de regex non-greedy sont comme leurs homologues greedy, mais avec une option ? qui les suivent immédiatement :

*  - zero or more
*? - zero or more (non-greedy)
+  - one or more
+? - one or more (non-greedy)
?  - zero or one
?? - zero or one (non-greedy)

Answer 2

Vous avez raison de dire que la cupidité est un problème :

--A--Z--A--Z--
  ^^^^^^^^^^
     A.*Z

Si vous voulez faire correspondre les deux A--Z vous devez utiliser A.*?Z (le ? fait le * "réticent", ou paresseux).

Cependant, il existe parfois de meilleures façons de procéder, par exemple

A[^Z]*+Z

Cette méthode utilise la classe de caractères négateurs et le quantificateur possessif, afin de réduire le retour en arrière, et est probablement plus efficace.

Dans votre cas, le regex serait :

/(\[[^\]]++\])/

Malheureusement Le regex Javascript ne supporte pas le quantificateur possessif, donc il faut faire avec :

/(\[[^\]]+\])/

Voir aussi

• regular-expressions.info/Répétition
  • Voir : Une alternative à la paresse
    • Les quantificateurs possessifs
  • Comparaison des saveurs

---

Résumé rapide

*   Zero or more, greedy
*?  Zero or more, reluctant
*+  Zero or more, possessive

+   One or more, greedy
+?  One or more, reluctant
++  One or more, possessive

?   Zero or one, greedy
??  Zero or one, reluctant
?+  Zero or one, possessive

Notez que les quantificateurs réticent et possessif sont également applicables à la répétition finie. {n,m} les constructions.

Exemples en Java :

System.out.println("aAoZbAoZc".replaceAll("A.*Z", "!"));  // prints "a!c"
System.out.println("aAoZbAoZc".replaceAll("A.*?Z", "!")); // prints "a!b!c"

System.out.println("xxxxxx".replaceAll("x{3,5}", "Y"));  // prints "Yx"
System.out.println("xxxxxx".replaceAll("x{3,5}?", "Y")); // prints "YY"

Answer 3

Je crois que ce serait comme ceci

takedata.match(/(\[.+\])/g);

le site g à la fin signifie global, donc il ne s'arrête pas au premier match.