Comment transformer l'expression régulière en non gourmand?

J'utilise jQuery. J'ai une chaîne avec un bloc de caractères spéciaux (début et fin). Je veux récupérer 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. Mais comment puis-je dire à jQuery de trouver plusieurs résultats lorsque vous avez deux caractères spéciaux ou plus?

Mon HTML:

<div id="container">
    <div id="textcontainer">
     Cuộc chiến pháp lý giữa [|cơ thử|nghiệm|] thị trường [|test2|đây là test lần 2|] chứng khoán [|Mỹ|day la nuoc my|] và ngân hàng đầu tư quyền lực nhất Phố Wall mới chỉ bắt đầ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ử | nghiệm |] thị trường [| test2 | đây là test lần 2 |] chứng khoán [| Mỹ | jour la nuoc my |] . Mais ce n'est pas le résultat que je veux :(. Comment obtenir [texte] pour les temps 1 et [démo] pour les temps 2?

Je viens de faire mon travail après avoir cherché des informations sur internet ^^. Je fais du code comme ça:

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

• mon résultat est: [| cơ thử | nghiệm |], [| test2 | đây là test lần 2 |] c'est vrai !. mais je ne comprends pas vraiment cela. Pouvez-vous me répondre pourquoi?

Les modificateurs de regex non gourmands sont comme leurs homologues gourmands mais avec un ?immédiatement après eux:

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

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 devrez utiliser A.*?Z(le ?rend le *"réticent", ou paresseux).

Il existe parfois de meilleures façons de le faire, par exemple,

A[^Z]*+Z

Cela utilise une classe de caractères nié et un quantificateur possessif, pour réduire le retour en arrière, et est probablement plus efficace.

Dans votre cas, l'expression régulière serait:

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

Malheureusement, regex Javascript ne prend pas en charge les quantificateurs possessifs, vous n'avez donc qu'à faire avec:

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

Voir également

• regular-expressions.info/Repetition
  • Voir: Une alternative à la paresse
    • 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éticents et possessifs sont également applicables aux {n,m}constructions à répétition finie .

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"

Je crois que ce serait comme ça

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

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