Jak utworzyć ciąg pasujący do wyrażenia regularnego?

Question

Potrzebuję utworzyć dokumentację formatowania. Znam wyrażeń regularnych, które są używane do sformatowania tekstu, ale nie wiem, jak odtworzyć przykład tego regex. Ten powinien być wewnętrznym Link:

'{\[((?:\#|/)[^ ]*) ([^]]*)\]}' 

Czy ktoś utworzyć przykład, że pasuje do tego, a może wyjaśnić jak dostał go. Utknąłem w "?".

Nigdy nie użyłem tego meta-znaku na początku, zwykle używam go do oznaczenia, że ​​literał nie może pojawić się lub pojawić się dokładnie raz.

Dzięki

Answer 1

(?:...) ma taki sam efekt grupowania jako (...), ale bez „przechwytywanie” zawartość grupy; patrz http://php.net/manual/en/regexp.reference.subpatterns.php.

Tak więc, (?:\#|/) oznacza "albo # lub /".

Zgaduję, że wiesz, że [^ ]* oznacza "zero lub więcej znaków, które nie są SP", i że [^]]* oznacza "zero lub więcej znaków, które nie są prawostronnymi nawiasami kwadratowymi".

Wprowadzenie go razem, jeden możliwy ciąg jest to:

'{[/abcd asdfasefasdc]}' 

Answer 2

Zobacz Open source RegexBuddy alternatives i Online regex testing za kilka pomocnych narzędzi. Najprościej jest najpierw wyjaśnić je przez wyrażenie regularne. Kiedyś YAPE tutaj:

NODE      EXPLANATION 
---------------------------------------------------------------------- 
    \[      '[' 
---------------------------------------------------------------------- 
    (      group and capture to \1: 
---------------------------------------------------------------------- 
    (?:      group, but do not capture: 
---------------------------------------------------------------------- 
     \#      '#' 
---------------------------------------------------------------------- 
    |      OR 
---------------------------------------------------------------------- 
    /      '/' 
---------------------------------------------------------------------- 
    )      end of grouping 
---------------------------------------------------------------------- 
    [^ ]*     any character except: ' ' (0 or more 
          times (matching the most amount 
          possible)) 
---------------------------------------------------------------------- 
)      end of \1 
---------------------------------------------------------------------- 
          ' ' 
---------------------------------------------------------------------- 
    (      group and capture to \2: 
---------------------------------------------------------------------- 
    [^]]*     any character except: ']' (0 or more 
          times (matching the most amount 
          possible)) 
---------------------------------------------------------------------- 
)      end of \2 
---------------------------------------------------------------------- 
    \]      ']' 
---------------------------------------------------------------------- 

Jest pod domniemania, że ​​{ i } w swoim przykładem są regex delimiters.

Wystarczy przeczytać listy wyjaśnień i wymyślić ewentualnego łańcucha źródłowego, takich jak:

[#NOSPACE NOBRACKET] 

Answer 3

myślę, że jest to dobra wiadomość, aby pomóc projektowania regex. Chociaż dość łatwo napisać ogólne wyrażenie regularne pasujące do ciągu, czasami pomocne jest spojrzenie na niego w odwrotnej kolejności po jego zaprojektowaniu. Czasami trzeba zobaczyć, jakie dziwaczne rzeczy będą pasować.

Podczas mieszania wielu metakarów w postaci literałów, jest to dość ważne, aby sformatować ten rodzaj
dla łatwego czytania i uniknięcia błędów.

Oto kilka przykładów w Perlu, które były łatwiejsze (dla mnie) do prototypowania.

my @samps = (
'{[/abcd asdfasefasdc]}', 
'{[# ]}', 
'{[# /# \/]}', 
'{[/# {[ 
    | /# {[#\/} ]}', 
, 
); 

for (@samps) { 
    if (m~{\[([#/][^ ]*) ([^]]*)\]}~) 
    { 
     print "Found: '$&'\ngrp1 = '$1'\ngrp2 = '$2'\n===========\n\n"; 
    } 
} 

__END__ 

Expanded 

\{\[ 
    (
    [#/][^ ]* 
) 
    [ ] 
    (
    [^\]]* 
) 
\]\} 

Wyjście

Found: '{[/abcd asdfasefasdc]}' 
grp1 = '/abcd' 
grp2 = 'asdfasefasdc' 
=========== 

Found: '{[# ]}' 
grp1 = '#' 
grp2 = '' 
=========== 

Found: '{[# /# \/]}' 
grp1 = '#' 
grp2 = '/# \/' 
=========== 

Found: '{[/# {[ 
     | /# {[#\/}  ]}' 
grp1 = '/#  {[ 
     |' 
grp2 = '/# {[#\/}  ' 
===========