J'ai besoin d'une expression régulière pour sélectionner tout le texte entre deux crochets extérieurs.

Exemple: some text(text here(possible text)text(possible text(more text)))end text

Résultat: (text here(possible text)text(possible text(more text)))

Les expressions régulières ne sont pas le bon outil pour le travail car vous avez affaire à des structures imbriquées, c'est-à-dire à la récursivité.

Mais il existe un algorithme simple pour ce faire, que j'ai décrit dans cette réponse à une question précédente .

Je veux ajouter cette réponse pour référence rapide. N'hésitez pas à mettre à jour.

.NET Regex utilisant des groupes d'équilibrage .

\((?>\((?<c>)|[^()]+|\)(?<-c>))*(?(c)(?!))\)

Où cest utilisé comme compteur de profondeur.

Démo sur Regexstorm.com

• Dépassement de pile : utilisation de RegEx pour équilibrer les parenthèses de correspondance
• Blogue déroutant de Wes : faire correspondre les constructions équilibrées avec les expressions régulières .NET
• Le blog de Greg Reinacker : constructions imbriquées dans des expressions régulières

PCRE utilisant un modèle récursif .

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

Démo à regex101 ; Ou sans alternance:

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

Démo à regex101 ; Ou déroulé pour la performance:

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

Démo à regex101 ; Le motif est collé sur (?R)lequel représente (?0).

Perl, PHP, Notepad ++, R : perl = TRUE , Python : package Regex avec (?V1)pour le comportement Perl.

Ruby utilisant des appels de sous-expression .

Avec Ruby 2.0 \g<0>peut être utilisé pour appeler le modèle complet.

\((?>[^)(]+|\g<0>)*\)

Démo chez Rubular ; Ruby 1.9 ne prend en charge que la capture de la récursivité de groupe :

(\((?>[^)(]+|\g<1>)*\))

Démo chez Rubular  ( groupement atomique depuis Ruby 1.9.3)

 API JavaScript :: XRegExp.matchRecursive

XRegExp.matchRecursive(str, '\\(', '\\)', 'g');

JS, Java et autres saveurs regex sans récursivité jusqu'à 2 niveaux d'imbrication:

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

Démo sur regex101 . Une imbrication plus profonde doit être ajoutée au modèle.
Pour échouer plus rapidement sur des parenthèses déséquilibrées, supprimez le +quantificateur.

Java : une idée intéressante utilisant les références directes de @jaytea .

_{Référence - Que signifie cette expression régulière?}

• rexegg.com - Expressions régulières récursives
• Regular-Expressions.info - Récursivité des expressions régulières

Vous pouvez utiliser la récursion regex :

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

[^\(]*(\(.*\))[^\)]*

