Regulärer Ausdruck für die Übereinstimmung von ausgeglichenen Klammern

Question

Ich brauche einen regulären Ausdruck, um den gesamten Text zwischen zwei äußeren Klammern auszuwählen.

Exemple :
START_TEXT(text here(possible text)text(possible text(more text)))END_TXT
^ ^

Ergebnis:
(text here(possible text)text(possible text(more text)))

Answer 1

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

Wenn Sie Text zwischen zwei Zeilen auswählen möchten passend zu Klammern, haben Sie mit regulären Ausdrücken kein Glück. Das ist unmöglich (*) .

Diese Regex gibt nur den Text zwischen der ersten öffnenden und der letzten schließenden Klammer in Ihrer Zeichenkette zurück.

---

(*) Es sei denn, Ihre Regex-Engine hat Funktionen wie Bilanzkreise o Rekursion . Die Zahl der Motoren, die solche Funktionen unterstützen, wächst langsam, aber sie sind immer noch nicht allgemein verfügbar.

Answer 2

Es ist tatsächlich möglich, dies mit regulären Ausdrücken in .NET zu tun, aber es ist nicht trivial, also lesen Sie sorgfältig.

Sie können einen schönen Artikel lesen aquí . Möglicherweise müssen Sie sich auch über reguläre Ausdrücke in .NET informieren. Sie können mit der Lektüre von aquí .

Eckige Klammern <> wurden verwendet, weil sie kein Escaping erfordern.

Der reguläre Ausdruck sieht wie folgt aus:

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

Answer 3

Ich war auch in dieser Situation, wo verschachtelte Muster kommt stecken.

Reguläre Ausdrücke sind das Richtige, um das oben genannte Problem zu lösen. Verwenden Sie folgendes Muster

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

Answer 4

Dies ist die endgültige Regex:

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

)*
)
\)

Exemple :

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

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

beachten Sie, dass die '(pip' wird korrekt als String verwaltet. (ausprobiert in regulator: http://sourceforge.net/projects/regulator/ )

Answer 5

Hinzufügen zu Wackelpudding's Antwort gibt es andere Regex-Varianten, die rekursive Konstrukte unterstützen.

Lua

Utilice %b() ( %b{} / %b[] für geschweifte Klammern / eckige Klammern):

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

Raku (früher Perl6) :

Nicht überschneidende Übereinstimmungen mit mehreren ausgeglichenen Klammern:

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)))

Überschneidungen mit mehreren ausgeglichenen Klammern:

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

Ver Demo .

Python re Nicht-Regex-Lösung

Ver Antwort von Stochern para Wie man einen Ausdruck zwischen ausgeglichenen Klammern erhält .

Mit Java anpassbare Nicht-Regex-Lösung

Hier ist eine anpassbare Lösung, die es erlaubt, einzelne Zeichen als Begrenzungszeichen in Java zu verwenden:

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

Beispielhafte Verwendung:

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)))]