Pergunta simples sobre regex. Eu tenho uma sequência no seguinte formato:

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

Qual é a expressão regular para extrair as palavras entre colchetes, ie.

sample
some
another one

Nota: No meu caso de uso, os colchetes não podem ser aninhados.

Você pode usar o seguinte regex globalmente :

\[(.*?)\]

Explicação:

• \[: [é um meta char e precisa ser escapado se você quiser combiná-lo literalmente.
• (.*?) : combine tudo de uma maneira não gananciosa e capture-a.
• \]: ]é um meta char e precisa ser escapado se você quiser combiná-lo literalmente.

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

Capturará conteúdo sem colchetes

• (?<=\[) - olhar positivo para [

• .*? - correspondência não gananciosa para o conteúdo

• (?=\]) - lookahead positivo para ]

EDIT: para colchetes aninhados, o regex abaixo deve funcionar:

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

Isso deve funcionar bem:

\[([^]]+)\]

Os colchetes podem ser aninhados?

Caso contrário: \[([^]]+)\]corresponde a um item, incluindo colchetes. A referência anterior \1conterá o item a ser correspondido. Se o seu sabor regex suportar a aparência, use

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

Isso corresponderá apenas ao item entre colchetes.

Se você não deseja incluir os colchetes na correspondência, veja o regex: (?<=\[).*?(?=\])

Vamos dividir

A .corresponde a qualquer caractere exceto para terminadores de linha. O visual?= é positivo . Um lookahead positivo encontra uma string quando uma determinada string vem depois dela. O olhar?<= é positivo . Um lookbehind positivo encontra uma string quando uma determinada string a precede. Para citar isso ,

Olhe para o lado positivo (? =)

Encontre a expressão A em que a expressão B segue:

A(?=B)

Olhe para trás positivo (? <=)

Encontre a expressão A em que a expressão B precede:

(?<=B)A

A alternativa

Se o mecanismo regex não suportar lookaheads e lookbehinds, você poderá usar o regex \[(.*?)\]para capturar as entranhas dos colchetes de um grupo e manipular o grupo conforme necessário.

Como esse regex funciona?

Os parênteses capturam os caracteres em um grupo. A .*?recebe todos os caracteres entre os colchetes (exceto para terminadores de linha, a menos que você tem a sbandeira habilitado) de uma forma que não é ganancioso.

(?<=\[).*?(?=\])funciona bem como explicado acima. Aqui está um exemplo 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'"

Caso você tenha colchetes desequilibrados , é possível criar alguma expressão com recursão semelhante a,

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

que, é claro, estaria relacionado ao idioma ou ao mecanismo RegEx que você pode estar usando.

RegEx Demo 1

Fora isso,

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

RegEx Demo 2

ou,

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

RegEx Demo 3

são boas opções para explorar.

Se você deseja simplificar / modificar / explorar a expressão, isso foi explicado no painel superior direito de regex101.com . Se desejar, também é possível assistir neste link , como ele corresponderia a algumas entradas de amostra.

Circuito RegEx

O jex.im visualiza expressões regulares:

Teste

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

Fonte

Expressão regular para combinar parênteses balanceados

se você quiser preencher apenas uma pequena letra do alfabeto entre colchetes az

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

se você quer letras pequenas e maiúsculas a-zA-Z

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

se você quiser letras minúsculas e letra numérica a-zA-Z0-9

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

se você quer tudo entre colchetes

se você quiser texto, número e símbolos

(\[.*\])

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

Acima deve funcionar, dada a seguinte explicação

• caracteres entre colchetes [] define a classe de caractere, o que significa que o padrão deve corresponder a pelo menos um caractere mencionado entre colchetes

• \ s especifica um espaço

•  + significa pelo menos um dos caracteres mencionados anteriormente em +.

Esse código extrairá o conteúdo entre colchetes e parênteses

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

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

Em R, tente:

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

Eu precisava incluir novas linhas e incluir os colchetes

\[[\s\S]+\]

Para corresponder uma substring entre o primeiro [ e o último ] , você pode usar

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

Veja uma demonstração de regex e uma demonstração de regex # 2 .

Use as seguintes expressões para corresponder cadeias entre os colchetes mais próximos :

• Incluindo os suportes:

  • \[[^][]*]- PCRE, Python re/ regex. NET, Golang, POSIX (grep, sed, bash)
  • \[[^\][]*]- ECMAScript (JavaScript, C ++ std::regex, VBA RegExp)
  • \[[^\]\[]*] - Regex Java
  • \[[^\]\[]*\] - Onigmo (Ruby, requer escape de colchetes em todos os lugares)

• Excluindo os colchetes:

  • (?<=\[)[^][]*(?=])- PCRE, Python re/ regex, .NET (C #, etc.), ICU (R stringr), Software JGSoft
  • \[([^][]*)]- Bash , Golang - capture o conteúdo entre colchetes com um par de parênteses sem escape, também veja abaixo
  • \[([^\][]*)]- JavaScript , C ++std::regex , VBARegExp
  • (?<=\[)[^\]\[]*(?=]) - Regex Java
  • (?<=\[)[^\]\[]*(?=\]) - Onigmo (Ruby, requer escape de colchetes em todos os lugares)

NOTA : *corresponde a 0 ou mais caracteres, use +para corresponder a 1 ou mais para evitar correspondências de seqüência de caracteres vazias na lista / matriz resultante.

Sempre que o suporte de ambos os olhares está disponível, as soluções acima se baseiam neles para excluir o suporte de abertura / fechamento à esquerda / à direita. Caso contrário, confie na captura de grupos (foram fornecidos links para as soluções mais comuns em alguns idiomas).

Se você precisar corresponder parênteses aninhados , poderá ver as soluções na expressão Regular para corresponder ao segmento de parênteses balanceados e substituir os colchetes pelos quadrados para obter a funcionalidade necessária. Você deve usar grupos de captura para acessar o conteúdo com o colchete de abrir / fechar excluído:

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