[^\(]*correspond à tout ce qui n'est pas un crochet ouvrant au début de la chaîne, (\(.*\))capture la sous-chaîne requise entre crochets et [^\)]*correspond à tout ce qui n'est pas un crochet fermant à la fin de la chaîne. Notez que cette expression ne tente pas de faire correspondre les crochets; un simple analyseur (voir la réponse de dehmann ) serait plus approprié pour cela.

(?<=\().*(?=\))

Si vous souhaitez sélectionner du texte entre deux parenthèses correspondantes , vous n'avez pas de chance avec les expressions régulières. C'est impossible ^(*) .

Cette expression régulière renvoie simplement le texte entre la première ouverture et les dernières parenthèses fermantes de votre chaîne.

^(*) À moins que votre moteur d'expression régulière n'ait des fonctionnalités comme l' équilibrage des groupes ou la récursivité . Le nombre de moteurs qui prennent en charge de telles fonctionnalités augmente lentement, mais ils ne sont toujours pas disponibles.

Cette réponse explique la limitation théorique des raisons pour lesquelles les expressions régulières ne sont pas le bon outil pour cette tâche.

Les expressions régulières ne peuvent pas faire cela.

Les expressions régulières sont basées sur un modèle informatique appelé Finite State Automata (FSA). Comme son nom l'indique, un FSAne peut se souvenir que de l'état actuel, il n'a aucune information sur les états précédents.

Dans le diagramme ci-dessus, S1 et S2 sont deux états où S1 est l'étape initiale et finale. Donc, si nous essayons avec la chaîne 0110, la transition se déroule comme suit:

      0     1     1     0
-> S1 -> S2 -> S2 -> S2 ->S1

Dans les étapes ci - dessus, lorsque nous sommes à la deuxième S2soit après l' analyse syntaxique 01de 0110la FSA n'a pas d' informations sur le précédent 0en 01car il ne peut se rappeler l'état actuel et le symbole d'entrée suivante.

Dans le problème ci-dessus, nous devons connaître le non de la parenthèse ouvrante; cela signifie qu'il doit être stocké à un endroit. Mais puisque FSAscela ne peut pas être fait, une expression régulière ne peut pas être écrite.

Cependant, un algorithme peut être écrit pour effectuer cette tâche. Les algorithmes relèvent généralement du domaine Pushdown Automata (PDA). PDAest un niveau au-dessus de FSA. PDA dispose d'une pile supplémentaire pour stocker des informations supplémentaires. Les PDA peuvent être utilisés pour résoudre le problème ci-dessus, car nous pouvons ` push` les parenthèses ouvrantes dans la pile et ' pop' les une fois que nous rencontrons une parenthèse fermante. Si à la fin, la pile est vide, l'ouverture des parenthèses et la fermeture des parenthèses correspondent. Sinon non.

Il est en fait possible de le faire en utilisant des expressions régulières .NET, mais ce n'est pas trivial, alors lisez attentivement.

Vous pouvez lire un bel article ici . Vous devrez peut-être également lire les expressions régulières .NET. Vous pouvez commencer à lire ici .

Des équerres <>ont été utilisées car elles ne nécessitent pas de fuite.

L'expression régulière ressemble à ceci:

<
[^<>]*
(
    (
        (?<Open><)
        [^<>]*
    )+
    (
        (?<Close-Open>>)
        [^<>]*
    )+
)*
(?(Open)(?!))
>

C'est le regex définitif:

\(
(?<arguments> 
(  
  ([^\(\)']*) |  
  (\([^\(\)']*\)) |
  '(.*?)'

)*
)
\)

Exemple:

input: ( arg1, arg2, arg3, (arg4), '(pip' )

output: arg1, arg2, arg3, (arg4), '(pip'

notez que le '(pip'est correctement géré en tant que chaîne. (essayé dans le régulateur: http://sourceforge.net/projects/regulator/ )

J'ai écrit une petite bibliothèque JavaScript appelée équilibrée pour aider à cette tâche. Vous pouvez accomplir cela en faisant

balanced.matches({
    source: source,
    open: '(',
    close: ')'
});

Vous pouvez même faire des remplacements:

balanced.replacements({
    source: source,
    open: '(',
    close: ')',
    replace: function (source, head, tail) {
        return head + source + tail;
    }
});

Voici un exemple JSFiddle plus complexe et interactif .

Pour ajouter à la réponse de Bobble Bubble , il existe d'autres saveurs d'expression régulière où les constructions récursives sont prises en charge.

Lua

Utilisation %b()( %b{}/ %b[]pour les accolades / crochets):

• for s in string.gmatch("Extract (a(b)c) and ((d)f(g))", "%b()") do print(s) end(voir démo )

Perl6 :

Correspondances entre parenthèses équilibrées multiples sans chevauchement:

my regex paren_any { '(' ~ ')' [ <-[()]>+ || <&paren_any> ]* }
say "Extract (a(b)c) and ((d)f(g))" ~~ m:g/<&paren_any>/;
# => (｢(a(b)c)｣ ｢((d)f(g))｣)

Chevauchement de plusieurs correspondances équilibrées entre parenthèses:

say "Extract (a(b)c) and ((d)f(g))" ~~ m:ov:g/<&paren_any>/;
# => (｢(a(b)c)｣ ｢(b)｣ ｢((d)f(g))｣ ｢(d)｣ ｢(g)｣)

Voir la démo .

reSolution Python non regex

Voir la réponse de poke pour savoir comment obtenir une expression entre parenthèses équilibrées .

Solution non regex personnalisable Java

Voici une solution personnalisable permettant des délimiteurs littéraux à un seul caractère en Java:

public static List<String> getBalancedSubstrings(String s, Character markStart, 
                                 Character markEnd, Boolean includeMarkers) 

{
        List<String> subTreeList = new ArrayList<String>();
        int level = 0;
        int lastOpenDelimiter = -1;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == markStart) {
                level++;
                if (level == 1) {
                    lastOpenDelimiter = (includeMarkers ? i : i + 1);
                }
            }
            else if (c == markEnd) {
                if (level == 1) {
                    subTreeList.add(s.substring(lastOpenDelimiter, (includeMarkers ? i + 1 : i)));
                }
                if (level > 0) level--;
            }
        }
        return subTreeList;
    }
}

Exemple d'utilisation:

String s = "some text(text here(possible text)text(possible text(more text)))end text";
List<String> balanced = getBalancedSubstrings(s, '(', ')', true);
System.out.println("Balanced substrings:\n" + balanced);
// => [(text here(possible text)text(possible text(more text)))]

L'expression régulière utilisant Ruby (version 1.9.3 ou supérieure):

/(?<match>\((?:\g<match>|[^()]++)*\))/

Démo sur rubular

Vous avez besoin des première et dernière parenthèses. Utilisez quelque chose comme ceci:

str.indexOf ('('); - il vous donnera la première occurrence

str.lastIndexOf (')'); - le dernier

Vous avez donc besoin d'une chaîne entre,

String searchedString = str.substring(str1.indexOf('('),str1.lastIndexOf(')');

"""
Here is a simple python program showing how to use regular
expressions to write a paren-matching recursive parser.

This parser recognises items enclosed by parens, brackets,
braces and <> symbols, but is adaptable to any set of
open/close patterns.  This is where the re package greatly
assists in parsing. 
"""

import re


# The pattern below recognises a sequence consisting of:
#    1. Any characters not in the set of open/close strings.
#    2. One of the open/close strings.
#    3. The remainder of the string.
# 
# There is no reason the opening pattern can't be the
# same as the closing pattern, so quoted strings can
# be included.  However quotes are not ignored inside
# quotes.  More logic is needed for that....


pat = re.compile("""
    ( .*? )
    ( \( | \) | \[ | \] | \{ | \} | \< | \> |
                           \' | \" | BEGIN | END | $ )
    ( .* )
    """, re.X)

# The keys to the dictionary below are the opening strings,
# and the values are the corresponding closing strings.
# For example "(" is an opening string and ")" is its
# closing string.

matching = { "(" : ")",
             "[" : "]",
             "{" : "}",
             "<" : ">",
             '"' : '"',
             "'" : "'",
             "BEGIN" : "END" }

# The procedure below matches string s and returns a
# recursive list matching the nesting of the open/close
# patterns in s.

def matchnested(s, term=""):
    lst = []
    while True:
        m = pat.match(s)

        if m.group(1) != "":
            lst.append(m.group(1))

        if m.group(2) == term:
            return lst, m.group(3)

        if m.group(2) in matching:
            item, s = matchnested(m.group(3), matching[m.group(2)])
            lst.append(m.group(2))
            lst.append(item)
            lst.append(matching[m.group(2)])
        else:
            raise ValueError("After <<%s %s>> expected %s not %s" %
                             (lst, s, term, m.group(2)))

# Unit test.

if __name__ == "__main__":
    for s in ("simple string",
              """ "double quote" """,
              """ 'single quote' """,
              "one'two'three'four'five'six'seven",
              "one(two(three(four)five)six)seven",
              "one(two(three)four)five(six(seven)eight)nine",
              "one(two)three[four]five{six}seven<eight>nine",
              "one(two[three{four<five>six}seven]eight)nine",
              "oneBEGINtwo(threeBEGINfourENDfive)sixENDseven",
              "ERROR testing ((( mismatched ))] parens"):
        print "\ninput", s
        try:
            lst, s = matchnested(s)
            print "output", lst
        except ValueError as e:
            print str(e)
    print "done"

La réponse dépend de si vous devez faire correspondre les ensembles de crochets correspondants, ou simplement de la première ouverture à la dernière fermeture dans le texte d'entrée.

Si vous devez faire correspondre les crochets imbriqués correspondants, vous avez besoin de quelque chose de plus que des expressions régulières. - voir @dehmann

Si c'est juste ouvert pour fermer, voir @Zach

Décidez de ce que vous voulez faire avec:

abc ( 123 ( foobar ) def ) xyz ) ghij

Vous devez décider à quoi votre code doit correspondre dans ce cas.

parce que js regex ne prend pas en charge la correspondance récursive, je ne peux pas faire fonctionner la correspondance de parenthèses équilibrées.

c'est donc un simple javascript pour la version en boucle qui transforme la chaîne "method (arg)" en tableau

push(number) map(test(a(a()))) bass(wow, abc)
$$(groups) filter({ type: 'ORGANIZATION', isDisabled: { $ne: true } }) pickBy(_id, type) map(test()) as(groups)

const parser = str => {
  let ops = []
  let method, arg
  let isMethod = true
  let open = []

  for (const char of str) {
    // skip whitespace
    if (char === ' ') continue

    // append method or arg string
    if (char !== '(' && char !== ')') {
      if (isMethod) {
        (method ? (method += char) : (method = char))
      } else {
        (arg ? (arg += char) : (arg = char))
      }
    }

    if (char === '(') {
      // nested parenthesis should be a part of arg
      if (!isMethod) arg += char
      isMethod = false
      open.push(char)
    } else if (char === ')') {
      open.pop()
      // check end of arg
      if (open.length < 1) {
        isMethod = true
        ops.push({ method, arg })
        method = arg = undefined
      } else {
        arg += char
      }
    }
  }

  return ops
}

// const test = parser(`$$(groups) filter({ type: 'ORGANIZATION', isDisabled: { $ne: true } }) pickBy(_id, type) map(test()) as(groups)`)
const test = parser(`push(number) map(test(a(a()))) bass(wow, abc)`)

console.log(test)

le résultat est comme

[ { method: 'push', arg: 'number' },
  { method: 'map', arg: 'test(a(a()))' },
  { method: 'bass', arg: 'wow,abc' } ]

[ { method: '$$', arg: 'groups' },
  { method: 'filter',
    arg: '{type:\'ORGANIZATION\',isDisabled:{$ne:true}}' },
  { method: 'pickBy', arg: '_id,type' },
  { method: 'map', arg: 'test()' },
  { method: 'as', arg: 'groups' } ]

Alors que tant de réponses mentionnent cela sous une forme quelconque en disant que l'expression régulière ne prend pas en charge la correspondance récursive et ainsi de suite, la principale raison de cela réside dans les racines de la théorie du calcul.

Langue du formulaire {a^nb^n | n>=0} is not regular. Regex ne peut correspondre qu'à des éléments qui font partie de l'ensemble régulier de langues.

En savoir plus @ ici

Je n'ai pas utilisé l'expression régulière car il est difficile de gérer le code imbriqué. Cet extrait devrait donc vous permettre de récupérer des sections de code avec des crochets équilibrés:

def extract_code(data):
    """ returns an array of code snippets from a string (data)"""
    start_pos = None
    end_pos = None
    count_open = 0
    count_close = 0
    code_snippets = []
    for i,v in enumerate(data):
        if v =='{':
            count_open+=1
            if not start_pos:
                start_pos= i
        if v=='}':
            count_close +=1
            if count_open == count_close and not end_pos:
                end_pos = i+1
        if start_pos and end_pos:
            code_snippets.append((start_pos,end_pos))
            start_pos = None
            end_pos = None

    return code_snippets

J'ai utilisé cela pour extraire des extraits de code d'un fichier texte.

J'étais également coincé dans cette situation où les modèles imbriqués viennent.

L'expression régulière est la bonne chose pour résoudre le problème ci-dessus. Utiliser le modèle ci-dessous

'/(\((?>[^()]+|(?1))*\))/'

Celui-ci a également fonctionné

re.findall(r'\(.+\)', s)

Cela peut être utile à certains:

Analyser les paramètres de la chaîne de fonction (avec des structures imbriquées) en javascript

Faites correspondre les structures comme:

• correspond aux crochets, crochets, parenthèses, guillemets simples et doubles

Ici vous pouvez voir l'expression rationnelle générée en action

/**
 * get param content of function string.
 * only params string should be provided without parentheses
 * WORK even if some/all params are not set
 * @return [param1, param2, param3]
 */
exports.getParamsSAFE = (str, nbParams = 3) => {
    const nextParamReg = /^\s*((?:(?:['"([{](?:[^'"()[\]{}]*?|['"([{](?:[^'"()[\]{}]*?|['"([{][^'"()[\]{}]*?['")}\]])*?['")}\]])*?['")}\]])|[^,])*?)\s*(?:,|$)/;
    const params = [];
    while (str.length) { // this is to avoid a BIG performance issue in javascript regexp engine
        str = str.replace(nextParamReg, (full, p1) => {
            params.push(p1);
            return '';
        });
    }
    return params;
};

Cela ne répond pas entièrement à la question OP mais je pense que cela peut être utile à certains venant ici pour rechercher des expressions rationnelles de structure imbriquée.