How do I find the number of values in a Perl list?

The number of values in a list can only be determined by iterating ove开发者_StackOverflow中文版r its values, or converting it to an array. Assigning it to a scalar won't return the items count:

my $n = ('a', 'b', 'c');  # $n = 'c' 

There's an "empty parentheses" idiom, that can be used to get the number of elements:

my $n = () = ('a', 'b', 'c'); # $n = 3

Is it equivalent internally to

my $n = @{[ 'a', 'b', 'c' ]};

?

The two items you showed are not equivalent. But they have the same final result;

my $n = @{[ 'a', 'b', 'c' ]};

Here you create an anonymous array [ 'a', 'b', 'c' ], then dereference it and take the count of members. The creation of the array provides a list context to the comma operators in the statement.

my $n = () = ('a', 'b', 'c');

Here we use the infamous "goatse operator". The list ('a', 'b', 'c') is assigned to an empty list () = ('a', 'b', 'c'); . The result of the list assignment is assigned to $n. List assignment returns the number of items on the right hand side of the assignment in scalar context (in list context, you get the list of values assigned to).

This is an interesting implementation detail: Does the assignment to an empty list create an (unnecessary) anonymous array?

There are two ways of answering this question: First, The Right Way: Try to figure out how this might be handled in the source. Is there a special case for assignment to an empty list evaluated in scalar context?

Being the lazy and ignorant type, I chose to use Benchmark:

#!/usr/bin/perl

use strict; use warnings;
use Benchmark qw( cmpthese );

cmpthese -5,  {
    goatse => sub { my $n = () = 'A' .. 'Z' },
    anon   => sub { my $n = @{[ 'A' .. 'Z' ]}},
};

I ran the benchmark a bunch of times, and the assignment to empty list had a slight advantage in all cases. If the difference were purely random, the probability of observing 10 timings all in favor of goatse is less than 0.1%, so I am assuming there is some kind of short circuit.

On the other hand, as running the benchmark @daotoad posted in the comments, probably gives a more complete picture:

#!/usr/bin/perl

use strict; use warnings;
use Benchmark qw( cmpthese );

use constant START => 1;
use constant STOP => 1000;

my $start = START;
my $stop = STOP;

cmpthese -5, {
    anon => sub { my $n = @{[ $start .. $stop ]}},
    goatse => sub { my $n = () = $start .. $stop },
    canon => sub { my $n = @{[ START .. STOP ]}},
    cgoatse => sub { my $n = () = START .. STOP },
};

Typical results on my machine (Windows XP Pro SP3, Core 2 Duo, 2 Gb memory, ActiveState perl 5.10.1.1006):

           Rate    anon cgoatse  goatse   canon
anon     5207/s      --    -45%    -49%    -51%
cgoatse  9522/s     83%      --     -7%    -10%
goatse  10201/s     96%      7%      --     -4%
canon   10636/s    104%     12%      4%      --

And, with:

use constant START => 'AAAA';
use constant STOP => 'ZZZZ';

the results are:

          Rate    anon  goatse cgoatse   canon
anon    1.73/s      --    -12%    -16%    -17%
goatse  1.98/s     14%      --     -4%     -5%
cgoatse 2.06/s     19%      4%      --     -1%
canon   2.08/s     20%      5%      1%      --

Conclusion:

If in doubt, use my $n = () = ...;

No. It's equivalent to:

my $n = (() = ('a', 'b', 'c'));

...since the assignment operator is right-associative. The parenthesized list assignment on the right is itself in scalar context, and so its value is the number of items on its right-hand side.

When used in a scalar context, a list evaluates to the number of items within it:

my @list = ('a', 'b', 'c');
my $list_size = @list;

To do an explicit test, such as in an if condition:

my @list = ('a', 'b', 'c');
if (scalar @list == 3) {
  print "@list"; # prints list separated with spaces
}

That will work without the 'scalar' keyword as well. However, that can make your code difficult to scan. Context is a wonderful idea, but it requires more work from the reader. Using scalar explicitly allows the reader to immediately see that you are evaluating @list in a scalar context.

How do I find the number of values in a Perl list?

Assign the list into an @array variable and get the size of the @array using scalar(@array) or using the operation $#array+1. Define sub count {scalar @_} and use calls to count if you have to do this a lot.

my $n = () = ('a', 'b', 'c'); # $n = 3

Sure you can use that... if you want Perl to continue having a bad name as a readonly language... :(

You can use the following code also, to count the no of element in the array or list

use strict;
use warnings;
my @array=(1,2,3,4);
my $i=0;
  foreach(@array)
  {
              $i++;
  }   
 print "The count is:$i\n";

In order to learn the size of array:

1. Use scalar() to make it explicit (for array references you need to unrefer them via @{...}):

   $ perl -e '$n = scalar(qw(1 2 3)); print $n . "\n"'
   3
   

2. Use $# (add plus one to get the size):

   $ perl -e '$n = [ 1, 2, 3]; print $#$n . "\n"'
   2
   $ perl -e 'print $#{[ 1, 2, 3]} . "\n"'
   2
   

Perl: there are at least two ways to do it :)