Grep and Map in Perl

vice versa · Note:

foreach
grep
map
grep
map
BLOCK
EXPR
LIST
BLOCK
grep BLOCK LIST
grep EXPR, LIST
$_
 @foo = grep(!/^#/, @bar) # weed out comments
@foo = grep {!/^#/} @bar; # weed out comments
$_
grep
foreach

      map

      grep
$_
grep
my $_
$_
$num_apple = grep /^apple$/i, @fruits;
@bought_fruits=grep /^apple$/i, @fruits;
grep
grep
 grep, 
$_
@files
@jpgs
.jpg
@jpgs = grep(/\.jpg$/,@files);
ls
@non_a_directory = grep(! -d, @list);
grep
for ($i=0; $i<@x; i++) {
   if (x[i]>0) {
      y[j++]=x[i]
   }
}
@y=grep($_>0,@x);
map
grep
$_
print "Program arguments are:\n", map("  '$_'\n", @ARGV);
@files
@sizes
@sizes = map(-s,@files);
foreach @files { $sizes($i++)= -s; }
-s
$_
map
map($sizes{$_} = -s, @files);
%sizes
map
$_ 
, 
map
$_
@selected = grep EXPR, @input;
@selected = map { if (EXPR) { $_ } } @input;
@a = (0 .. 9, 'a' .. 'z');
$password = join '', map { $a[int rand @a] } 0 .. 7;
print "$password\n";
y2ti3dal
# Trashes @array  :(
@digitless = map { tr/0-9//d; $_ } @array;    

# Preserves @array  :)
@digitless = map { ($x = $_) =~ tr/0-9//d;    
                   $x; 
                 } @array;
@sizes = map { -s $_ } @file_names;
%dictionary = map { $_, 1 } qw(cat dog man woman hat glove);
@caps = map uc, @phrases;
@first_word = map { /(\S+)/ } @phrases;
@words = map split, @phrases;
$title = join ' ', map { ucfirst lc } split / /, $name;
print "<table>\n";

print map {"<tr><td>$_</td><td>$hash{$_}</td></tr>\n"} sort keys %hash;

print "</table>\n";
if ( grep { $_ eq $clientAddress} @ip_addresses ) {
  # the array already contains this ip address; skip it this time
  next;
} else {
  # the array does not yet contain this ip address; add it
  push @ip_addresses, $clientAddress;
}
if ( grep { $_ eq '192.168.1.100'} @ip_addresses )

# create a perl list/array of strings
@pizzas = qw(cheese pepperoni veggie sausage spinach garlic);

# use the perl grep function to search the @pizzas list for the string "pepper"
@results = grep /pepper/, @pizzas;

# print the results
print "@results\n";

pepperoni

@results = grep /pepper/i, @pizzas;

@results = grep /\w{8}/, @pizzas;

pepperoni

my @list = qw(one two three four five);

my @containing_o = grep { /o/ } @list;

my @index_containing_o = grep { $list[$_] =~ /o/ } 0..$#list;  # ==> (0,1,3)

my %hash_of_containing_o = map { $list[$_]=~/o/?($list[$_]=>$_):() } 0..$#list
            # ==> ( 'one' => 0, 'two' => 1, 'four' => 3 )

Foreach $element (@A){
    if($element eq $B){
        print "$B is in array A";
    }
}
index(@A,$B)=>0
foreach my $element (@a) {
    if($element eq $b) {
       # do something             
       last;
    }
}

my $found = grep { $_ eq $b } @a;

use List::Util qw(first); 

my $found = first { $_ eq $b } @a;

my %check;
@check{@a} = ();

my $found = exists $check{$b};

my %check = map { $_ => 1 } @a;

my $found = $check{$b};

use 5.10.1;

$B ~~ @A and say '$B in @A';

use List::AllUtils qw/ any /;
print "\@A contains $B" if any { $B eq $_ } @A;

open FILE "<myfile" or die "Can't open myfile: $!";
print grep /terrorism|nuclear/i, <FILE>;
while ($line = <FILE>) {
    if ($line =~ /terrorism|nuclear/i) { print $line }
}
$num_apple = grep /^apple$/i, @fruits;
@unique = grep { ++$count{$_} < 2 } 
               qw(a b a c d d e f g f h h);
print "@unique\n";

a b c d e f g h
@crops = qw(wheat corn barley rice corn soybean hay 
            alfalfa rice hay beets corn hay);
@dupes = grep { $count{$_} == 2 } 
              grep { ++$count{$_} > 1 } @crops;
print "@dupes\n";

rice
@files = grep { -f and -T } glob '* .*';
print "@files\n";
@array = qw(To be or not to be that is the question);
print "@array\n";
@found_words = 
    grep { $_ =~ /b|o/i and ++$counts{$_} < 2; } @array;
print "@found_words\n";

To be or not to be that is the question
To be or not to question

# An array of references to anonymous arrays
@data_points = ( [ 5, 12 ], [ 20, -3 ], 
                 [ 2, 2 ], [ 13, 20 ] );
@y_gt_x = grep { $_->[1] > $_->[0] } @data_points;
foreach $xy (@y_gt_x) { print "$xy->[0], $xy->[1]\n" }

5, 12
13, 20
# @database is array of references to anonymous hashes 
@database = ( 
    { name      => "Wild Ginger", 
      city      => "Seattle",
      cuisine   => "Asian Thai Chinese Japanese",
      expense   => 4, 
      music     => "\0", 
      meals     => "lunch dinner",
      view      => "\0", 
      smoking   => "\0", 
      parking   => "validated",
      rating    => 4, 
      payment   => "MC VISA AMEX", 
    },
#    { ... },  etc.
);

sub findRestaurants {
    my ($database, $query) = @_;
    return grep {
        $query->{city} ? 
            lc($query->{city}) eq lc($_->{city}) : 1 
        and $query->{cuisine} ? 
            $_->{cuisine} =~ /$query->{cuisine}/i : 1 
        and $query->{min_expense} ? 
           $_->{expense} >= $query->{min_expense} : 1 
        and $query->{max_expense} ? 
           $_->{expense} <= $query->{max_expense} : 1 
        and $query->{music} ? $_->{music} : 1 
        and $query->{music_type} ? 
           $_->{music} =~ /$query->{music_type}/i : 1 
        and $query->{meals} ? 
           $_->{meals} =~ /$query->{meals}/i : 1 
        and $query->{view} ? $_->{view} : 1 
        and $query->{smoking} ? $_->{smoking} : 1 
        and $query->{parking} ? $_->{parking} : 1 
        and $query->{min_rating} ? 
           $_->{rating} >= $query->{min_rating} : 1 
        and $query->{max_rating} ? 
           $_->{rating} <= $query->{max_rating} : 1 
        and $query->{payment} ? 
           $_->{payment} =~ /$query->{payment}/i : 1
    } @$database;
}

%query = ( city => 'Seattle', cuisine => 'Asian|Thai' );
@restaurants = findRestaurants(\@database, \%query);
print "$restaurants[0]->{name}\n";

Wild Ginger

@selected = grep EXPR, @input;
@selected = map { if (EXPR) { $_ } } @input;
foreach
@transformed = map EXPR, @input;
foreach (@input) { push @transformed, EXPR; }
@sizes = map { -s $_ } @file_names;
@teams = qw(Miami Oregon Florida Tennessee Texas 
            Oklahoma Nebraska LSU Colorado Maryland);
%rank = map { $teams[$_], $_ + 1 } 0 .. $#teams;
print "Colorado: $rank{Colorado}\n"; 
print "Texas: $rank{Texas} (hook 'em, Horns!)\n"; 

Colorado: 9
Texas: 5 (hook 'em, Horns!)

%dictionary = map { $_, 1 } qw(cat dog man woman hat glove);
@words = qw(dog kat wimen hat man glov);
foreach $word (@words) {
    if (not $dictionary{$word}) {   
        print "Possible misspelled word: $word\n";
    }
}
Possible misspelled word: kat
Possible misspelled word: wimen
Possible misspelled word: glov 

use CGI qw(param);
%params = map { $_, ( param($_) )[0] } 
              grep { lc($_) ne 'submit' } param();

param()
param($_)
param($_)
( param($_) )[0] 
@a = (0 .. 9, 'a' .. 'z');
$password = join '', map { $a[int rand @a] } 0 .. 7;
print "$password\n";
y2ti3dal
# Trashes @array  :(
@digitless = map { tr/0-9//d; $_ } @array;    

# Preserves @array  :)
@digitless = map { ($x = $_) =~ tr/0-9//d;    
                   $x; 
                 } @array;
chr
"() =~ 
   /.../g"
print map( { chr } 
           ('10611711511603209711011111610410111' .
           '4032112101114108032104097099107101114') 
           =~ /.../g
         ), "\n";
just another perl hacker

@matrix = ( [1, 2, 3], [4, 5, 6], [7, 8, 9] );
foreach $xyz (@matrix) {
    print "$xyz->[0]  $xyz->[1]  $xyz->[2]\n";
}
@transposed = 
    map { $x = $_;
          [ map { $matrix[$_][$x] } 0 .. $#matrix ];
        } 0 .. $#{$matrix[0]};
print "\n";
foreach $xyz (@transposed) {
    print "$xyz->[0]  $xyz->[1]  $xyz->[2]\n";
}
1  2  3
4  5  6
7  8  9

1  4  7
2  5  8
3  6  9

foreach $num (1 .. 1000) {
    @expr = map { '$_ % ' . $_ . ' &&' } 2 .. int sqrt $num;
    if (eval "grep { @expr 1 } $num") { print "$num " }
}
1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 ...
CANDIDATE: foreach $num (1 .. 1000) {
    foreach $factor (2 .. int sqrt $num) {
        unless ($num % $factor) { next CANDIDATE }
    }
    print "$num ";
}
1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 ...

map
grep
map
$_
map
map
@result = map expression, list 

   @result = map { code } list
map
@result = (); 

   foreach (list) { push @result, expression; }
@times_ten = map $_ * 10, 1..10;
(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
@uppercased = map { ucfirst $_ } qw(george jane judy elroy);
('George', 'Jane', 'Judy', 'Elroy')
grep
map
@result = grep expression, list 

   @result = grep { code } list
map
grep
 $_
'0'
grep
# Returns (2, 4, 6, 8, 10).
@even = grep { not $_ % 2 } 1..10;
# Returns a list of text files in the current directory.
@text_files = grep -T, glob "*";
# Classic grep -- imitating Unix grep. Prints lines containing the 

   # word 'Joseph'.
print grep /\bJoseph\b/, <>;
 grep
map
map
grep
# Another way to get a list of text files.
@text_files = map { (-T) ? $_ : () } glob "*";
map
# Print out the contents of a hash.
print map "$_: $hash{$_}\n", sort keys %hash;
each
while (($key, $val) = each %hash) { print "$key: $val\n" }
map
map
map
# Create keys for all the "words" in $text, so that we can test for 

   # a word later with if $seen{$word}.
%words_seen = map { $_ => 1 } split /\s+/, $text;
# After this, $file_size{$file} gives -s $file -- saves time if 

   # we need to use it more than once.
%file_size = map { $_ => -s } @files;
map
map
# Blend @x, @y, and @z into a single 2-d array @xyz ... $xyz[0][0]

   # is $x[0], $xyz[0][1] is $y[0], and so on.
@xyz = map [$x[$_], $y[$_], $z[$_]], 0..$#x;
# Cache the results from stat into a hash of arrays ... then 

   # $info{'file'}[7] gives the size of 'file', $info{'file'}[5] 

   # gives the owner's uid, and so on.
%info = map { $_, [ stat $_ ] } @files;
map
# This will extract @x from @xyz (undoing what we did above) ... 

   # $x[0] is $xyz[0][0], $x[1] is $xyz[1][0], and so on.
@x = map $_->[0], @xyz;
grep
map
# Select elements from @xyz whose "coordinates" are all >0.

   # @gt_zero is still a 2-d array with the same organization as @xyz.
@gt_zero = grep {$_->[0] > 0 and $_->[1] > 0 and $_->[2] > 0} @xyz;
map
# Read 10 lines from STDIN.
@ten_lines = map scalar(<STDIN>), 1..10;
sort
map
# Sort files in descending order of size.
@files_by_size = 
map { $_->[0] } 
# 3. slice out the original list, now sorted
sort { $b->[1] <=> $a->[1] }
# 2. sort the list of tuples 
map { [$_, -s $_] } 
# 1. create a list of tuples by nesting 
@files; 
# the data to be sorted
map
%hash1
%hash2
delete
# keys %result contains 2 4 6 7 8 9 when this is done.
%hash1 = map { $_, 1 } 1..9; # some sample data 

   %hash2 = map { $_, 1 } 1, 3, 5; # more sample data 

   %result = map { $_, $hash1{$_} } grep { not exists $hash2{$_} } keys %hash1;
# Another way to do the same thing, with delete.
%result = %hash1; 

   delete @result{keys %hash2};
map
map
# Create a hash of user name vs. user id from lines in /etc/passwd.
open PASSWD, "/etc/passwd" or 

   die "couldn't open password file: $!\n"; 

   %name_to_id = map /(.*?):.*?:(.*?):/, <PASSWD>;
map
# Convert a string like 'ABC' into its 

   # hex equivalent, '\x41\x42\x43'.
$hexed = join '', map { sprintf "\\x%x", ord $_ } split //, $str;
# An alternative using s///, which is slightly slower 

   # for long strings.
($hexed = $str) =~ s/(.)/sprintf "\\x%x", ord $1/ge;
map
grep
map 
print "ARGV[] is:\n";
for ($i=0; $i<$#ARGV; $i++) {
    print "  '$ARGV[$i]'\n";
}
print "--------\n";

t.1
bash) perl ./t.1 foo bar baz blah
ARGV[] is:
  'foo'
  'bar'
  'baz'
  'blah'
--------

use strict;
$i
map 
map BLOCK LIST
map EXPR, LIST
map 
map 
print "ARGV[] is:\n",
      map("  '$_'\n", @ARGV),
      "--------\n";

t.2
"\n"
join
print join "\n",
           "ARGV[] is:",
           map("  '$_'", (@ARGV)),
           "--------",
           "";        # This one causes a trailing newline

CGI.pm 
use CGI qw/:html/;

print div({ALIGN => 'CENTER'},
          table({BORDER => 1}, join "\n",
             caption("ARGV[] List:"),
             map( { TR(td($_))} @ARGV)
          )    # End-table
      ),      # End-div
      "";     # This one causes a trailing newline

@caps = map uc, @phrases;
@first_word = map { /(\S+)/ } @phrases;
@words = map split, @phrases;
$title = join ' ', map { ucfirst lc } split / /, $name;
print "<table>\n";

print map {"<tr><td>$_</td><td>$hash{$_}</td></tr>\n"} sort keys %hash;

print "</table>\n";
perl -s prog.pm -a -b -c
perl -s prog.pm -a -b 13 -c 6/6/2001
perl -s prog.pm -a -b=13 -c=6/6/2001
use Getopt::Long;
GetOptions("a!", "b=i", "c=s", "d:s");
LinuxChix Perl Course Part 17: grep and map

1) Introduction
2) grep - filters a list
3) map - transforms the values of a list
4) What "grep" and "map" have in common
5) Exercises
6) Answer to Previous Exercise
7) Past Information
8) Credits
9) Licensing

             -----------------------------------

