Proste pytanie regularne. Mam ciąg w następującym formacie:

this is a [sample] string with [some] special words. [another one]

Jakie jest wyrażenie regularne do wyodrębnienia słów w nawiasach kwadratowych, tj.

sample
some
another one

Uwaga: W moim przypadku nie można zagnieżdżać nawiasów.

Możesz użyć następujących wyrażeń regularnych globalnie :

\[(.*?)\]

Wyjaśnienie:

• \[ : [jest meta char i należy go unikać, jeśli chcesz dosłownie go dopasować.
• (.*?) : dopasuj wszystko w niechciany sposób i złap je.
• \]: ]jest meta char i należy go unikać, jeśli chcesz dosłownie go dopasować.

(?<=\[).+?(?=\])

Przechwytuje zawartość bez nawiasów

• (?<=\[) - pozytywne spojrzenie za [

• .*? - niechciane dopasowanie treści

• (?=\]) - pozytywne spojrzenie w przyszłość ]

EDYCJA: dla nawiasów zagnieżdżonych poniższe wyrażenie regularne powinno działać:

(\[(?:\[??[^\[]*?\]))

To powinno zadziałać ok:

\[([^]]+)\]

Czy można zagnieżdżać nawiasy?

Jeśli nie: \[([^]]+)\]pasuje do jednego elementu, w tym nawiasów kwadratowych. Odsyłacz wsteczny \1będzie zawierał element do dopasowania. Jeśli Twój smak regularny obsługuje wygląd, użyj

(?<=\[)[^]]+(?=\])

To będzie pasować tylko do elementu w nawiasach.

Jeśli nie chcesz uwzględniać nawiasów w dopasowaniu, oto regex: (?<=\[).*?(?=\])

Rozwalmy to

.Dopasowuje dowolny znak z wyjątkiem terminatory linii. To ?=jest pozytywne spojrzenie w przyszłość . Pozytywny lookahead znajduje ciąg, gdy określony ciąg następuje po nim. ?<=Jest pozytywny lookbehind . Pozytywne spojrzenie znajduje ciąg, gdy określony ciąg poprzedza. Cytując to ,

Patrz w przyszłość pozytywnie (? =)

Znajdź wyrażenie A, po którym następuje wyrażenie B:

A(?=B)

Spójrz za pozytywne (? <=)

Znajdź wyrażenie A, w którym wyrażenie B poprzedza:

(?<=B)A

Alternatywa

Jeśli Twój silnik wyrażeń regularnych nie obsługuje funkcji lookaheads i lookbehinds, możesz użyć wyrażenia regularnego \[(.*?)\]do przechwycenia wewnętrznych elementów nawiasów w grupie, a następnie możesz w razie potrzeby manipulować grupą.

Jak działa ten regex?

Nawiasy przechwytują znaki w grupie. .*?Dostaje wszystkie znaki w nawiasach (za wyjątkiem linii terminatorów, chyba że masz sflagi włączone) w sposób, który nie jest chciwy.

(?<=\[).*?(?=\])działa dobrze, zgodnie z wyjaśnieniem podanym powyżej. Oto przykład w języku Python:

import re 
str = "Pagination.go('formPagination_bottom',2,'Page',true,'1',null,'2013')"
re.search('(?<=\[).*?(?=\])', str).group()
"'formPagination_bottom',2,'Page',true,'1',null,'2013'"

Na wszelki wypadek możesz mieć niewyważone nawiasy kwadratowe , prawdopodobnie możesz zaprojektować wyrażenie z rekurencją podobną do,

\[(([^\]\[]+)|(?R))*+\]

który oczywiście odnosi się do języka lub silnika RegEx, którego możesz używać.

Demo RegEx 1

Inne niż to,

\[([^\]\[\r\n]*)\]

RegEx Demo 2

lub,

(?<=\[)[^\]\[\r\n]*(?=\])

RegEx Demo 3

to dobre opcje do zwiedzania.

Jeśli chcesz uprościć / zmodyfikować / zbadać wyrażenie, zostało to wyjaśnione w prawym górnym panelu strony regex101.com . Jeśli chcesz, możesz również obejrzeć w tym linku , jak będzie pasował do niektórych przykładowych danych wejściowych.

RegEx Circuit

jex.im wizualizuje wyrażenia regularne:

Test

const regex = /\[([^\]\[\r\n]*)\]/gm;
const str = `This is a [sample] string with [some] special words. [another one]
This is a [sample string with [some special words. [another one
This is a [sample[sample]] string with [[some][some]] special words. [[another one]]`;
let m;

