Mappage avec Split & Trim en Perl

Question

Comment utiliser map avec la fonction split pour découper les constituants: $ a, $ b, $ c et $ d; de $ line?

my ($a, $b, $c, $d, $e) = split(/\t/, $line); 

# Perl trim function to remove whitespace from the start and end of the string 
sub trim($) 
{ 
    my $string = shift; 
    $string =~ s/^\s+//; 
    $string =~ s/\s+$//; 
    return $string; 
} 

Answer 1

Cela devrait fonctionner:

my ($a, $b, $c, $d, $e) = map {trim ($_)} (split(/\t/, $line)); 

Par ailleurs, il est un point mineur, mais vous ne devriez pas utiliser un $ et $ b comme noms de variables.

Answer 2

map prend deux entrées:

• une expression ou d'un bloc: ce serait l'expression trim (vous ne devez pas écrire votre propre - il est sur CPAN)
• et une liste pour fonctionner sur: cela devrait être split la sortie « :

use String::Util 'trim'; 
my @values = map { trim($_) } split /\t/, $line; 

Answer 3

ne pas utiliser des prototypes le ($) sur votre fonction à moins que vous besoin de eux.

my ($a, $b, $c, $d, $e) = 
    map {s/^\s+|\s+$//g; $_} ## Notice the `, $_` this is common 
    , split(/\t/, $line, 5) 
; 

Ne pas oublier dans ce qui précède s/// renvoie le nombre de remplacement - non $_. Donc, nous le faisons explicitement.

ou plus simplement:

my @values = map {s/^\s+|\s+$//g; $_}, split(/\t/, $line, 5), $line 

Answer 4

Juste pour la variété:

my @trimmed = grep { s/^\s*|\s*$//g } split /\t/, $line; 

grep agit comme un filtre sur les listes. C'est pourquoi les \s+ doivent être remplacés par \s* dans l'expression rationnelle. Forcer des correspondances sur 0 ou plusieurs espaces empêche grep de filtrer les éléments de la liste qui n'ont pas d'espaces de début ou de fin.

Answer 5

Vous pouvez également utiliser "foreach" ici.

foreach my $i ($a, $b, $c, $d, $e) { 
    $i=trim($i); 
} 

Answer 6

Lorsque je coupe une chaîne, je ne souhaite pas souvent conserver l'original. Ce serait bien d'avoir l'abstraction d'un sous-marin mais aussi de ne pas avoir à se soucier des valeurs temporaires.

Il se avère que nous pouvons faire tout cela, comme perlsub explique:

Tous les arguments passés dans le show dans le tableau @_. Par conséquent, si vous appelez une fonction avec deux arguments, ceux-ci seront stockés dans $_[0] et $_[1]. Le tableau @_ est un tableau local, mais ses éléments sont des alias pour les paramètres scalaires réels. En particulier, si un élément $_[0] est mis à jour, l'argument correspondant est mis à jour (ou une erreur se produit s'il n'est pas modifiable).

Dans votre cas, trim devient

sub trim { 
    for (@_) { 
    s/^ \s+ //x; 
    s/ \s+ $//x; 
    } 
    wantarray ? @_ : $_[0]; 
} 

Rappelez-vous que map et for sont des cousins, donc avec la boucle trim, on n'a plus besoin map. Par exemple

my $line = "1\t 2\t3 \t 4 \t 5 \n";  
my ($a, $b, $c, $d, $e) = split(/\t/, $line);  

print "BEFORE: [", join("] [" => $a, $b, $c, $d), "]\n"; 
trim $a, $b, $c, $d; 
print "AFTER: [", join("] [" => $a, $b, $c, $d), "]\n"; 

Sortie:

BEFORE: [1] [ 2] [3 ] [ 4 ] 
AFTER: [1] [2] [3] [4]