1) Introduction

Before we finish looking at arrays in Perl, I thought we should take a 
quick look at two handy Perl functions: "grep" and "map". Both functions 
are technically operators because they allow you to do magical things 
that a function can't do, but syntactically they look like functions, so 
we refer to them as functions here.

Let me add that this will be the last e-mail before January. It's that 
busy-busy-busy time of year and I'm afraid that I have no more time to 
write about Perl than you have to read about it.

             -----------------------------------

2) grep - filters a list

The "grep" function returns only the elements of a list that meet a 
certain condition:

   @positive_numbers = grep($_ > 0, @numbers);

As you can see, each element is refered to as "$_". This (plus the fact 
that parentheses are optional) allows you write commands that look 
similar to invocations of the Unix "grep" program:

   @non_blank_lines = grep /\S/, @lines;

In addition, you can specify a code block rather than a single condition:

   @non_blank_lines = grep { /\S/ } @lines;     # Equivalent to the above.

Obviously it doesn't matter in this case, but code blocks are helpful 
when you want a complex filter with multiple lines of code. The result 
of the code block is the result of the last statement executed:

   # All positive numbers can be used as exponents,
   # but negative exponents must be integers.
   @can_be_used_as_exponent = grep {
     if ( $_ < 0 ) {
       ! /\./;          # No decimal point -> integer.
     }
     else {
       1;               # Always true.
     }
   } @array;

             -----------------------------------

3) map - transforms the values of a list

The "map" function applies a transformation to each element of a list 
and returns the result, leaving the original list unchanged (unless you 
mess it up; more on that in a moment).

   @lines_with_newlines = map( $_ . "\n", @lines_without_newlines);

As with "grep", each value in the list is refered to as "$_".

"map" can also take a block of code:

   # Replace "x at y.z" with "x at y dot z" to confuse spammers.
   @disguised_addresses = map {
       my $email = $_;
       $email =~ s/\@/ at /;
       $email =~ s/\./ dot /g;
       $email;
     } @email_addresses;

Note that it's important not to change "$_" because that would change 
the original "@email_addresses" (and you wouldn't get what you wanted in 
"@disguised_addresses").

"map" needs not be a one-to-one mapping. For example, in the following code:

   @words   =   map   m/\b(\w+)\b/g,   @lines;    # Spaces are for clarity.

the regular expression splits a string into a list of words. The "map" 
function returns the result of joining all the small lists. If a line 
contains no words, the regular expression will return an empty list, and 
that's okay.

             -----------------------------------

4) What "grep" and "map" have in common

"grep" and "map" have a lot in common. They both "magically" take a 
piece of code (either an expression or a code block) as a parameter. You 
need to put a comma after an expression but shouldn't put a comma after 
a code block.

