Perl Cd Bookshelf [Electronic resources] نسخه متنی

با بیش از 100000 منبع الکترونیکی رایگان به زبان فارسی ، عربی و انگلیسی

4.5. Iterating Over an Array

4.5.1. Problem

You want to repeat a
procedure for every element in a list.

Often you use an array to collect information you're interested in;
for instance, login names of users who have exceeded their disk
quota. When you finish collecting the information, you want to
process it by doing something with every element in the array. In the
disk quota example, you might send each user a stern mail message.

4.5.2. Solution

Use a foreach loop:

foreach $item (LIST) {
# do something with $item
}

4.5.3. Discussion

Let's say we've used @bad_users to compile a list
of users who are over their allotted disk quotas. To call some
complain subroutine for each user, we'd use:

foreach $user (@bad_users) {
complain($user);
}

Rarely is this recipe so simply applied. Instead, we often use
functions to generate the list:

foreach $var (sort keys %ENV) {
print "$var=$ENV{$var}\n";
}

Here we're using sort and keys
to build a sorted list of environment variable names. If you use the
list more than once, you'll obviously keep it around by saving in an
array. But for one-shot processing, it's often tidier to process the
list directly.

Not only can we add complexity to this formula by building up the
list in the foreach, we can also add complexity by
doing more work inside the code block. A common application of
foreach is to gather information on every element
of a list and then, based on that information, decide whether to do
something. For instance, returning to the disk quota example:

foreach $user (@all_users) {
$disk_space = get_usage($user); # find out how much disk space in use
if ($disk_space > $MAX_QUOTA) { # if it's more than we want ...
complain($user); # ... then object vociferously
}
}

More complicated program flow is possible. The code can call
last to jump out of the loop,
next to move on to the next element, or
redo to jump back to the first statement inside
the block. Use these to say "no point continuing with this one, I
know it's not what I'm looking for" (next), "I've
found what I'm looking for, there's no point in my checking the rest"
(last), or "I've changed some things, I'd better
run this loop's calculations again" (redo).

The variable set to each value in
the list is called a loop variable or
iterator variable. If no iterator variable is
supplied, the global variable $_ is used.
$_ is the default variable for many of Perl's
string, list, and file functions. In brief code blocks, omitting
$_ improves readability. (In long ones, though,
too much implicit use hampers readability.) For
example:

foreach (`who`) {
if (/tchrist/) {
print;
}
}

or combining with a while loop:

while (<FH>) { # $_ is set to the line just read
chomp; # $_ has a trailing \n removed, if it had one
foreach (split) { # $_ is split on whitespace, into @_
# then $_ is set to each chunk in turn
$_ = reverse; # the characters in $_ are reversed
print; # $_ is printed
}
}

Perhaps all these uses of $_ are starting to make
you nervous. In particular, the foreach and the
while both give values to $_.
You might fear that at the end of the foreach, the
full line as read into $_ with
<FH> would be forever gone.

Fortunately, your fears would be
unfounded, at least in this case. Perl won't permanently clobber
$_'s old value, because the
foreach's iterator variable (here,
$_) is automatically preserved during the loop. It
saves away any old value on entry and restores it upon exit.

However, there is some cause for concern. If the
while had been the inner loop and the
foreach the outer one, your fears would have been
realized. Unlike a foreach loop, the
while (<FH>) construct
clobbers the value of the global $_ without first
localizing it! So any routine—or block for that
matter—that uses this construct with $_
should declare local $_.

If a lexical variable (one declared with my) is in
scope, the temporary variable will be lexically scoped, private to
that loop. Otherwise, it will be a dynamically scoped global
variable. To avoid strange magic at a distance, write this more
obviously and more clearly as:

foreach my $item (@array) {
print "i = $item\n";
}

The foreach
looping construct has another feature: each time through the loop,
the iterator variable becomes not a copy of but rather an
alias for the current element. This means that
when you change that iterator variable, you really change each
element in the list:

@array = (1,2,3);
foreach $item (@array) {
$item--;
}
print "@array\n";
0 1 2
# multiply everything in @a and @b by seven
@a = ( .5, 3 ); @b = ( 0, 1 );
foreach $item (@a, @b) {
$item *= 7;
}
print "@a @b\n";
3.5 21 0 7

You can't change a constant, though, so this is illegal: