trim() magic

[japhy]

It's the typical trim(), with optional in-place behavior, and $_ argument defaulting.

sub trim {
  @_ = $_ if not @_ and defined wantarray;
  @_ = @_ if defined wantarray;
  for (@_ ? @_ : $_) { s/^\s+//, s/\s+$// }
  return wantarray ? @_ : $_[0] if defined wantarray;
}

trim;               # trims $_ inplace
$new = trim;        # trims (and returns) a copy of $_
trim $str;          # trims $str inplace
$new = trim $str;   # trims (and returns) a copy of $str
trim @list;         # trims @list inplace
@new = trim @list;  # trims (and returns) a copy of @list

[dragonchild]

On the theory that storing the return from wantarray is always faster than computing it between 2 and 4 times, I was going to suggest the following:

sub trim {
  if (defined my $w = wantarray) {
    @_ = ( @_ ? @_ : $_ );
    for (@_) { s/^\s+//, s/\s+$// if $_ }
    return $w ? @_ : $_[0];
  }
  else {
    for (@_ ? @_ : $_) { s/^\s+//, s/\s+$// if $_ }
  }
}

The if $_ is to protect against warnings for undefined values.

Unfortunately, it turns out that I was wrong. Your version is usually faster than mine. The only place I'm faster is my $x = trim();. I'm not sure that case is worth making the code harder to read. (Though, if this were added to something like Scalar::Util, I would code it my way.)

Read more... (1476 Bytes)

[Roy Johnson]

What does the assignment @_ = @_ accomplish?

[japhy]

It breaks the aliasing nature of the elements in @_.

[Aristotle]

I tried to see if there were any knobs to twiddle on this one, using dragonchild’s benchmark cases.

First thing I tried: using a recursive call to alias $_. This lets you get rid of the ternary in the for list.

sub trim {
    return trim( $_ ) if not @_;
    @_ = @_ if defined wantarray;
    for ( @_ ) { s/^\s+//, s/\s+$// }
    return wantarray ? @_ : $_[ 0 ] if defined wantarray;
}

On my setup this is about 15% slower for the “inplace replacement of implicit $_” case, but ekes out a few percentage points on the other cases. But it let me proceed to switch from duplicate defined wantarray tests to a duplicate inner loop:

sub trim2 {
    return trim2( $_ ) if not @_;
    return map { local $_ = $_; s/^\s+//, s/\s+$//; $_ } @_
        if defined wantarray;
    for ( @_ ) { s/^\s+//, s/\s+$// }
}

This gets back most of the lost speed in the “inplace replacement of implicit $_” case, has roughly the same performance in other void contexts, but is also about 50% faster in many other cases, including the IMHO most important one – passing a scalar and assigning to one.

Read more... (5 kB)

[Aristotle]

What I’d do differently now: at least this:

sub trim2 {
    return trim2 $_ if not @_;
    return map { s/^\s+//; s/\s+$//; $_ } my @c = @_
        if defined wantarray;
    for ( @_ ) { s/^\s+//, s/\s+$// }
}

And someone who can be bothered should benchmark the following variants:

sub trim3a {
    return trim3a $_ if not @_;

    s/^\s+//, s/\s+$// for
                wantarray ? my @c = @_     :
        defined wantarray ? my $c = $_[-1] :
                                    @_;

    @c ? @c : $c ? $c : ();
}

sub trim3b {
    return trim3b $_ if not @_;

    my $w = wantarray;
    s/^\s+//, s/\s+$// for
                $w ? my @c = @_     :
        defined $w ? my $c = $_[-1] :
                             @_;

    @c ? @c : $c ? $c : ();
}