Changing "$_" in "grep" or "map" will change the original list. This 
isn't generally a good idea because it makes the code hard to read. 
Remember that "map" builds a list of results by evaluating an 
expression, NOT by setting "$_".

A side effect of this fact is that you should not use "s///" with "map". 
The "s///" operator changes "$_" rather than returning a result, so you 
won't get what you would expect if you use it with "map" (and you 
CERTAINLY shouldn't use it with "grep").

             -----------------------------------

5) Exercises

a) Write some Perl code that, given a list of numbers, generates a list 
of square roots of those numbers. (The square root function in Perl is 
"sqrt".)

b) Modify the code to filter out any negative numbers. The result should 
be as though the negative numbers were never in the original list.

c) Write a Perl program that reads two files and outputs only the lines 
that are common to both of them.

             -----------------------------------

6) Answer to Previous Exercise

The following program reads the password file and outputs a list of 
usernames and UIDs, ordered by username:

   #!/usr/bin/perl -w
   use strict;

   open FILE, '< /etc/passwd' or die "Couldn't open file: $!";
   my @data = sort(<FILE>);
   close FILE;

   my @result;
   foreach (@data) {
     my @fields = split(/:/);    # Equivalent to split(/:/, $_)
     push @result, $fields[0] . ' -> ' . $fields[2];
   }

   print join("\n", at result) . "\n";

