Как вложенные группы захвата нумеруются в регулярных выражениях?

Да, это все очень хорошо определено для всех интересующих вас языков:

• Java - http://java.sun.com/javase/6/docs/api/java/util/regex/Pattern.html#cg
  "Захватывающие группы нумеруются путем подсчета их открывающих скобок слева направо. Ноль группы всегда обозначает все выражение".
• .Net - http://msdn.microsoft.com/en-us/library/bs2twtah(VS.71).aspx
  "Захваты с использованием() нумеруются автоматически в соответствии с порядком открывающей скобки, начиная с 1. Первый захват, номер элемента захвата нуля - это текст, сопоставляемый всем шаблоном регулярного выражения." )
• PHP (функции PCRE) - http://www.php.net/manual/en/function.preg-replace.php#function.preg-replace.parameters
  "\ 0 или $0 относится к тексту, сопоставляемому всем шаблоном. Открывающиеся круглые скобки подсчитываются слева направо (начиная с 1), чтобы получить номер подматрицы захвата". (Это также относится к устаревшим функциям POSIX)

• PCRE - http://www.pcre.org/pcre.txt
  Чтобы добавить к тому, что сказал Алан М, выполните поиск "Как pcre_exec() возвращает захваченные подстроки" и прочитайте следующий пятый абзац:

  The  first  pair  of  integers, ovector[0] and ovector[1], identify the
  portion of the subject string matched by the entire pattern.  The next
  pair  is  used for the first capturing subpattern, and so on. The value
  returned by pcre_exec() is one more than the highest numbered pair that
  has  been  set.  For example, if two substrings have been captured, the
  returned value is 3. If there are no capturing subpatterns, the  return
  value from a successful match is 1, indicating that just the first pair
  of offsets has been set.
  

• Perl different - http://perldoc.perl.org/perlre.html#Capture-buffers
  $ 1, $2 и т.д. Соответствуют группам захвата, как и следовало ожидать (т.е. По наличию открывающей скобки), однако $0 возвращает имя программы, а не всю строку запроса - чтобы вы использовали $& вместо.

Вы, скорее всего, найдете похожие результаты для других языков (Python, Ruby и др.).

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

Помещение всей строки матча в позицию 0 также имеет смысл - в основном для согласованности. Он позволяет всей согласованной строке оставаться в одном индексе независимо от группы захвата числа от регулярного выражения к регулярному выражению и независимо от количества групп захвата, которые фактически соответствуют чему-либо (например, Java скроет длину массива согласованных групп для каждого захвата группа не соответствует какому-либо контенту (например, подумайте, например, как "a (. *) pattern" ). Вы всегда можете проверить capture_group_results [capturing_group_results_length - 2], но это плохо переводит языки на Perl, которые динамически создают переменные ($ 1, $2 и т.д.) (Perl - неудачный пример, так как он использует $& для согласованного выражения, но вы получаете идею:).

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

Где интересно, это с именованными группами. В большинстве случаев они следуют той же политике нумерации по относительным позициям parens - это имя является просто псевдонимом для числа. Однако в регулярных выражениях .NET именованные группы нумеруются отдельно от пронумерованных групп. Например:

Regex.Replace(@"one two three four", 
              @"(?<one>\w+) (\w+) (?<three>\w+) (\w+)",
              @"$1 $2 $3 $4")

// result: "two four one three"

Фактически, это псевдоним для имени; числа, назначенные именованным группам, начинаются там, где "реальные" нумерованные группы остаются в силе. Это может показаться странной политикой, но для этого есть веская причина: в регулярных выражениях .NET вы можете использовать одно и то же имя группы более одного раза в регулярном выражении. Это позволяет использовать регулярные выражения, такие как этот поток для сопоставления чисел с плавающей запятой из разных локалей:

^[+-]?[0-9]{1,3}
(?:
    (?:(?<thousand>\,)[0-9]{3})*
    (?:(?<decimal>\.)[0-9]{2})?
|
    (?:(?<thousand>\.)[0-9]{3})*
    (?:(?<decimal>\,)[0-9]{2})?
|
    [0-9]*
    (?:(?<decimal>[\.\,])[0-9]{2})?
)$

Если есть разделитель тысяч, он будет сохранен в группе "тысяча" независимо от того, какая часть регулярного выражения соответствовала ему. Аналогично, десятичный разделитель (если он есть) всегда будет сохранен в группе "десятичный". Конечно, есть способы идентифицировать и извлекать разделители без многократно используемых именных групп, но этот способ намного удобнее, я думаю, что это более чем оправдывает странную схему нумерации.

И тогда есть Perl 5.10+, который дает нам больше контроля над захватом групп, чем я знаю, что делать.: D

Порядок захвата в порядке слева - стандартный для всех платформ, на которых я работал. (perl, php, ruby, egrep)