Мой вопрос + ответ связан, и я делаю выражение и мета-выражение, которое может соответствовать произвольным (конечным) уровням вложенности. Это довольно изящно, но что еще вы можете ожидать? Используйте обратные ссылки в матче, если ваш движок поддерживает его.

Нет, вы попадаете в область Контекстных свободных грамматик в этой точке.

Использование регулярных выражений для проверки вложенных шаблонов очень просто.

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

Использование рекурсивного соответствия в PHP-регулярном выражении значительно быстрее процедурного соответствия скобок. особенно с более длинными строками.

http://php.net/manual/en/regexp.reference.recursive.php

, например

$patt = '!\( (?: (?: (?>[^()]+) | (?R) )* ) \)!x';

preg_match_all( $patt, $str, $m );

vs.

matchBrackets( $str );

function matchBrackets ( $str, $offset = 0 ) {

    $matches = array();

    list( $opener, $closer ) = array( '(', ')' );

    // Return early if there's no match
    if ( false === ( $first_offset = strpos( $str, $opener, $offset ) ) ) {
        return $matches;
    }

    // Step through the string one character at a time storing offsets
    $paren_score = -1;
    $inside_paren = false;
    $match_start = 0;
    $offsets = array();

    for ( $index = $first_offset; $index < strlen( $str ); $index++ ) {
        $char = $str[ $index ];

        if ( $opener === $char ) {
            if ( ! $inside_paren ) {
                $paren_score = 1;
                $match_start = $index;
            }
            else {
                $paren_score++;
            }
            $inside_paren = true;
        }
        elseif ( $closer === $char ) {
            $paren_score--;
        }

        if ( 0 === $paren_score ) {
            $inside_paren = false;
            $paren_score = -1;
            $offsets[] = array( $match_start, $index + 1 );
        }
    }

    while ( $offset = array_shift( $offsets ) ) {

        list( $start, $finish ) = $offset;

        $match = substr( $str, $start, $finish - $start );
        $matches[] = $match;
    }

    return $matches;
}

Лемма Pumping для правильных языков является причиной того, что вы не можете этого сделать.

Сгенерированный автомат будет иметь конечное число состояний, например k, поэтому a строка из k + 1 открывающих скобок обязана иметь состояние, повторяющееся где-то (поскольку автомат обрабатывает символы). Часть строки между одним и тем же состоянием может быть продублирована бесконечно много раз, и автомат не узнает разницу.

В частности, если он принимает k + 1 открывающих скобок, за которыми следуют k + 1 замыкающие скобки ( который он должен), он также примет количество накачиваемых открывающих скобок, за которым следуют неизменные k + 1 замыкающие браки (что не должно).

Правильные регулярные выражения не могли бы этого сделать, поскольку вы покинули бы территорию обычных языков для приземления на территориях свободного пространства контекста.

Тем не менее, пакеты «регулярного выражения», которые предлагают многие языки,

Например, регулярные выражения Lua имеют распознаватель «%b()», который будет соответствовать сбалансированной круглой скобке. В вашем случае вы будете использовать «%b{}»

. Еще один сложный инструмент, подобный sed, - gema , где вы очень легко сопоставляете сбалансированные фигурные скобки с помощью {#}.

Итак, в зависимости от инструментов, которые у вас есть, ваше «регулярное выражение» (в более широком смысле) может соответствовать вложенным скобкам.

Кажется, что это работает: /(\{(?:\{.*\}|[^\{])*\})/m

, как упоминалось zsolt, некоторые двигатели регулярных выражений поддерживают рекурсию - конечно, обычно это те, которые используют алгоритм обратного отслеживания, поэтому он не будет особенно эффективен. пример: /(?>[^{}]*){(?>[^{}]*)(?R)*(?>[^{}]*)}/sm