Como transformar a expressão regular em não gananciosa?

Estou usando jQuery. Eu tenho uma string com um bloco de caracteres especiais (início e fim). Quero pegar o texto desse bloco de caracteres especiais. Eu usei um objeto de expressão regular para encontrar seqüências de caracteres. Mas como posso dizer ao jQuery para encontrar vários resultados quando tiver dois caracteres especiais ou mais?

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

e meu código JavaScript:

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

  alert(filterdata); 

  //end write js 
});

Meu resultado é: [| CO Qui | Nghiem |] Thị Trường [| test2 | Djay là teste LAN 2 |] Chung khoán [| Mỹ | dia la nuoc meu |] . Mas este não é o resultado que eu quero :(. Como obter [texto] para os tempos 1 e [demo] para os tempos 2?

Acabei de fazer meu trabalho depois de pesquisar informações na internet ^^. Eu faço um código como este:

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

• meu resultado é: [| cgh thử | nghiệm |], [| test2 | lây là test lần 2 |] isso está certo !. mas eu realmente não entendo isso. Você pode me responder porque?

Os modificadores de regex não gananciosos são como suas contrapartes gananciosas, mas com uma ?sequência imediata:

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

Você está certo de que a ganância é um problema:

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

Se você quiser combinar os dois A--Z, precisará usar A.*?Z(isso ?torna o *"relutante" ou preguiçoso).

Às vezes, existem maneiras melhores de fazer isso, por exemplo,

A[^Z]*+Z

Isso usa classe de caracteres negada e quantificador possessivo, para reduzir o retorno e é provável que seja mais eficiente.

No seu caso, a regex seria:

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

Infelizmente, o regex Javascript não suporta quantificador possessivo, então você apenas tem a ver com:

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

Veja também

• regular-expressions.info/Repetition
  • Veja: Uma alternativa à preguiça
    • Quantificadores possessivos
  • Comparação de sabores

Resumo rápido

*   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

Observe que os quantificadores relutantes e possessivos também são aplicáveis ​​às {n,m}construções de repetição finita .

Exemplos em 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"

Eu acredito que seria assim

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

o gno final significa global, por isso não para na primeira partida.