How can I capture multiple repeated groups?

The key distinction is repeating a captured group instead of capturing a repeated group.

As you have already found out, the difference is that repeating a captured group captures only the last iteration. Capturing a repeated group captures all iterations.

In PCRE (PHP):

((?:\w+)+),? 

Match 1, Group 1. 0-5 HELLO Match 2, Group 1. 6-11 THERE Match 3, Group 1. 12-20 BRUTALLY Match 4, Group 1. 21-26 CRUEL Match 5, Group 1. 27-32 WORLD 

Since all captures are in Group 1, you only need $1 for substitution.

I used the following general form of this regular expression:

((?:{{RE}})+) 

Example at regex101

I think you need something like this:

b = "HELLO,THERE,WORLD" re.findall('[\w]+',b) 

Which in Python 3 will return:

['HELLO', 'THERE', 'WORLD'] 

After reading Byte Commander's answer, I want to introduce a tiny possible improvement:

You can generate a regexp that will match either n words, as long as your n is predetermined. For instance, if I want to match between 1 and 3 words, the regexp:

^([A-Z]+)(?:,([A-Z]+))?(?:,([A-Z]+))?$ 

will match the next sentences, with one, two or three capturing groups.

HELLO,LITTLE,WORLD HELLO,WORLD HELLO 

You can see a fully detailed explanation about this regular expression on Regex101.

As I said, it is pretty easy to generate this regexp for any groups you want using your favorite language. Since I'm not much of a swift guy, here's a ruby example:

def make_regexp(group_regexp, count: 3, delimiter: ",") regexp_str = "^(#{group_regexp})" (count - 1).times.each do regexp_str += "(?:#{delimiter}(#{group_regexp}))?" end regexp_str += "$" return regexp_str end puts make_regexp("[A-Z]+") 

That being said, I'd suggest not using regular expression in that case, there are many other great tools from a simple split to some tokenization patterns depending on your needs. IMHO, a regular expression is not one of them. For instance in ruby I'd use something like str.split(",") or str.scan(/[A-Z]+/)

The problem with the attempted code, as discussed, is that there is one capture group matching repeatedly so in the end only the last match can be kept.

Instead, instruct the regex to match (and capture) all pattern instances in the string, what can be done in any regex implementation (language). So come up with the regex pattern for this.

The defining property of the shown sample data is that the patterns of interest are separated by commas so we can match anything-but-a-comma, using a negated character class

[^,]+ 

and match (capture) globally, to get all matches in the string.

If your pattern need be more restrictive then adjust the exclusion list. For example, one can also remove spaces with [^,\s]+. Or, to capture words separated by any of the listed punctuation or spaces

[^,.!\s-]+ 

This extracts all words from hello-again, Mrs. Y!, without any punctuation or spaces. (The - itself must be given first or last in a character class, unless it's used in a range like a-z or 0-9.) Note that this pattern, with -, breaks up hyphenated words, what may not be desired. Further discussion would bring us to the difficulties and subtleties of the natural language parsing.

In Python

import re string = "HELLO,THERE,WORLD" pattern = r"([^,]+)" matches = re.findall(pattern,string) print(matches) 

In Perl (and many other compatible systems)

use warnings; use strict; use feature 'say'; my $string = 'HELLO,THERE,WORLD'; my @matches = $string =~ /([^,]+)/g; say "@matches"; 

(In this specific example, the capturing () in fact aren't needed since we collect everything that is matched. But they don't hurt and in general they are needed.)

Just in case, I'd like to add: The specific text shown in the question is in the CSV (comma-separated-values) format. When all text is indeed like that one is far better off using a library for CSV parsing.

The approach above works as it stands for other patterns as well, including the one attempted in the question (as long as you remove the anchors which make it too specific). The most common one is to capture all words (usually meaning [a-zA-Z0-9_]), with the pattern \w+. Or, as in the question, get only the substrings of uppercase ASCII letters[A-Z]+.

Just to provide additional example of paragraph 2 in the answer. I'm not sure how critical it is for you to get three groups in one match rather than three matches using one group. E.g., in Groovy:

def subject = "HELLO,THERE,WORLD" def pat = "([A-Z]+)" def m = (subject =~ pat) m.eachWithIndex{ g,i -> println "Match #$i: ${g[1]}" } 

Match #0: HELLO Match #1: THERE Match #2: WORLD 

It happened to me today, and I solved it with the following approach:

^(([A-Z]+),)+([A-Z]+)$ 

So the first group (([A-Z]+),)+ will match all the repeated patterns except the final one ([A-Z]+) that will match the final one. And this will be dynamic, no matter how many repeated groups in the string.

You actually have one capture group that will match multiple times. Not multiple capture groups.

JavaScript solution:

let string = "HI,THERE,TOM"; let myRegexp = /([A-Z]+),?/g; // Modify as you like let match = myRegexp.exec(string); // JavaScript function. The output is described below while (match != null) { // Loops through matches console.log(match[1]); // Do whatever you want with each match match = myRegexp.exec(string); // Find next match }

Syntax:

// Matched text: match[0] // Match start: match.index // Capturing group n: match[n] 

As you can see, this will work for any number of matches.

Sorry, not Swift, just a proof of concept in the closest language at hand (JavaScript).

// JavaScript POC. Output: // Matches: ["GOODBYE","CRUEL","WORLD","IM","LEAVING","U","TODAY"] let str = `GOODBYE,CRUEL,WORLD,IM,LEAVING,U,TODAY` let matches = []; function recurse(str, matches) { let regex = /^((,?([A-Z]+))+)$/gm let m while ((m = regex.exec(str)) !== null) { matches.unshift(m[3]) return str.replace(m[2], '') } return "bzzt!" } while ((str = recurse(str, matches)) != "bzzt!") ; console.log("Matches: ", JSON.stringify(matches)) 

Note: If you were really going to use this, you would use the position of the match as given by the regex match function, not a string replace.

1. Design a regex that matches each particular element of the list rather then a list as a whole. Apply it with /g
2. Iterate through the matches, cleaning them from any garbage such as list separators that got mixed in. You may require another regex, or you can get by with simple replace substring method.

The sample code is in JavaScript, sorry :) The idea must be clear enough.

const string = 'HELLO,THERE,WORLD'; // First use following regex matches each of the list items separately: const captureListElement = /^[^,]+|,\w+/g; const matches = string.match(captureListElement); // Some of the matches may include the separator, so we have to clean them: const cleanMatches = matches.map(match => match.replace(',', '')); console.log(cleanMatches); 

Repeat the A-Z pattern in the group for the regular expression.

data = "HELLO,THERE,WORLD" pattern = r"([a-zA-Z]+)" matches = re.findall(pattern, data) print(matches) 

Output

['HELLO', 'THERE', 'WORLD'] 

I had the same problem. No answers to this question helped me. I created a regex that works for me.

(\w+)\W*(\w+)\W*(\w+)\W*(\w+)\W*(\w+)\W*(\w+)*\W*(\w+)* Example HELLO,THERE,BRUTALLY,CRUEL,WORLD $1=HELLO $2=THERE $3=BRUTALLY $4=CRUEL $5=WORLD ($6="") ($7="") 

The groups are created within the match, so to make each word a group you have to make that number of matches. I tried the below RegEx with RegexBuddy .NET flavour and I got the expected result.

However, with this approach, you will get multiple matches and within each match, Group 1 will hold the value of the captured word.

([A-Z]+),?