my $last_match;

while ( <DATA> ) {
   if ( /^([A-Z]+)$/ ) { print "In if:   $1\n"; $last_match = $1; }
   else { print "In else: $last_match\n"; }
}
__DATA__
FOO
1234
Xyz
BAR
DFgdfg
[download]

Speculation: As for why it's doing this, I have a guess that as the regex engine goes left to right across the string, it starts matching and filling up the buffer for $1 with uppercase characters, clobbering what was in it before. It doesn't fail until it gets to a lowercase character (when the regex is expecting the end of string), but $1 is already trashed. When the non-matching strings in your __DATA__ started with lowercase letters, the regex could fail before even trying to fill the buffer for $1, so it was not clobbered and the old value remained.

Why you still ended up getting exactly the old first character though is a mystery to me.

You are trying to use $1 after a failing match, so basically you deserve whatever's coming to you ;)

Thanks, blokhead. That's more or less what I'd intuited. But, in that case:

1) Why doesn't the 'failing match' clobber $1 in my first two snippets?

2) With respect to the docs:

The numbered variables ($1, $2, $3, etc.) ... are all dynamically scoped until the end of the enclosing block or until the next successful match, whichever comes first.

This seems to suggest that $1 (provided that it stays in scope) should not change until a match succeeds, rather than being clobbered if a match fails (which, I'm sure you'll agree, is not the same thing...).

Why you still ended up getting exactly the old first character though is a mystery to me.

To me too...

Still Confused,

dave

I would agree with you that, this is a problem, as the behavior is not consistant.

However this can also be looked at from a different angle. Although it is not clearly stated, or only vaguely mentioned, it is unsafe to use $1 after a failed match, and it is up to you to execise your caution.

I consider this as some sort of grey area. It will be nice if the consistancy is there, but that kind of consistancy was not clearly promised.

By the way, in your first piece of code, there is no need to initialize the hash elements to 0. This is Perl ;-)

my %totals;
while ( <DATA> ) {
   chomp;
   if ( /(^[a-z].*$)/i ) {
   #I deleted the initialization here, and you still get what you expe
+cted
   }
   else {
      $totals{$1} += $_;
  }
}
print "$_: $totals{$_}\n" for keys %totals;

__DATA__
player1
11
22
11
player2
10
21
player1
22
[download]

By the way, in your first piece of code, there is no need to initialize the hash elements to 0. This is Perl ;-)

Thanks, you're right, of course. However, I happen to hate empty if blocks.

Don't worry, it's just a personal thing ;-). So I re-wrote my original code (which I'll probably never use again since it's proved so fragile):

my %totals;
while ( <DATA> ) {
   chomp;
   /(^[a-z].*$)/i or $totals{$1} += $_;
}
[download]

Thanks again for the tip.

dave

In if:   FOO
In else: 
In else: 
In if:   BAR
In else:
[download]

In if:   FOO
In else: FOO
In else: 
In if:   BAR
In else: BA
[download]

NOTE: failed matches in Perl do not reset the match variables, which makes easier to write code that tests for a series of more specific cases and remembers the best match.

The numbered match variables ($1, $2, $3, etc.) and the related punctuation set ($+, $&, $`, $', and $^N) are all dynamically scoped until the end of the enclosing block or until the next successful match, whichever comes first. (See perlsyn/"Compound Statements".)

$ perl -we'$_="FOO"; /^([A-Z]+)$/, print $1; $_="Foo"; /^([A-Z]+)$/; p
+rint $1'
FOOFOO
$ perl -we'for ("FOO","Foo") {/^([A-Z]+)$/; print $1 }'
FOOF
[download]

Others have fleshed out the whys and wherefors wrt the behavior you've experienced, but I just wanted to mention that perhaps some important information has left the perl documentation. For as long as I can remember (since 1992ish) I've always followed the practice that the numbered vars are only good until the next match that contains parenthesised bits (regardless of that match's success or failure). I think I read in the perl man page at the time or perhaps in the pink camel that this was the only safe way to proceed and it's never steered me wrong. Perhaps that has gone missing from the docs (I didn't see it just now when I looked) or maybe perl is actually supposed to not clobber $1 and friends unless the entire pattern matches. Either way, I think a doc patch is necessary.