Home / Questions / 143095
Accepted
Jose Hermosilla Rodrigo
Asked: 2020-03-04 08:19:40 +0800 CST 2020-03-04 08:19:40 +0800 CST

How can I repeat a capture group

  • 772

I have several strings with the following structure:

AAAA_BBBB_CCCC_1_15_17
AAAA_BBBB_1
AAAA_BBBB_15_17

I am trying to find a regex that captures the following groups:

GRUPO1: AAAA  GRUPO2: BBBB_CCCC GRUPO3: 1_15_17
GRUPO1: AAAA  GRUPO2: BBBB GRUPO3: 1
GRUPO1: AAAA  GRUPO2: BBBB GRUPO3: 15_17

I have tried the following:

([a-zA-Z]+)_([a-zA-Z]+_?[a-zA-Z]+?)_(\d+_?)+

I'm having trouble with the third group, as it seems that the next one matchoverwrites the previous one using the +for group (\d+_?)+.

Example

const regex = /([a-zA-Z]+)_([a-zA-Z]+_?[a-zA-Z]+?)_(\d+_?)+/

const string = 'AAAA_BBBB_CCCC_1_2'

const [fullMatch, ...groups] = string.match(regex)

console.log(groups)

In the example 1_2I only get the 2.

How can I capture this last full group?

javascript

2 Answers

  1. Best Answer

    A capture is always overwritten . This is how regular expressions work. Repeating a group always overwrites the capture with the last match. For example, something like

    /(\d)+/

    will always capture the last digit of the integer.


    Beware of nested quantifiers . You're also having a problem in your regex, which isn't obvious now, but may cause problems in the future. When using:

    [a-zA-Z]+_?[a-zA-Z]+?

    you are consecutively repeating 2 constructions that match the same thing. Since el _is optional, the regex can be converted to [a-zA-Z]+[a-zA-Z]+?, and such a construct is the perfect recipe for catastrophic backtracking !

    Also, with that same construct, you're requiring it to be at least 2 characters long, so it's never going to match a text like A_B_1.


    Solution: Repeat within the group . To avoid this, what we do is enclose the entire optional part in a group without capturing , quantified with ?. Namely:

    ([a-zA-Z]+(?:_[a-zA-Z]+)?)

    enter image description here


    And we apply the same logic to the digit part (repeated with *).


    Regex:

     /^([a-z]+)_([a-z]+(?:_[a-z]+)?)_(\d+(?:_\d+)*)$/i


    Code:

    let pruebas = [
        'AAAA_BBBB_1',
        'AAAA_BBBB_CCCC_1',
        'AAAA_BBBB_1_2_3_4',
        'AAAA_BBBB_CCCC_1_2_3',
        'A_B_1',
        'A_B_C_1_2',
        'A_B_C_D_1'
    ];

const regex = /^([a-z]+)_([a-z]+(?:_[a-z]+)?)_(\d+(?:_\d+)*)$/i;
let match;


for (let texto of pruebas) {
    console.log(texto);
    if (match = regex.exec(texto)) {
        console.log('Grupo 1:',match[1],'Grupo 2:',match[2],'Grupo 3:',match[3]);
    } else {
        console.log('no coincide!');
    }
}

    • 3

  2. Similar to how you caught the second group, the third can be done with the help of non capturing groups .

    ([a-zA-Z]+)_([a-zA-Z]+_?[a-zA-Z]+?)((?:_\d+)+(?:_\d+)*)

    The state machine would look something like this:

    regex state machine

    When you put the symbols ?:inside a group, you are telling it not to capture that group, or better said, to capture it but not to register it among the captured groups.

    It is important to note that although it seems that the first half of group 3 would suffice, this is not the case, because if we have more than one repetition, the group will only catch the ending that matches and not the entire group of characters that we want.

    const regex = /([a-zA-Z]+)_([a-zA-Z]+_?[a-zA-Z]+?)((?:_\d+)+(?:_\d+)*)/

const strings = [
        'AAAA_BBBB_CCCC_1_15_17'
        ,'AAAA_BBBB_1'
        ,'AAAA_BBBB_15_17'
        ,'AAAA_BBBB_CCCC_1_2'
    ]

strings.forEach(string => {
  const [fullMatch, ...groups] = string.match(regex)
  console.log(groups)
})

    • 2