Quelle est la différence entre grep et map dans Perl?

En Perl deux grep et map prendre une expression et une liste, et d'évaluer l'expression pour chaque élément de la liste.

Quelle est la différence entre les deux?

source d'informationauteur Nathan Fellman | 2009-02-22

  1. 25

    grep renvoie les éléments de la liste originale qui correspondent à l'expression, tandis que map retourne le résultat de l'expression appliquée à chaque élément de la liste originale.

    $ perl -le 'print join " ", grep $_ & 1, (1, 2, 3, 4, 5)'
1 3 5
$ perl -le 'print join " ", map $_ & 1, (1, 2, 3, 4, 5)'
1 0 1 0 1

    Le premier exemple imprime tous les impair d'éléments de la liste, tandis que le second exemple imprime un 0 ou 1 selon que l'élément correspondant est bizarre ou pas.

  2. 10

    Je trouve qu'il est utile de penser à penser à grep() et map() dans leur forme la plus générale:

    grep {BLOCK} LIST   
map  {BLOCK} LIST

    grep() est un filtre: il retourne le sous-ensemble des éléments de la LISTE pour le BLOC renvoie la valeur true.

    map() est une fonction de mappage: envoyer une valeur à partir de la LISTE de BLOC et BLOC renvoie une liste de 0 ou plusieurs valeurs; l'ensemble de tous ces appels à BLOC sera l'ultime liste retournée par map().

  3. 4

    map applique une fonction à tous les éléments dans une liste et retourne le résultat.

    grep renvoie tous les éléments dans une liste qui évalue à true quand une fonction est appliquée.

    my %fruits = (
  banana => {
    color => 'yellow',
    price => 0.79,
    grams => 200
  },
  cherry => {
    color => 'red',
    price => 0.02,
    grams => 10
  },
  orange => {
    color => 'orange',
    price => 1.00,
    grams => 225
  }
);

my %red_fruits = map { $_ => $fruits{$_} }
                   grep { $fruits{$_}->{color} eq 'red' }
                     keys(%fruits);

my @prices = map { $fruits{$_}->{price} } keys(%fruits);
my @colors = map { $fruits{$_}->{color} } keys(%fruits);
my @grams  = map { $fruits{$_}->{grams} } keys(%fruits);

# Print each fruit's name sorted by price lowest to highest:
foreach( sort { $fruits{$a}->{price} <=> $fruits{$b}->{price}} keys(%fruits) )
{
  print "$_ costs $fruits{$_}->{price} each\n";
}# end foreach()
  4. 3

    Une autre chose au sujet grep: dans un contexte scalaire, il vous indique le nombre d'éléments qu'il trouve. Cela peut être utile si vous ne voulez pas vraiment d'une seconde liste, mais vous voulez savoir combien d'objets d'un certain type, il y a des.

    my @numbers = qw/1 2 3 4 5 6/;

my @odd_numbers  = grep { $_ & 1 } @numbers; # grep returns (1, 3, 5)

my $how_many_odd = grep { $_ & 1 } @numbers; # grep returns 3

    Edit: Depuis que l'OP a demandé dans un commentaire, je dois dire que vous pouvez utiliser map dans un contexte scalaire de la même manière. Le point n'est pas que grep est le seul des deux qui peut le faire, mais qu'il est parfois utile de le faire avec grep.

  5. 2

    Pense grep comme la carte avec un filtre. carte itère et fournit une occasion de faire quelque chose avec chaque élément. Par exemple, ces deux lignes sont équivalentes:

    my @copy = @original;
my @copy = map {$_} @original;

    De même, ces deux sont équivalentes:

    my @copy = grep { -f $_} @original;

@copy = ();
for (@original)
{
  push @copy, $_ if -f $_;
}

    grep offre la possibilité d'insérer un conditionnel, et devient donc un filtre.

  6. 0

    Facétieusement: grep donne son bloc un contexte scalaire, la carte donne son bloc un contexte de liste. (Et BLOC foreach LISTE donne son bloc de contexte vide.)