while ((m = regex.exec(str)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (m.index === regex.lastIndex) {
        regex.lastIndex++;
    }
    
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Źródło

Wyrażenie regularne pasujące do zrównoważonych nawiasów

jeśli chcesz wstawić tylko małą literę alfabetu między nawias kwadratowy az

(\[[a-z]*\])

jeśli chcesz małe i wielkie litery a-zA-Z

(\[[a-zA-Z]*\]) 

jeśli chcesz małe litery i cyfrę a-zA-Z0-9

(\[[a-zA-Z0-9]*\]) 

jeśli chcesz wszystko między nawiasami kwadratowymi

jeśli chcesz tekst, liczbę i symbole

(\[.*\])

([[][a-z \s]+[]])

Powyższe powinno działać z poniższym wyjaśnieniem

• znaki w nawiasach kwadratowych [] definiują klasę characte, co oznacza, że ​​wzór powinien pasować co najmniej jeden znak wymieniony w nawiasach kwadratowych

• \ s określa spację

•  + oznacza przynajmniej jedną ze wspomnianych wcześniej postaci +.

Ten kod wyodrębni zawartość między nawiasami kwadratowymi a nawiasami

(?:(?<=\().+?(?=\))|(?<=\[).+?(?=\]))

(?: non capturing group
(?<=\().+?(?=\)) positive lookbehind and lookahead to extract the text between parentheses
| or
(?<=\[).+?(?=\]) positive lookbehind and lookahead to extract the text between square brackets

W R spróbuj:

x <- 'foo[bar]baz'
str_replace(x, ".*?\\[(.*?)\\].*", "\\1")
[1] "bar"

Potrzebowałem, łącznie z nowymi wierszami i nawiasami klamrowymi

\[[\s\S]+\]

Aby dopasować podciąg między pierwszym [ a ostatnim ] , możesz użyć

\[.*\]            # Including open/close brackets
\[(.*)\]          # Excluding open/close brackets (using a capturing group)
(?<=\[).*(?=\])   # Excluding open/close brackets (using lookarounds)

Zobacz prezentację wyrażenia regularnego i prezentację wyrażenia regularnego # 2 .

Użyj następujących wyrażeń, aby dopasować ciągi znaków między najbliższymi nawiasami kwadratowymi :

• W tym nawiasy:

  • \[[^][]*]- PCRE, Python re/regex , .NET, Golang, POSIX (grep, sed, bash)
  • \[[^\][]*]- ECMAScript (JavaScript, C ++ std::regex, VBA RegExp)
  • \[[^\]\[]*] - Wyrażenie regularne Java
  • \[[^\]\[]*\] - Onigmo (Ruby, wymaga ucieczki nawiasów wszędzie)

• Z wyłączeniem nawiasów:

  • (?<=\[)[^][]*(?=])- PCRE, Python re/ regex, .NET (C # itp.), ICU (R stringr), oprogramowanie JGSoft
  • \[([^][]*)]- Bash , Golang - przechwyć zawartość między nawiasami kwadratowymi za pomocą pary nieokreślonych nawiasów, patrz także poniżej
  • \[([^\][]*)]- JavaScript , C ++std::regex , VBARegExp
  • (?<=\[)[^\]\[]*(?=]) - Wyrażenie regularne Java
  • (?<=\[)[^\]\[]*(?=\]) - Onigmo (Ruby, wymaga ucieczki nawiasów wszędzie)

UWAGA : *pasuje do 0 lub więcej znaków, użyj+ aby dopasować 1 lub więcej znaków, aby uniknąć dopasowania pustych ciągów w wynikowej liście / tablicy.

Ilekroć dostępne jest oba wsparcie wyszukiwania, powyższe rozwiązania polegają na nich, aby wykluczyć nawias otwierający / zamykający prowadzący / kończący. W przeciwnym razie polegaj na przechwytywaniu grup (udostępniono łącza do najpopularniejszych rozwiązań w niektórych językach).

Jeśli potrzebujesz dopasować zagnieżdżone nawiasy , możesz zobaczyć rozwiązania w wyrażeniu Regular, aby dopasować zrównoważony nawias nić i zastąpić okrągłe nawiasy kwadratowe, aby uzyskać niezbędną funkcjonalność. Należy użyć grup przechwytywania, aby uzyskać dostęp do zawartości z wyłączeniem nawiasów otwierających / zamykających:

• \[((?:[^][]++|(?R))*)]- PHP PCRE
• \[((?>[^][]+|(?<o>)\[|(?<-o>]))*)]- Demo .NET
• \[(?:[^\]\[]++|(\g<0>))*\]- Demo Onigmo (Ruby)