The above program is a nice review of Perl functions. But of course, 
There Is More Than One Way To Do It, and we could replace the bottom 
half with:

   foreach (@data) {
     s/^(.*?):.*?:(\d*):.*$/$1 -> $2/;
   }
   print join("\n", at result) . "\n";

Or to make the program really short:

   $_ = join '', @data;
   s/^(.*?):.*?:(\d*):.*$/$1 -> $2/gm;
   print;        # Prints "$_"

-----------------------------------

7) Past Information

Part 16: Array Functions
      http://linuxchix.org/pipermail/courses/2003-November/001359.html

Part 15: More About Lists
      http://linuxchix.org/pipermail/courses/2003-November/001351.html

Part 14: Arrays
      http://linuxchix.org/pipermail/courses/2003-October/001350.html

Part 13: Perl Style
      http://linuxchix.org/pipermail/courses/2003-October/001349.html

Part 12: Side Effects with Perl Variables
      http://linuxchix.org/pipermail/courses/2003-October/001347.html

Part 11: Perl Variables
      http://linuxchix.org/pipermail/courses/2003-October/001345.html

Parts 1-10: see the end of:
      http://linuxchix.org/pipermail/courses/2003-October/001345.html

             -----------------------------------

8) Credits

Works cited:
a) man perlfunc
b) Kirrily Robert, Paul Fenwick and Jacinta Richardson's
    "Intermediate Perl", which you can find (along with their
    "Introduction to Perl") at:
    http://www.perltraining.com.au/notes.html

