Захват квантификаторов и арифметика квантификаторов

I don't know a regex engine that can capture a quantifier. However, it is possible with PCRE or Perl to use some tricks to check if you have the same number of characters. With your example:

@@@@ "Star Wars" ==== "1977" ---- "Science Fiction" //// "George Lucas"

~(?<!@)((?:@(?=[^=]*(\2?+=)[^-]*(\3?+-)[^/]*(\4?+/)))+)(?!@)(?=[^=]*\2(?!=)[^-]*\3(?!-)[^/]*\4(?!/))~

детали узора:

~                          # pattern delimiter
(?<!@)                     # negative lookbehind used as an @ boundary
(                          # first capturing group for the @
    (?:
        @                  # one @
        (?=                # checks that each @ is followed by the same number
                           # of = - /  
            [^=]*          # all that is not an =
            (\2?+=)        # The possessive optional self-referencing group:
                           # capture group 2: backreference to itself + one = 
            [^-]*(\3?+-)   # the same for -
            [^/]*(\4?+/)   # the same for /
        )                  # close the lookahead
    )+                     # close the non-capturing group and repeat
)                          # close the first capturing group
(?!@)                      # negative lookahead used as an @ boundary too.

# this checks the boundaries for all groups
(?=[^=]*\2(?!=)[^-]*\3(?!-)[^/]*\4(?!/))
~

Основная идея

Группа без захвата содержит только один @. Каждый раз, когда эта группа повторяется, новый персонаж добавляется в группы захвата 2, 3 и 4.

притяжательно-необязательная самоссылающаяся группа

Как это работает?

( (?: @ (?= [^=]* (\2?+ = ) .....) )+ )

При первом появлении символа @ группа захвата 2 еще не определена, поэтому вы не можете написать что-то вроде (\2 =), что приведет к сбою шаблона. Чтобы избежать этой проблемы, можно сделать обратную ссылку необязательной: \2?

Второй аспект этой группы заключается в том, что количество совпадающих символов = увеличивается при каждом повторении группы без захвата, поскольку каждый раз добавляется =. Чтобы гарантировать, что это число всегда увеличивается (или шаблон не работает), притяжательный квантификатор заставляет сначала сопоставляться обратную ссылку перед добавлением нового символа =.

Обратите внимание, что эту группу можно увидеть так: если существует группа 2, сопоставьте ее со следующим =

( (?(2)\2) = )

Рекурсивный способ

~(?<!@)(?=(@(?>[^@=]+|(?-1))*=)(?!=))(?=(@(?>[^@-]+|(?-1))*-)(?!-))(?=(@(?>[^@/]+|(?-1))*/)(?!/))~

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

детали узора:

(?<!@)                # left @ boundary
(?=                   # open a lookahead (to allow overlapped matches)
    (                 # open a capturing group
        @
        (?>           # open an atomic group
            [^@=]+    # all that is not an @ or an =, one or more times
          |           # OR
            (?-1)     # recursion: the last defined capturing group (the current here)
        )*            # repeat zero or more the atomic group
        =             #
    )                 # close the capture group
    (?!=)             # checks the = boundary
)                     # close the lookahead
(?=(@(?>[^@-]+|(?-1))*-)(?!-))  # the same for -
(?=(@(?>[^@/]+|(?-1))*/)(?!/))  # the same for /

Основное отличие от предыдущего шаблона заключается в том, что ему не важен порядок групп = - и /. (Однако вы можете легко внести некоторые изменения в первый шаблон, чтобы справиться с этим, с классами символов и отрицательным прогнозом.)

Примечание. В примере строки, чтобы быть более конкретным, вы можете заменить отрицательный ретроспективный просмотр якорем (^ или \A). И если вы хотите получить всю строку как результат совпадения, вы должны добавить .* в конце (иначе результат совпадения будет пустым, как это замечает игривый).

Возвращаясь через пять недель, потому что я узнал, что в .NET есть что-то, что очень близко к идее «захвата квантификатора», упомянутой в вопросе. Функция называется «балансировка групп».

Вот решение, которое я придумал. Выглядит долго, но довольно просто.

(?:@(?<c1>)(?<c2>)(?<c3>))+[^@=]+(?<-c1>=)+[^=-]+(?<-c2>-)+[^-/]+(?<-c3>/)+[^/]+(?(c1)(?!))(?(c2)(?!))(?(c3)(?!))

Как это работает?

1. Первая группа без захвата соответствует символам @. В этой незахватывающей группе у нас есть три именованные группы c1, c2 и c3, которые ничему не соответствуют, вернее, соответствуют пустой строке. Эти группы будут служить тремя счетчиками c1, c2 и c3. Поскольку .NET отслеживает промежуточные захваты при количественной оценке группы, каждый раз, когда совпадает @, захват добавляется к наборам захватов для групп c1, c2 и c3.

2. Далее [^@=]+ съедает все символы до первого =.

3. Вторая квантифицированная группа (?<-c1>=)+ соответствует = символам. Кажется, эта группа называется -c1, но -c1 не является названием группы. -c1 is.NET синтаксис для отправки одного захвата из коллекции захватов группы c1 в эфир. Другими словами, это позволяет нам уменьшить c1. Если вы попытаетесь уменьшить c1, когда коллекция захвата пуста, совпадение не удастся. Это гарантирует, что у нас никогда не будет больше = символов, чем @. (Позже нам нужно будет убедиться, что у нас не может быть больше @, чем = символов.)

4. Следующие шаги повторяют шаги 2 и 3 для символов - и /, уменьшая значения счетчиков c2 и c3.

5. [^/]+ съедает остаток строки.

6. (?(c1)(?!)) - это условное выражение, которое говорит: «Если группа c1 была установлена, произойдет сбой». Возможно, вы знаете, что (?!) — это обычный трюк, чтобы заставить регулярное выражение не работать. Это условное выражение гарантирует, что c1 будет уменьшено до нуля: другими словами, @ символов не может быть больше, чем =.

7. Точно так же (?(c2)(?!)) и (?(c3)(?!)) гарантируют, что @ не может быть больше, чем - и / символов.

Я не знаю о вас, но даже это немного длинно, я нахожу это действительно интуитивным.