11

I have a nice little bash script which parses a message for a regular expression and does something with the capture groups:

regex='\((Closes|Resolves):\s([0-9]+)\)'
msg='Fixed a problem (Closes: 1234), (Resolves: 5678)'

if [[ $msg =~ $regex ]] ; then
  action="${BASH_REMATCH[1]}"
  issue="${BASH_REMATCH[2]}"
  do_something $action $issue
fi

This works well for the first match, but if there are multiple matches msg, later matches are ignored. Is there a way for me to loop through each match or is it time to start thinking of python or perl?

Improve this question

2 Answers 2

Reset to default
13

It's not explicitly supported by built-in bash syntax, but it can be easily achieved with a little variable substitution and some recursion.

function do_something {
  echo $1 $2
}

function handlematches {
  regex='\((Closes|Resolves):\s([0-9]+)\)'
  msg=$1

  if [[ $msg =~ $regex ]] ; then
    action="${BASH_REMATCH[1]}"
    issue="${BASH_REMATCH[2]}"
    do_something "$action" "$issue"

    # Remove the first regex match and try again
    handlematches "${msg/${BASH_REMATCH[0]}/}"
  fi
}

message='Fixed a problem (Closes: 1234), (Resolves: 5678)'
handlematches "$message"

Output:

Closes 1234
Resolves 5678
Improve this answer
5

Similar to Stewart's answer, but using an iterative rather than recursive approach:

regex='\((Closes|Resolves): ([0-9]+)\)'
msg='Fixed a problem (Closes: 1234), (Resolves: 5678)'

while [[ $msg =~ $regex ]]; do
        action=${BASH_REMATCH[1]}
        issue=${BASH_REMATCH[2]}
        do_something "$action" "$issue"

        msg=${msg/"${BASH_REMATCH[0]}"/}
done

This iterates over the string in $msg until the regular expression no longer matches. In each iteration, the matching bit is remove using a bash parameter substitution.

If you want to hold on to the original $msg, then make a copy of it in another variable first.

With

do_something () {
        printf 'action=%s, issue=%s\n' "$1" "$2"
}

this outputs

action=Closes, issue=1234
action=Resolves, issue=5678
Improve this answer
13
  • This is a good approach to this question, but in general you have to be careful with patterns that match empty strings, like word boundaries and ^ and $. E.g. regex='^.' would run do_something on every character. Commented Jul 9 at 19:48
  • @SpinUp__ADavis Do you suggest that the solution should check whether the given regular expression matches the correct thing? I’m afraid that would be extremely difficult to do. Commented Jul 10 at 4:16
  • I just wanted to point out the caveat that it's very difficult to make this approach work in general. In particular, people should avoid using patterns with word boundaries and anchors, since there isn't a similar construct in shell patterns. It would be much easier if Bash provided us with the index of the match from =~, then we could simply lop off that part of the string, instead of relying on pattern matching with {foo/.../}, or indeed {foo#*...}. Commented Jul 15 at 14:32
  • @SpinUp__ADavis I don't believe I'm using word boundaries or anchors in my answer. Could you say more about what you are referring to? Also, what would make my approach with msg=${msg/"${BASH_REMATCH[0]}"/} fail? I'm removing the first match of the matched substring from the string in msg. This gives us a new string that we can match against again, until there are no more matches. Note the quoting of ${BASH_REMATCH[0]}. Without the quotation marks, it would be interpreted as a regular expression, which might not work as expected. Commented Jul 15 at 15:45
  • Absolutely, your answer is totally valid, no word boundaries or anchors. Note, though, that this is not correct: "Without the quotation marks, it would be interpreted as a regular expression". It would in fact be interpreted as a shell pattern, which doesn't have a notion of matching non-printing characters. Commented Jul 15 at 21:43

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.