Thanks to Jacinta Richardson for fact checking.

             -----------------------------------

9) Licensing

This course (i.e., all parts of it) is copyright 2003 by Alice Wood and 
Dan Richter, and is released under the same license as Perl itself 
(Artistic License or GPL, your choice). This is the license of choice to 
make it easy for other people to integrate your Perl code/documentation 
into their own projects. It is not generally used in projects unrelated 
to Perl.

map()
 # map {BLOCK GOES HERE} LIST; map {$_++} @p; # increment every element of @p # map EXPRESSION, LIST; map -f,@p; # file test every element of @p 
foreach()
map()
map()
map()
$_
$_
map()
 # "normal" (procedural) way foreach (sort keys %ENV) { print "$_ => $ENV{$_}\n"; } # FP way map { print "$_ => $ENV{$_}\n" } sort keys %ENV; 
print()
 # these are the users @users = ('joe', 'ted', 'larry'); # and this is an on-the-fly substitution of user names with hash references map { $_ = { $_ => length } } @users; # @users is now ( { 'joe' => 3 }, # { 'ted' => 3 }, # { 'larry' => 5 } ) 
map()
map()
 use File::stat; use Data::Dumper; @files = ('/etc/passwd', '/etc/group', '/etc/fstab', '/etc/vfstab'); print Dumper map { $sb = stat $_; $_ = (defined $sb) ? { name => $_, size =>$sb->size(), mtime => $sb->mtime() } : undef } @files; 
grep()
grep()
map()
$_
grep()
map()
grep()
map()
# grep {BLOCK GOES HERE} LIST; grep {$_ > 1} @p; # only accept numbers more than 1 grep {$_++} @p; # please don't do this # grep EXPRESSION, LIST; grep /hi/,@p; # only accept matching elements grep !/hi/,@p; # do not accept matching elements
grep()
foreach()
my @list = (1, 2, 3, 'hi'); my @results; # the procedural approach foreach (@list) { push @results, $_ unless $_%2; } # using grep - FP approach @results = grep { !($_ % 2) } @list; 
opendir(DIR, ".") || die "can't opendir: $!"; # get the directory handle my @f = grep { /^[^\.]/ && -f } readdir(DIR); # filter only files into @f 

   readdir()
