Question regex simple. J'ai une chaîne au format suivant:

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

Quelle est l'expression régulière pour extraire les mots entre crochets, c.-à-d.

sample
some
another one

Remarque: Dans mon cas d'utilisation, les crochets ne peuvent pas être imbriqués.

Vous pouvez utiliser globalement l' expression régulière suivante :

\[(.*?)\]

Explication:

• \[: [est un méta-caractère et doit être échappé si vous voulez le faire correspondre littéralement.
• (.*?) : associez tout de manière non gourmande et capturez-le.
• \]: ]est un méta-caractère et doit être échappé si vous voulez le faire correspondre littéralement.

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

Capture le contenu sans crochets

• (?<=\[) - lookbehind positif pour [

• .*? - match non gourmand pour le contenu

• (?=\]) - anticipation positive pour ]

EDIT: pour les crochets imbriqués, l'expression régulière ci-dessous devrait fonctionner:

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

Cela devrait fonctionner correctement:

\[([^]]+)\]

Les supports peuvent-ils être imbriqués?

Sinon: \[([^]]+)\]correspond à un élément, y compris les crochets. La référence arrière \1contiendra l'élément à faire correspondre. Si votre saveur regex prend en charge le lookaround, utilisez

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

Cela ne correspondra qu'à l'élément entre parenthèses.

Si vous ne souhaitez pas inclure les parenthèses dans la correspondance, voici l'expression régulière: (?<=\[).*?(?=\])

Décomposons-le

Le .correspond à n'importe quel caractère à l'exception des terminateurs de ligne. Le ?=est une anticipation positive . Un lookahead positif trouve une chaîne quand une certaine chaîne vient après. C'est ?<=un regard positif derrière . Un lookbehind positif trouve une chaîne lorsqu'une certaine chaîne la précède. Pour citer ceci ,

Regardez vers l'avenir positif (? =)

Trouvez l'expression A où l'expression B suit:

A(?=B)

Regardez derrière positif (? <=)

Rechercher l'expression A où l'expression B précède:

(?<=B)A

L'alternative

Si votre moteur regex ne prend pas en charge les lookaheads et lookbehinds, vous pouvez utiliser l'expression régulière \[(.*?)\]pour capturer les entrailles des crochets dans un groupe, puis vous pouvez manipuler le groupe si nécessaire.

Comment fonctionne cette expression régulière?

Les parenthèses capturent les personnages d'un groupe. Le .*?obtient tous les caractères entre les crochets (sauf pour les terminateurs de ligne, sauf si le sdrapeau est activé) d'une manière qui n'est pas gourmande.

(?<=\[).*?(?=\])fonctionne bien selon l'explication donnée ci-dessus. Voici un exemple 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'"

Juste au cas où vous auriez pu avoir des parenthèses déséquilibrées , vous pouvez probablement concevoir une expression avec une récursion similaire à,

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

ce qui, bien sûr, serait lié à la langue ou au moteur RegEx que vous pourriez utiliser.

RegEx Demo 1

Autre que ça,

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

RegEx Demo 2

ou,

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

RegEx Demo 3

sont de bonnes options à explorer.

Si vous souhaitez simplifier / modifier / explorer l'expression, cela a été expliqué dans le panneau supérieur droit de regex101.com . Si vous le souhaitez, vous pouvez également regarder dans ce lien , comment cela se comparerait à certains exemples d'entrées.

Circuit RegEx

jex.im visualise les expressions régulières:

Tester

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

La source

Expression régulière pour correspondre à des parenthèses équilibrées

si vous voulez seulement une petite lettre de l'alphabet entre crochets az

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

si vous voulez des lettres minuscules et majuscules a-zA-Z

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

si vous voulez des petites majuscules et une lettre numérique a-zA-Z0-9

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

si vous voulez tout entre crochets

si vous voulez du texte, des chiffres et des symboles

(\[.*\])

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

Ci-dessus devrait fonctionner compte tenu de l'explication suivante

• les caractères entre crochets [] définit la classe characte, ce qui signifie que le modèle doit correspondre au moins à un caractère mentionné entre crochets

• \ s spécifie un espace

•  + signifie au moins un des caractères mentionnés précédemment pour +.

Ce code extraira le contenu entre crochets et parenthèses

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

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

Dans R, essayez:

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

Pour faire correspondre une sous - [ ] chaîne entre la première et la dernière , vous pouvez utiliser

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

Voir une démo regex et une démo regex # 2 .

Utilisez les expressions suivantes pour faire correspondre les chaînes entre les crochets les plus proches :

• Y compris les supports:

  • \[[^][]*]- PCRE, Python re/ regex, .NET, Golang, POSIX (grep, sed, bash)
  • \[[^\][]*]- ECMAScript (JavaScript, C ++ std::regex, VBA RegExp)
  • \[[^\]\[]*] - Java regex
  • \[[^\]\[]*\] - Onigmo (Ruby, nécessite l'échappement des supports partout)

• À l'exclusion des parenthèses:

  • (?<=\[)[^][]*(?=])- PCRE, Python re/ regex, .NET (C #, etc.), ICU (R stringr), logiciel JGSoft
  • \[([^][]*)]- Bash , Golang - capturez le contenu entre crochets avec une paire de parenthèses non échappées, voir aussi ci-dessous
  • \[([^\][]*)]- JavaScript , C ++std::regex , VBARegExp
  • (?<=\[)[^\]\[]*(?=]) - Java regex
  • (?<=\[)[^\]\[]*(?=\]) - Onigmo (Ruby, nécessite l'échappement des supports partout)

REMARQUE : *correspond à 0 ou plusieurs caractères, utilisez +pour correspondre à 1 ou plus pour éviter les correspondances de chaînes vides dans la liste / le tableau résultant.

Chaque fois que la prise en charge des deux contournements est disponible, les solutions ci-dessus s'appuient sur elles pour exclure le crochet d'ouverture / fermeture avant / arrière. Sinon, comptez sur la capture de groupes (des liens vers les solutions les plus courantes dans certaines langues ont été fournis).

Si vous devez faire correspondre des parenthèses imbriquées , vous pouvez voir les solutions dans l' expression régulière pour faire correspondre le thread entre parenthèses équilibrées et remplacer les crochets ronds par les carrés pour obtenir les fonctionnalités nécessaires. Vous devez utiliser des groupes de capture pour accéder au contenu avec le crochet ouvert / fermé exclu:

• \[((?:[^][]++|(?R))*)]- PHP PCRE
• \[((?>[^][]+|(?<o>)\[|(?<-o>]))*)]- Démonstration .NET
• \[(?:[^\]\[]++|(\g<0>))*\]- Démo Onigmo (Ruby)

J'avais besoin d'inclure des nouvelles lignes et d'inclure les crochets

\[[\s\S]+\]