¿Cómo se crea una cadena para que coincida con una expresión regular?

Question

Necesito crear una documentación de formato. Conozco las expresiones regulares que se usan para formatear el texto, pero no sé cómo reproducir un ejemplo para esa expresión regular. Éste debe ser un enlace interno:

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

¿Alguien puede crear un ejemplo que se correspondería con esto, y tal vez explicar cómo lo consiguió. Me quedé atrapado en '?'.

Nunca usé este meta-carácter al principio, generalmente lo uso para marcar que un literal no puede aparecer o aparecer exactamente una vez.

Gracias

Answer 1

(?:...) tiene el mismo efecto agrupación como (...), pero sin "capturar" el contenido del grupo; ver http://php.net/manual/en/regexp.reference.subpatterns.php. Por ejemplo, (?:\#|/) significa "# o /".

Supongo que sabe que [^ ]* significa "cero o más caracteres que no son SP", y que [^]]* significa "cero o más caracteres que no son correctos-corchetes".

Juntando todo, una secuencia posible es la siguiente:

'{[/abcd asdfasefasdc]}' 

Answer 2

Ver Open source RegexBuddy alternatives y Online regex testing para algunas herramientas útiles. Es más fácil tener una expresión regular explicada por ellos primero. Solía ​​Yape aquí:

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

Esta es bajo la presunción de que { y } en su ejemplo son los regex delimiters.

Puede acaba de leer a través de la lista de explicaciones y llegar a una posible cadena de origen, tales como:

[#NOSPACE NOBRACKET] 

Answer 3

Creo que este es un buen puesto para ayudar a expresiones regulares diseño. Si bien es bastante fácil escribir un regex general para que coincida con una cadena, a veces es útil mirarlo en reversa después de
su diseño. A veces es necesario ver qué cosas de Bizzar coincidirán.

Al mezclar muchos de los metacaracteres como literales, es bastante importante formatear
este tipo para facilitar la lectura y evitar errores.

Aquí hay algunas muestras en Perl que fueron más fáciles (para mí) para el prototipo.

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

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

__END__ 

Expanded 

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

salida

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

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

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

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