grep()
foreach()
grep()
use Proc::ProcessTable; # get this module from CPAN use strict; my $table = new Proc::ProcessTable; my @procs; if (@procs = grep { defined $_->cmndline && $_->cmndline =~ /^perl/ } @{$table->table}) { print $_->pid, "\n" foreach @procs; } else { print "No Perl interpreters seem to be running.\n"; } 
grep()
foreach()
sort()
map()
grep()
sort()
sort()
@new_list = sort @old_list; # sort @old_list alphabetically
@old_list = (1, 2, 5, 200, '010'); @new_list = sort { $a <=> $b } @old_list; # sort @old_list numerically
reverse()
{ $b <=> 
   $a }
<=>
# create a list with two hash references @old_list = ( { name => "joe" }, { name => "moe" } ); # sort @old_list by the value of the 'name' key @new_list = sort { $a->{name} cmp $b->{name} } @old_list; 
split()
split()
# create a list with some strings @old_list = ( '5 eagles', '10 hawks', '2 bulls', '8 cows'); # sort @old_list by the first word in each string, numerically @new_list = map($_->[1], sort( { $a->[0] <=> $b->[0] } map( [ (split)[0], $_ ], @old_list)));
map()
map()
split()
map()
$_
$_
grep()
map()
grep()
map()
map()
grep()

      grep()
grep()
push (@fin_nodes, [$node, $hindex, $e->{$hip}->{FREQ}]);

$VAR1 = [
      'first-node',
      '4',
      3
    ];
$VAR2 = [
      'second-node',
      '1',
      3
    ];
$VAR3 = [
      'another-node',
      '1',
      5
    ];
$VAR4 = [
      'some-node',
      '0',
      5
    ];

my @match = grep { grep { $_ =~ $node } @$_ } @fin_nodes;

$VAR1 = [
  'second-node',
  '1',
  3
];

my %fin_nodes;
$fin_nodes{$node} = [$hindex, $e->{$hip}->{FREQ}]);

 my @matches = grep { $_ -> [0] eq $node } @fin_nodes;

my ( $first_match ) =  grep { $_ -> [0] eq $node } @fin_nodes;

Softpanorama May the source be with you, but remember the KISS principle ;-)	Home	Switchboard	Unix Administration	Red Hat	TCP/IP Networks	Neoliberalism	Toxic Managers
	(slightly skeptical) Educational society promoting "Back to basics" movement against IT overcomplexity and bastardization of classic Unix

News	Operations on Arrays in Perl	Recommended Links	Reference	Regular expressions	Nikolai Bezroukov. Simplified Perl for Unix System Administrators
sort	substr	Split	sprintf	index and rindex	tr
Pipes in Perl		History	Humor	Etc

Top Visited <p>Your browser does not support iframes.</p>					Switchboard
					Latest
					Past week
					Past month

`@files_by_size =`
`map { $_->[0] }`	`# 3. slice out the original list, now sorted`
`sort { $b->[1] <=> $a->[1] }`	`# 2. sort the list of tuples`
`map { [$_, -s $_] }`	`# 1. create a list of tuples by nesting`
`@files;`	`# the data to be sorted`

Grep and Map in Perl

Introduction

Grep

Map

Some elegant examples

NEWS CONTENTS

Old News ;-)

[Nov 23, 2017] A Perl array 'contains' example by Alvin Alexander

Jun 03, 2016 | alvinalexander.com

[Nov 22, 2017] Perl grep array FAQ - How to search an array-list of strings alvinalexander.com

Nov 22, 2017 | alvinalexander.com

[Nov 22, 2017] perl - How can I also get an element's index when I grep through an array - Stack Overflow

Nov 22, 2017 | stackoverflow.com

[Nov 22, 2017] Perl Searching for item in an Array - Stack Overflow

Nov 22, 2017 | stackoverflow.com

Perl grep, map and sort

login - Effective Perl Programming

SAGE

Part 17: grep and map

The road to better programming Chapter 4

[Nov 16, 2017] perl - Grep Two Dimensional Array - Stack Overflow

Nov 16, 2017 | stackoverflow.com

Recommended Links

Google matched content

Softpanorama Recommended

Top articles

Sites

Etc