$_ is a global variable. Your while is setting it to the last record of your filehandle and since your files end with a \n, $_ returns blank (I guess $_ gets set before the test is done to see if it has a value). Since this is Perl there is more than one way to get around this:

You can localize $_ in your sub like so:

sub screwed {
  my ($in) = @_;

  local $_; # basically a temporary $_ just for this sub  

  open(IN, "<$in");
  while(<IN>) { print "file $in contains $_"; }
  close(IN);
}
[download]

while(defined(my $foo = <IN>)) { print "file $in contains $foo"; }
[download]

Hope that helps

To elaborate a bit (it took me some experimenting to realize why cfreak is right), inside a map the variable $_ is magic. While each entry in the list is evaluated, $_ is an alias to that entry. Assigning a new value to $_ changes the value of the current list entry. Because you're calling screwed from within map without localizing $_, it's being assigned to each successive line in the file, and then set to undef to indicate end-of-file. When screwed returns, $_ is still set to undef, so all entries in the list are changed to undef.

You can verify this by changing screwed to:

sub screwed {
  $_ = 'hi';
}
[download]

in which case you'll get:

before a
before b
after hi
after hi

How come while(<IN>){}, but not for (@x) {}? why is while (<IN>) so special?

I love perl, but this scares the hell out of me.
--Bob Niederman, http://bob-n.com

Nevermend. I think I get it - someone else posted that while(<>){} is the same as while($_=<>){} - it does an assignment to $_ and that's what does the damage.

Somehwere, I think I remember someone (Tom Christiansen, I think) saying to always localize $_ in subroutines. Now I know why.

--Bob Niederman, http://bob-n.com

screwed $_;
[download]

screwed "$_";
[download]

map {function($_)} @array;
[download]

@result_set = map {function($_)} @array
[download]

foreach (@array) {sub_without_meaningful_return($_)}
[download]

and now for something entirely different..

just as an aside, using map in a void context (i.e. not returning anything), is generally considered a BadThing(TM). If you are simply looking for a way to do simple single line loops, you can always use for().. ala

print "before: $_\n" for @instances;
screwed "$_"         for @instances;
print "after: $_\n"  for @instances;
[download]

You might already know this, you might not, but I figured I would toss it out there. The reason it't not so good, is Perl can go through a lot of trouble to build a list of things to return from the map block, and if you don't use them its simply a waste of processor time and memory that could be better spent doing other things.

use perl;

my first attempt was with

foreach(@instances) { screwed "$_"; };
[download]

and then when it didn't work i showed it to someone here at work and he introduced me to maps so i used

map { screwed "$_"; } @instances;
[download]

but...

screwed "$_" for @instances;
[download]

..is even less typing again!

print "before $_\n" for @instances;
screwed $_          for @instances;
print "after $_\n"  for @instances;
[download]

--
I'd like to be able to assign to an luser

I'm not surprised you are confused:) I get the same behaviour with AS 5.8.

This isn't a bug, and what's more it is a doosy. I'm amazed I didn't recognise this as the normal behaviour of while. this hasn't shown up earlier. Actually I did, after trying to sleep for about 2 hours later. D'oh. It's the heat.

The problem lies with the while statement. Somehow, the aliasing of the input to $_ is getting mixd up with the first element of @_. This can be seen by printing the contents of the array just before the while and again inside it. Inside the loop, the first element of the array has been overwritten by the input from the diamond operator. At the end of the while loop, this then gets set to null. The original contents have been blown away!!

A work around is to explicitly localise $_ in the while as shown commented out above.

I'll raise a perlbug against this.

I'll raise a perlbug against this.

Please don't. It's documented in perlvar. Search for nasty_break().

wowzers! thanks for the super fast responses, i pop out to lunch and look what happens :)

i also tried mapping <in>, as in...

map { print "file $in contains $_"; } <IN>;
[download]

and that works ok.

mat

Somehow, the aliasing of the input to $_ is getting mixd up with the first element of @_

When you do screwed($_) variable $_ gets aliased to $_[0] inside screwed() as subroutine parameters always aliased to elements of @_ array inside the subroutine. So later when while loop modifies $_ it affects $_[0] too.

Shorter demo:

$_ = 1;

test($_);

sub test {
    $_ = 2;
    print $_[0], "\n";
}

# output of script
__END__
2
[download]

Yet another example why I think while(<>) { ... } considered harmful.

--
Ilya Martynov, ilya@iponweb.net
CTO IPonWEB (UK) Ltd
Quality Perl Programming and Unix Support UK managed @ offshore prices - http://www.iponweb.net
Personal website - http://martynov.org

I just wanted to say THANK YOU, I was just bitten by this, and would never have figured it out if it wasn't for this thread. In my case the while appears to have been in a module I was using.