How can I make Perl functions that use $_ by default?

Question

So I have an array and a simple function that trims white spaces:

my @ar=("bla ", "ha  1")
sub trim { my $a=shift; $a =~ s/\s+$//; $a}

Now, I want to apply this to an array with the map function. Why can't I do this by just giving the function name like one would do with built in functions?

E.g. You can do

print map(length,@ar)

but you can't do

print map(trim,@ar)

you have to do something like:

print map {trim($_)} @ar
print map(trim($_),@ar)

Answer 1

Many Perl built-in functions operate on $_ if given no arguments.

If your function did the same, it would work:

my @ar=("bla ", "ha  1");
sub trim { my $s=@_?$_[0]:$_;$s =~ s/\s+$//; $s}
print map(trim,@ar),"\n";

And yes, Perl is kind of gross.

Answer 2

If you are using 5.10 or later, you can specify _ as the prototype for trim. If you are using earlier versions, use Axeman's answer:

As the last character of a prototype, or just before a semicolon, you can use _ in place of $ : if this argument is not provided, $_ will be used instead.

use strict; use warnings;

my @x = ("bla ", "ha  1");

sub trim(_) { my ($x) = @_; $x =~ s!\s+$!!; $x }

print map trim, @x;

Incidentally, don't use $a and $b outside of a sort comparator: They are immune from strict checking.

However, I prefer not to use prototypes for functions I write mainly because their use makes it harder to mentally parse the code. So, I would prefer using:

map trim($_), @x;

See also perldoc perlsub:

This is all very powerful, of course, and should be used only in moderation to make the world a better place.

Answer 3

The prototype that Sinan talks about is the best current way. But for earlier versions, there is still the old standby:

sub trim { 
    # v-- Here's the quick way to do it.
    my $str = @_ ? $_[0] : $_;
    # That was it.

    $str =~ s/^\s+|\s+$//;
    return $str;
 }

Of course, I have a trim function with more features and handles more arguments and list context, but it doesn't demonstrate the concept as well. The ternary expression is a quick way to do what the '_' prototype character now does.

...BTW, Perl rules!

Answer 4

my favorite way to optionally use $_ without needing 5.10+ is as follows:

sub trim {
    my ($s) = (@_, $_);
    $s =~ s/\s+$//;
    $s
}

this assigns the first element of @_ to $s if there is one, otherwise uses $_