Wie macht man aus regulärem Ausdruck nicht gierig?

Ich benutze jQuery. Ich habe eine Zeichenfolge mit einem Block von Sonderzeichen (Anfang und Ende). Ich möchte den Text aus diesem Sonderzeichenblock erhalten. Ich habe ein Objekt mit regulären Ausdrücken für die Suche nach Zeichenfolgen verwendet. Aber wie kann ich jQuery anweisen, mehrere Ergebnisse zu finden, wenn zwei oder mehr Sonderzeichen vorhanden sind?

Mein 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>

und mein JavaScript-Code:

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

  alert(filterdata); 

  //end write js 
});

Mein Ergebnis ist: [| cơ thử | nghiệm |] thị trường [| test2 | đây là test lần 2 |] chứng khoán [| Mỹ | day la nuoc my |] . Aber das ist nicht das Ergebnis, das ich will :(. Wie bekomme ich [Text] für Zeit 1 und [Demo] für Zeit 2?

Ich habe gerade meine Arbeit erledigt, nachdem ich Informationen im Internet gesucht habe ^^. Ich mache Code wie folgt:

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

• Mein Ergebnis ist: [| cơ thử | nghiệm |], [| test2 | đây là test lần 2 |] das ist richtig!. aber ich verstehe das nicht wirklich. Kannst du mein Warum beantworten?

Die nicht-gierigen Regex-Modifikatoren sind wie ihre gierigen Gegenstücke, aber mit einem ?unmittelbar folgenden:

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

Sie haben Recht, dass Gier ein Problem ist:

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

Wenn Sie beide übereinstimmen möchten A--Z, müssen Sie verwenden A.*?Z(das ?macht das *"widerstrebend" oder faul).

Es gibt jedoch manchmal bessere Möglichkeiten, dies zu tun, z

A[^Z]*+Z

Dies verwendet eine negierte Zeichenklasse und einen besitzergreifenden Quantifizierer, um das Backtracking zu reduzieren, und ist wahrscheinlich effizienter.

In Ihrem Fall wäre der reguläre Ausdruck:

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

Leider unterstützt Javascript Regex keinen Possessiv-Quantifizierer, sodass Sie nur Folgendes tun müssen:

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

Siehe auch

• reguläre-Ausdrücke.info/Wiederholung
  • Siehe: Eine Alternative zur Faulheit
    • Possessive Quantifizierer
  • Geschmacksvergleich

Kurze Zusammenfassung

*   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

Es ist zu beachten, dass die widerstrebenden und besitzergreifenden Quantifizierer auch auf die {n,m}Konstrukte mit endlicher Wiederholung anwendbar sind .

Beispiele in 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"

Ich glaube, das wäre so

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

Das gam Ende bedeutet global, also hört es nicht beim ersten Spiel auf.