Pregunta simple de expresiones regulares. Tengo una cadena en el siguiente formato:

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

¿Cuál es la expresión regular para extraer las palabras entre corchetes, es decir.

sample
some
another one

Nota: en mi caso de uso, los corchetes no se pueden anidar.

Puede usar la siguiente expresión regular globalmente :

\[(.*?)\]

Explicación:

• \[: [es un meta char y necesita ser escapado si quiere hacer coincidirlo literalmente.
• (.*?) : combina todo de una manera no codiciosa y captúralo.
• \]: ]es un meta char y necesita ser escapado si quiere hacer coincidirlo literalmente.

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

Capturará contenido sin corchetes

• (?<=\[) - mirada positiva hacia atrás para [

• .*? - coincidencia no codiciosa para el contenido

• (?=\]) - anticipación positiva para ]

EDITAR: para corchetes anidados, la expresión regular a continuación debería funcionar:

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

Esto debería funcionar bien:

\[([^]]+)\]

¿Se pueden anidar paréntesis?

Si no: \[([^]]+)\]coincide con un elemento, incluidos los corchetes. La referencia inversa \1contendrá el elemento que se corresponderá. Si su sabor regex es compatible con la búsqueda, use

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

Esto solo coincidirá con el elemento entre paréntesis.

Si no desea incluir los corchetes en el partido, aquí está la expresión regular: (?<=\[).*?(?=\])

Vamos a descomponerlo

La .coincide con cualquier carácter excepto para las terminaciones de línea. El ?=es un lookahead positivo . Una búsqueda anticipada positiva encuentra una cadena cuando una determinada cadena viene después de ella. El ?<=es una mirada positiva hacia atrás . Una mirada hacia atrás positiva encuentra una cadena cuando cierta cadena la precede. Para citar esto ,

Mira hacia adelante positivo (? =)

Encuentre la expresión A donde sigue la expresión B:

A(?=B)

Mire hacia atrás positivo (? <=)

Encuentre la expresión A donde la expresión B precede:

(?<=B)A

La alternativa

Si su motor regex no es compatible con lookaheads y lookbehinds, puede usar la expresión regular \[(.*?)\]para capturar las entrañas de los corchetes en un grupo y luego puede manipular el grupo según sea necesario.

¿Cómo funciona esta expresión regular?

Los paréntesis capturan los personajes en un grupo. La .*?obtiene todos los caracteres entre los corchetes (excepto para las terminaciones de línea, a menos que tenga el sindicador de habilitación) de una manera que no es codicioso.

(?<=\[).*?(?=\])funciona bien según la explicación dada anteriormente. Aquí hay un ejemplo de 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'"

Por si acaso, es posible que haya tenido corchetes desequilibrados , es probable que pueda diseñar alguna expresión con recursión similar a,

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

que, por supuesto, se relacionaría con el idioma o el motor RegEx que podría estar utilizando.

Demo de RegEx 1

Aparte de eso,

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

RegEx Demo 2

o,

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

RegEx Demo 3

Son buenas opciones para explorar.

Si desea simplificar / modificar / explorar la expresión, se explica en el panel superior derecho de regex101.com . Si lo desea, también puede ver en este enlace cómo coincidiría con algunas entradas de muestra.

Circuito RegEx

jex.im visualiza expresiones regulares:

Prueba

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}`);
    });
}

Fuente

Expresión regular para que coincida con paréntesis equilibrados

si desea relleno solo una pequeña letra del alfabeto entre corchetes az

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

si quieres letras pequeñas y mayúsculas a-zA-Z

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

si quiere letras mayúsculas y minúsculas a-zA-Z0-9

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

si quieres todo entre corchetes

si quieres texto, número y símbolos

(\[.*\])

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

Lo anterior debería funcionar dada la siguiente explicación

• los caracteres entre corchetes [] definen la clase de caracteres, lo que significa que el patrón debe coincidir al menos con un carácter mencionado entre corchetes

• \ s especifica un espacio

•  + significa al menos uno de los caracteres mencionados anteriormente a +.

Este código extraerá el contenido entre corchetes y paréntesis

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

(?: 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

En R, intente:

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

Para hacer coincidir una subcadena entre el primero [ y el último ] , puede usar

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

Vea una demostración de expresiones regulares y una demostración de expresiones regulares # 2 .

Use las siguientes expresiones para unir cadenas entre los corchetes más cercanos :

• Incluyendo los soportes:

  • \[[^][]*]- PCRE, Python re/ regex, .NET, Golang, POSIX (grep, sed, bash)
  • \[[^\][]*]- ECMAScript (JavaScript, C ++ std::regex, VBA RegExp)
  • \[[^\]\[]*] - Java regex
  • \[[^\]\[]*\] - Onigmo (Ruby, requiere escapar de los corchetes en todas partes)

• Excluyendo los corchetes:

  • (?<=\[)[^][]*(?=])- PCRE, Python re/ regex, .NET (C #, etc.), ICU (R stringr), software JGSoft
  • \[([^][]*)]- Bash , Golang : capture el contenido entre corchetes con un par de paréntesis sin escape, también vea a continuación
  • \[([^\][]*)]- JavaScript , C ++std::regex , VBARegExp
  • (?<=\[)[^\]\[]*(?=]) - Java regex
  • (?<=\[)[^\]\[]*(?=\]) - Onigmo (Ruby, requiere escapar de los corchetes en todas partes)

NOTA : *coincide con 0 o más caracteres, use +para coincidir con 1 o más para evitar coincidencias de cadenas vacías en la lista / matriz resultante.

Siempre que esté disponible el soporte de lookaround, las soluciones anteriores se basan en ellos para excluir el soporte de apertura / cierre inicial / final. De lo contrario, confíe en capturar grupos (se han proporcionado enlaces a las soluciones más comunes en algunos idiomas).

Si necesita hacer coincidir paréntesis anidados , puede ver las soluciones en la expresión regular para hacer coincidir el hilo de paréntesis equilibrados y reemplazar los corchetes con los cuadrados para obtener la funcionalidad necesaria. Debe usar grupos de captura para acceder a los contenidos con el soporte de apertura / cierre excluido:

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

Necesitaba incluir nuevas líneas e incluir los corchetes

\[[\s\S]+\]