Daftar Isi

• map BLOCK LIST

• map EXPR,LIST

  Evaluates the BLOCK or EXPR for each element of LIST (locally setting$_ to each element) and returns the list value composed of theresults of each such evaluation. In scalar context, returns thetotal number of elements so generated. Evaluates BLOCK or EXPR inlist context, so each element of LIST may produce zero, one, ormore elements in the returned value.

   @chars = map(chr, @numbers);
   

  translates a list of numbers to the corresponding characters.

   my @squares = map { $_ * $_ } @numbers;
   

  translates a list of numbers to their squared values.

   my @squares = map { $_ > 5 ? ($_ * $_) : () } @numbers;
   

  shows that number of returned elements can differ from the number ofinput elements. To omit an element, return an empty list ().This could also be achieved by writing

   my @squares = map { $_ * $_ } grep { $_ > 5 } @numbers;
   

  which makes the intention more clear.

  Map always returns a list, which can beassigned to a hash such that the elementsbecome key/value pairs. See perldata for more details.

   %hash = map { get_a_key_for($_) => $_ } @array;
   

  is just a funny way to write

   %hash = ();
   
   foreach (@array) {
   
   $hash{get_a_key_for($_)} = $_;
   
   }
   

  Note that $_ is an alias to the list value, so it can be used tomodify the elements of the LIST. While this is useful and supported,it can cause bizarre results if the elements of LIST are not variables.Using a regular foreach loop for this purpose would be clearer inmost cases. See also grep for an array composed of those items ofthe original list for which the BLOCK or EXPR evaluates to true.

  If $_ is lexical in the scope where the map appears (because it hasbeen declared with my $_), then, in addition to being locally aliased tothe list elements, $_ keeps being lexical inside the block; that is, itcan't be seen from the outside, avoiding any potential side-effects.

  { starts both hash references and blocks, so map { ... could be eitherthe start of map BLOCK LIST or map EXPR, LIST. Because Perl doesn't lookahead for the closing } it has to take a guess at which it's dealing withbased on what it finds just after the{. Usually it gets it right, but if itdoesn't it won't realize something is wrong until it gets to the } andencounters the missing (or unexpected) comma. The syntax error will bereported close to the }, but you'll need to change something near the {such as using a unary + to give Perl some help:

   %hash = map {  "\L$_" => 1  } @array  # perl guesses EXPR.  wrong
   
   %hash = map { +"\L$_" => 1  } @array  # perl guesses BLOCK. right
   
   %hash = map { ("\L$_" => 1) } @array  # this also works
   
   %hash = map {  lc($_) => 1  } @array  # as does this.
   
   %hash = map +( lc($_) => 1 ), @array  # this is EXPR and works!
   
   
   %hash = map  ( lc($_), 1 ),   @array  # evaluates to (1, @array)
   

  or to force an anon hash constructor use +{:

     @hashes = map +{ lc($_) => 1 }, @array # EXPR, so needs comma at end
   

  to get a list of anonymous hashes each with only one entry apiece.