There's not a built-in. The regexp approach is fine. If you want it to be a sub, just put it in a sub definition:

sub trim_white {
   my $string = shift;
   $string =~ s/^\s+//g;
   $string =~ s/\s+$//g;
   return $string;
}

# Usage example:
my $trimmed = trim_white( $untrimmed );
[download]

Update: For completeness's sake, it might be worth noting that on CPAN you can find String::Util, which includes a function called trim() that does exactly what you're talking about. ...it's been done. ;)

Your code is missing an s, so it won't do what you want.

That aside, you could use the following rather obfuscated code:

s/^\s+//g, s/\s+$//g for $value;
[download]

sub trim {
   local $_ = @_ ? $_[0] : $_;
   s/^\s+//g;
   s/\s+$//g;
   $_
}

$trimmed = trim($untrimmed);
$trimmed = trim;                      # Trims $_ by default.
@trimmed = map trim, @untrimmed;      # Trim a whole list. (readable)
push(@trimmed, trim) for @untrimmed;  # Trim a whole list. (efficient)
[download]

Please don't use those kinds of abbreviations. There are people speaking many languages who come here and there's no point in making things harder for them to understand.

No, the way you showed is the best way (except you don't need the "g" since you already get all the spaces with "+").

I thought about this too. You're correct that the /g modifier is kind of pointless by itself, but combined with the /m modifier, you get improved functionality (for some definitions of 'improved'):

use strict;
use warnings;

my $string = "   now is the \ntime for all     \n       good men to co
+me    \n          to the aid\n";



$string =~ s/^\s+//mg;
$string =~ s/\s+$//mg;

print $string, "\n";
[download]




Dave

$value="    kkkk.123  ";
for ( $i=0; $i<length($value); $i++ ) {
    if ( substr($value,$i,1) eq " " ) {
        substr($value,$i,1) = "";
        redo;
    } else {
        last;
    }
}
for ( $i=length($value)-1; $i>0; $i-- ) {
    if ( substr($value,$i,1) eq " " ) {
        $value = substr($value,0,$i);
    }
}
[download]

I tend to do it:

use strict;
use warnings;

my $before = "   some text   ";
($_ = $before) =~ s/^\s+|\s+$//g;
print ">$before<\n";
print "|$_|\n";
[download]

Prints:

>   some text   <
|some text|
[download]

I guess this is sufficiently light weight that it is thought a function is not required. Does seem a slight omission though.

Assinging to $_ without localizing it is dangerous.
(local $_ = $before) =~ s/^\s+|\s+$//g;
or
(my $after = $before) =~ s/^\s+|\s+$//g;
should be used in just almost all cicumstances.

I think the alternation in the s/^\s+|\s+$// version causes significant time costs in large applications. I often work with tab-delimited files containing hundreds of thousands of lines. If I'm tab-splitting these lines and then trimming each one, I'm going to pick the double-regex approach each time. I wrote some quick code that benchmarked the double-regex vs single-regex approach against three strings.

use Benchmark;

my @words = ('trim_unneeded','  front trim only','rear trim only   ','
+  both side trim ');

for my $word (@words){
    
    print "Benchmarking $word...\n\n";
    
    timethese(1_000_000, {double => sub{ $word =~ s/^\s+//; $word =~ s
+/\s+$//; },
                    single => sub{ $word =~ s/^\s+|\s+$//; }})
}
[download]

The code was run on a Celeron D 2.8 GHz machine running XP with the following results:

'trim_unneeded'
Single Regex: 0.45 seconds
Double Regex: 2.27 seconds

' front trim only'
Single Regex: 0.67 seconds
Double Regex: 2.66 seconds

'rear trim only '
Single Regex: 0.67 seconds
Double Regex: 2.45 seconds

' both side trim '
Single Regex: 0.66 seconds
Double Regex: 2.44 seconds

That's after only 1,000,000 trims. In a 800,000 line file with 50 columns per line, we're talking about 40,000,000 trims. Assuming a linear scale, that means I give up about a minute of processing time per file per run. That's far less than the time it would have taken me to type two regexes. Admittedly, it's a small optimization, and only valid for those who are processing files on the scale that I do, but for most people who end up typing the 'trim regex' often enough to complain about it on perlmonks, it probably applies.

"I think the alternation in the s/^\s+|\s+$// version causes significant time costs in large applications."

Wait, isn't the single regex faster in your benchmark?

"Single Regex: 0.45 seconds
Double Regex: 2.27 seconds"

---

Ordinary morality is for ordinary people. -- Aleister Crowley

($_ = $before) =~ s/^\s+|\s+$//g;
[download]

Just as a minor nitpick I'd localise $_, but then I wouldn't bind with =~, I'd just

local $_ = $before;
s/^\s+|\s+$//g;
[download]

or else

(my $after = $before) =~ s/^\s+|\s+$//g;
[download]