I just assumed that the parenthesis would define a capturing group, but they don’t. If I understand it well, parenthesis are necessary, but not sufficient to form a capturing group.

I have some experience with regular expressions but this perl dialect really is new to me (shame on Roland).

If I understand well, that the non-capturing patterns are quite like the “anchors” $ and ^. So, they match a particular *position* in the text, *not* a piece of text as such, right?

kind regards,

Roland Bouman

$fk =~ s#(?<=()([^)]+)(?=))#join(’, ‘, sort(split(/, /, $1)))#ge;

$fk =~ s means “match and replace on the $fk variable.” This alters the variable in place.

The # is an alternate delimiter for the s operation, which is usually of the form s/pattern/replacement/modifiers. But you can choose your own delimiters if you’re going to have to backslash a lot of / characters within the pattern or something. I chose #.

The whole line is then $fk =~ s#pattern#replacement#ge. The modifiers are g for ‘global’ and e for ‘execute’. The ‘execute’ option means to search for the pattern, interpolate $1 (the first capturing group) into the substitution pattern, then instead of just doing string replacement, execute the substitution pattern as code, and use the result as the replacement value.

As for the pattern itself, there are three groups: (?<=\(), ([^\)]+), and (?=\)). The first is a non-capturing assertion that says “the pattern must be preceded by a left paren.” This is called a lookbehind assertion. This does not get included in the match, just asserts something must be true at the lefthand side of the match. The second is the actual capture, which finds every character that isn’t a right paren, and then there’s a lookahead assertion, which says “the pattern must be followed by a right paren.” So this pattern is grabbing whatever is inside the parentheses. That’s the column names.

Finally, when the substitution code executes, it splits the column names on a comma followed by a space, which returns a list of the column names themselves; this gets sorted alphabetically, and then joined together with a comma and space again.

Whew!

Perl is a neat language. It can be the devil to maintain, but when it’s written with care, it’s as maintainable as any other language. That said, I should follow the suggestions in Perl Best Practices (the “Dog Book”) and make this pattern more readable with inline comments. There’s another modifier, x, which allows patterns to span multiple lines and have comments. That helps a lot.

Lemme see if I get this:

$fk =~ s#(?<=()([^)]+)(?=))#join(', ', sort(split(/, /, $1)))#ge;

So,

match a literal “(”:

(
?<=
(
)

followed by one or more characters not like “)”:

(
[
^)
]+
)

followed by a literal “)”:

(?=))

So far I get it. Now it works “inward-out” starting a the split

split(/, /, $1)

which probably means: split the matched group $1 at the comma’s , but I expected $1 to correspond with with the match made by (?< =\(), but clearly this is wrong as it should split whatever was matched by ([^\)]+). Or start the indices at 0?

I think I know what sort and join then do, but I don’t understand the semantics of the # and the leading ~ s (ignore whitespace? guessing..)

Anyway, thanks for this addition. I’m still not a perl user, but this kind of thing is seriously tempting me…:)