Come si crea una stringa per abbinare un'espressione regolare?

Question

Devo creare una documentazione di formattazione. Conosco le regex utilizzate per formattare il testo, ma non so come riprodurre un esempio per quella regex. Questo dovrebbe essere un collegamento interno:

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

chiunque può creare un esempio che potrebbe corrispondere a questo, e forse spiegare come l'ha avuto. Sono rimasto bloccato a "?".

Non ho mai usato questo meta-carattere all'inizio, di solito lo uso per indicare che un letterale non può apparire o apparire esattamente una volta.

Grazie

Answer 1

(?:...) ha lo stesso effetto come raggruppamento (...), ma senza "catturare" il contenuto del gruppo; vedi http://php.net/manual/en/regexp.reference.subpatterns.php.

Quindi, (?:\#|/) significa "o # o /".

Immagino che tu sappia che [^ ]* significa "zero o più caratteri che non sono SP" e che [^]]* significa "zero o più caratteri che non sono parentesi quadre".

Mettere insieme, una possibile stringa è questo:

'{[/abcd asdfasefasdc]}' 

Answer 2

Vedi Open source RegexBuddy alternatives e Online regex testing per alcuni strumenti utili. È più facile avere un'espressione regolare spiegata da loro per prima. Ho usato YAPE qui:

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 
---------------------------------------------------------------------- 
    \]      ']' 
---------------------------------------------------------------------- 

Questo è sotto la presunzione che { e } nel tuo esempio sono i regex delimiters.

Si può solo leggere l'elenco delle spiegazioni e venire con una possibile stringa di origine come ad esempio:

[#NOSPACE NOBRACKET] 

Answer 3

Credo che questo sia un buon posto per aiutare la progettazione regex. Mentre è abbastanza facile scrivere una regex generale per corrispondere a una stringa, a volte è utile guardarla al contrario dopo
suo progettato. A volte è necessario vedere quali saranno le cose bizzar.

Quando si mescolano molti metacarchi come valori letterali, è abbastanza importante formattare
di questo tipo per facilitare la lettura ed evitare errori.

Ecco alcuni esempi in Perl che sono stati più facili (per me) da prototipare.

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

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

__END__ 

Expanded 

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

uscita

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

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

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

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