In the case of b*, it matches zero times at the start of the string (ie before the first character) - which is as many as it can, because there are not more than 0 leading b's in your string.

In the case of b+, the empty match is not successful, so the regex engine bumps along, and tries to match as many b's as possible, starting from the second position (ie string index 1).

So both are greedy, but neither do a search for longest match of consecutive b's. try

$ perl -lwe '"abbabbbbc"=~/(b+)/ && print "Found: $1"'
Found: bb
[download]

It used the first position where b+ matched, and there took as many b's as possible.

In the second case, the "." says any first character then zero or more b's, since we got to the b's, we get them all. Same thing in the 3rd example.

"abbbbc"=~/(b*)/ && print "Found: $1\n";  #(no b's)
"abbbbc"=~/.(b*)/ && print "Found: $1\n"; #bbbb
"bbbbbc"=~/(b*)/ && print "Found: $1\n";  #bbbbb
[download]

This is a "further" question re the replies from moritz and Marshall.

And in following their answers, I found it helpful to remember that "greedy" is not the same as "global." While (b*) is greedy, it is not global, /(b*)/g. In other words (I thought) /(b*)/ stops after the first (moritz caught this)failure success , at the start of the string, whereas adding the /g would tell the regex engine to keep on trying until it reaches the end of the string.

Well, that was my second thought.

But, OOOPS,

"abbbbc"=~/(b*)/g && print "Found: $1";
# Found:
[download]

Huh?

Well, is this a case where the rules are different in substitution?

my $string1 = "abbbbc";

my $found1 = $string1 =~ s/(b*)/^/g;

print "\$string1: $string1, \$found1: $found1"; $found1 is 4

=head

after s///  $string: ^a^^c^
At begin of string
    ...no "b" found |         # satisfies "0 or more 'b's"
         "a" (duh!)  |
     Two "b"(s) found |       # likewise; the first and second 'b's ar
+e conflated? 
         and again     |
             "c"        |
     no "b" after "c"    |
=cut
[download]

That this code produces two replacements for the string of four 'b's remains a puzzle. Why does this appear (this may be my error) that the regex conflates two 'b's rather than all four?

Enlightenment?
or Coffee?

Update: Wonderful answer below. s/failure/success/ per moritz; italics closed per ssandv.

In other words (I thought) /(b*)/ stops after the first failure, at the start of the string,

s/failure/success/

whereas adding the /g would tell the regex engine to keep on trying until it reaches the end of the string.

What /g does on a regex depends on context. In boolean scalar context it matches once, and stores the position in pos. If you execute it a second time, it starts off from where it left.

The background is that you can write

while (/(b*)/g) {
...
}
[download]

and get a new match for each iteration:

$perl -e '$_="abbbabc";
while (/(b*)/g) { print "($1)\n" }'
()
(bbb)
()
(b)
()
()
[download]

Update: Answer to the second question

That this code produces two replacements for the string of four 'b's remains a puzzle. Why does this appear (this may be my error) that the regex conflates two 'b's rather than all four?

A naiive substitution implementation would loop on s/b*/^/, because it would continue to replace the empty string with ^ forever on.

Perl is a bit more sophisticated: It detects a zero-width match, and before doing a second substition of a zero-width match at the same position it bumps along, and tries in the next position.

So applying s/b*/^/ on abba make these steps:

abba
| match zero b's before a
^abba
 | match zero b's again. Don't substitute here, bump along
^abba
  | match 'bb'
^a^a
   | match zero b's
^a^^a
    | match zero b's, don't substitute but bump along
^a^^a^
     | match zero b's, don't substitute but bump along
[download]

You can watch it work; I didn't find a way to get the modified string, but at least you can monitor the match positions:

$ perl -le '$_ = "abba"; s/b*/print pos; "^"/eg; print'
0
1
3
4
^a^^a^
[download]

Perl 6 - links to (nearly) everything that is Perl 6.

If you execute it a second time, it starts off from where it left.

If that where true, while (/(b*)/g) would never finish. It starts where it finished the previous time, unless it matched an empty string. In the latter case, pos() will be advanced by one. (Details are even more complicated. But documented. See the section "Repeated Patterns Matching a Zero-length Substring" in the perlre manual page.)

In the case of b*, it matches zero times at the start of the string

Thanks a lot.