Strip whitespace from a string/Top and tail

From Rosetta Code
Jump to: navigation, search
Task
Strip whitespace from a string/Top and tail
You are encouraged to solve this task according to the task description, using any language you may know.

The task is to demonstrate how to strip leading and trailing whitespace from a string. The solution should demonstrate how to achieve the following three results:

  • String with leading whitespace removed
  • String with trailing whitespace removed
  • String with both leading and trailing whitespace removed

For the purposes of this task whitespace includes non printable characters such as the space character, the tab character, and other such characters that have no corresponding graphical representation.

Contents

[edit] Ada

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings; use Ada.Strings;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
procedure StripDemo is
str : String := " Jabberwocky ";
begin
Put_Line ("'" & Trim (str, Left) & "'");
Put_Line ("'" & Trim (str, Right) & "'");
Put_Line ("'" & Trim (str, Both) & "'");
end StripDemo;
Output:
'Jabberwocky     '
'     Jabberwocky'
'Jabberwocky'

[edit] ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.win32
# returns "text" with leading non-printing characters removed #
PROC trim leading whitespace = ( STRING text )STRING:
BEGIN
 
INT pos := LWB text;
 
WHILE
IF pos > UPB text
THEN
FALSE
ELSE
text[ pos ] <= " "
FI
DO
pos +:= 1
OD;
 
text[ pos : ]
END; # trim leading whitespace #
 
# returns "text" with trailing non-printing characters removed #
PROC trim trailing whitespace = ( STRING text )STRING:
BEGIN
 
INT pos := UPB text;
 
WHILE
IF pos < LWB text
THEN
FALSE
ELSE
text[ pos ] <= " "
FI
DO
pos -:= 1
OD;
 
text[ : pos ]
END; # trim trailing whitespace #
 
# returns "text" with leading and trailing non-printing characters removed #
PROC trim whitespace = ( STRING text )STRING:
BEGIN
trim trailing whitespace( trim leading whitespace( text ) )
END; # trim whitespace #
 
 
main:(
STRING test = " leading and trailing spaces surrounded this text ";
 
print( ( "trim leading: """ + trim leading whitespace ( test ) + """", newline ) );
print( ( "trim trailing: """ + trim trailing whitespace( test ) + """", newline ) );
print( ( "trim both: """ + trim whitespace ( test ) + """", newline ) )
)
Output:
trim  leading: "leading and trailing spaces surrounded this text   "
trim trailing: "   leading and trailing spaces surrounded this text"
trim     both: "leading and trailing spaces surrounded this text"

[edit] AutoHotkey

AutoHotkey_L and v2 contain a Trim function

string := "   abc   "
MsgBox % clipboard := "<" LTrim(string) ">`n<" RTrim(string) ">`n<" . Trim(string) ">"
Output:
<abc   >
<   abc>
<abc>

[edit] AWK

#!/usr/bin/awk -f 
function trim(str) {
sub(/^[ \t]+/,"",str); # remove leading whitespaces
sub(/[ \t]+$/,"",str); # remove trailing whitespaces
return str;
}
{
print trim($0);
}

[edit] BASIC

Works with: QBasic
 mystring$=ltrim(mystring$)           ' remove leading whitespace
mystring$=rtrim(mystring$) ' remove trailing whitespace
mystring$=ltrim(rtrim(mystring$)) ' remove both leading and trailing whitespace

[edit] BBC BASIC

      REM Remove leading whitespace:
WHILE ASC(A$)<=32 A$ = MID$(A$,2) : ENDWHILE
 
REM Remove trailing whitespace:
WHILE ASC(RIGHT$(A$))<=32 A$ = LEFT$(A$) : ENDWHILE
 
REM Remove both leading and trailing whitespace:
WHILE ASC(A$)<=32 A$ = MID$(A$,2) : ENDWHILE
WHILE ASC(RIGHT$(A$))<=32 A$ = LEFT$(A$) : ENDWHILE

[edit] Bracmat

Greedy pattern matching is not Bracmat's strongest field. So instead of a pattern that globs all white space characters, we have a pattern that finds the first non-whitespace character. That character, and the remainder of the subject string, constitute a left trimmed string. To do a right trim, we reverse the string, do a left trim and reverse back.

( ( ltrim
= s
. @( !arg
 :  ?
( ( %@
 : ~( " "
| \a
| \b
| \n
| \r
| \t
| \v
)
)
 ?
 : ?s
)
)
& !s
)
& (rtrim=.rev$(ltrim$(rev$!arg)))
& (trim=.rev$(ltrim$(rev$(ltrim$!arg))))
& (string=" \a Hear
the sound?
\v
 
\r
")
& out$(str$("Input:[" !string "]"))
& out$(str$("ltrim:[" ltrim$!string "]"))
& out$(str$("rtrim:[" rtrim$!string "]"))
& out$(str$("trim :[" trim$!string "]"))
&
);

Output (Notice the effect of the ancient \a (alarm) and \v (vertical tab)):

Input:[     Hear
         the sound?
♂


]
ltrim:[Hear
         the sound?
♂


]
rtrim:[     Hear
         the sound?]
trim :[Hear
         the sound?]

[edit] Burlesque

 
blsq ) " this is a string "t[
"this is a string "
blsq ) " this is a string "t]
" this is a string"
blsq ) " this is a string "tt
"this is a string"
 

[edit] C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
char *rtrim(const char *s)
{
while( isspace(*s) || !isprint(*s) ) ++s;
return strdup(s);
}
 
char *ltrim(const char *s)
{
char *r = strdup(s);
if (r != NULL)
{
char *fr = r + strlen(s) - 1;
while( (isspace(*fr) || !isprint(*fr) || *fr == 0) && fr >= r) --fr;
*++fr = 0;
}
return r;
}
 
char *trim(const char *s)
{
char *r = rtrim(s);
char *f = ltrim(r);
free(r);
return f;
}
 
const char *a = " this is a string ";
 
int main()
{
char *b = rtrim(a);
char *c = ltrim(a);
char *d = trim(a);
 
printf("'%s'\n'%s'\n'%s'\n", b, c, d);
 
free(b);
free(c);
free(d);
return 0;
}

[edit] C++

#include <boost/algorithm/string.hpp>
#include <string>
#include <iostream>
 
int main( ) {
std::string testphrase( " There are unwanted blanks here! " ) ;
std::string lefttrimmed = boost::trim_left_copy( testphrase ) ;
std::string righttrimmed = boost::trim_right_copy( testphrase ) ;
std::cout << "The test phrase is :" << testphrase << "\n" ;
std::cout << "Trimmed on the left side :" << lefttrimmed << "\n" ;
std::cout << "Trimmed on the right side :" << righttrimmed << "\n" ;
boost::trim( testphrase ) ;
std::cout << "Trimmed on both sides :" << testphrase << "\n" ;
return 0 ;
}
Output:
The test phrase is :    There are unwanted blanks here!    
Trimmed on the left side :There are unwanted blanks here!    
Trimmed on the right side :    There are unwanted blanks here!
Trimmed on both sides :There are unwanted blanks here!

[edit] C#

using System;
 
public class TrimExample
{
public static void Main(String[] args)
{
const string toTrim = " Trim me ";
Console.WriteLine(Wrap(toTrim.TrimStart()));
Console.WriteLine(Wrap(toTrim.TrimEnd()));
Console.WriteLine(Wrap(toTrim.Trim()));
}
 
private static string Wrap(string s)
{
return "'" + s + "'";
}
}
Output:
'Trim me '
' Trim me'
'Trim me'

[edit] COBOL

Works with: GNU Cobol version 2.0
DISPLAY "'" FUNCTION TRIM(str, LEADING) "'"
DISPLAY "'" FUNCTION TRIM(str, TRAILING) "'"
DISPLAY "'" FUNCTION TRIM(str) "'"

[edit] Clojure

 
(use 'clojure.string)
(triml " my string ")
=> "my string "
(trimr " my string ")
=> " my string"
(trim " \t\r\n my string \t\r\n ")
=> "my string"
 

[edit] Common Lisp

; Common whitespace characters
(defvar *whitespace* '(#\Space #\Newline #\Tab))
 
(defvar str " foo bar baz ")
 
(string-trim *whitespace* str)
; -> "foo bar baz"
 
(string-left-trim *whitespace* str)
; -> "foo bar baz "
 
(string-right-trim *whitespace* str)
; -> " foo bar baz"
 
; Whitespace characters defined by Unicode for
; implementations which support it (e.g. CLISP, SBCL).
; (see http://www.unicode.org/Public/UCD/latest/ucd/PropList.txt)
(defvar *unicode-whitespace*
'(#\u0009 #\u000a #\u000b #\u000c #\u000d
#\u0020 #\u0085 #\u00a0 #\u1680 #\u2000
#\u2001 #\u2002 #\u2003 #\u2004 #\u2005
#\u2006 #\u2007 #\u2008 #\u2009 #\u200a
#\u2028 #\u2029 #\u202f #\u205f #\u3000))
 
(defvar unicode-str
(format nil "~C~Cfoo~Cbar~Cbaz~C~C"
#\u2000 #\u2003 #\u0020 #\u00a0 #\u0009 #\u202f))
 
(string-trim *unicode-whitespace* unicode-str)
; -> "foo bar baz"
 
(string-left-trim *unicode-whitespace* unicode-str)
; -> "foo bar baz  "
 
(string-right-trim *unicode-whitespace* unicode-str)
; -> "  foo bar baz"

[edit] D

import std.stdio, std.string;
 
void main() {
auto s = " \t \r \n String with spaces \t \r \n ";
assert(s.stripLeft() == "String with spaces \t \r \n ");
assert(s.stripRight() == " \t \r \n String with spaces");
assert(s.strip() == "String with spaces");
}

[edit] Delphi/Pascal

program StripWhitespace;
 
{$APPTYPE CONSOLE}
 
uses SysUtils;
 
const
TEST_STRING = ' String with spaces ';
begin
Writeln('"' + TEST_STRING + '"');
Writeln('"' + TrimLeft(TEST_STRING) + '"');
Writeln('"' + TrimRight(TEST_STRING) + '"');
Writeln('"' + Trim(TEST_STRING) + '"');
end.

[edit] DWScript

Translation of: Delphi
const TEST_STRING = '     String with spaces     ';
 
PrintLn('"' + TEST_STRING + '"');
PrintLn('"' + TrimLeft(TEST_STRING) + '"');
PrintLn('"' + TrimRight(TEST_STRING) + '"');
PrintLn('"' + Trim(TEST_STRING) + '"');

[edit] Erlang

% Implemented by Arjun Sunel
1> string:strip(" Hello World! ", left). %remove leading whitespaces
"Hello World! "
 
2> string:strip(" Hello World! ", right). % remove trailing whitespaces
" Hello World!"
 
3> string:strip(" Hello World! ", both). % remove both leading and trailing whitespace
"Hello World!"
 

[edit] Euphoria

Works with: Euphoria version 4.0.3, 4.0.0 and later

A string (sequence) 'A B C' is surrounded by unwanted characters including spaces. The trim() function Trims "all items in the supplied set from both the left end (head/start) and right end (tail/end) of a sequence." It's part of the standard library, std/text.e .

Special characters in a string literal are typed 'escaped' with a '\' followed by one character. Other special characters are written using escaped hexadecimal , example : \x04 to represent hexadecimal ascii 04 or \u2A7C for 4-digit UTF, or more than two digit ascii characters : \u0127.

include std/console.e
include std/text.e
 
sequence removables = " \t\n\r\x05\u0234\" "
sequence extraSeq = " \x05\r \" A B C \n \t\t \u0234 \r\r \x05 "
 
extraSeq = trim(extraSeq,removables) --the work is done by the trim function
 
--only output programming next :
printf(1, "String Trimmed is now: %s \r\n", {extraSeq} ) --print the resulting string to screen
 
for i = 1 to length(extraSeq) do --loop over each character in the sequence.
printf(1, "String element %d", i) --to look at more detail,
printf(1, " : %d\r\n", extraSeq[i])--print integer values(ascii) of the string.
end for
 
any_key()
Output:
String Trimmed is now: A  B  C
String element 1 : 65
String element 2 : 32
String element 3 : 32
String element 4 : 66
String element 5 : 32
String element 6 : 32
String element 7 : 67
Press Any Key to continue...


[edit] F#

[<EntryPoint>]
let main args =
printfn "%A" (args.[0].TrimStart())
printfn "%A" (args.[0].TrimEnd())
printfn "%A" (args.[0].Trim())
0
>rosetta " a string "
"a string "
" a string"
"a string"

[edit] Factor

 
USING: unicode.categories;
" test string " [ blank? ] trim  ! leading and trailing
" test string " [ blank? ] trim-head  ! only leading
" test string " [ blank? ] trim-tail  ! only trailing
 


[edit] Forth

: -leading ( addr len -- addr' len' )
begin over c@ bl = while 1 /string repeat ;
\ -trailing is built in
 
s" test "
2dup -leading cr type
2dup -trailing cr type
-leading -trailing cr type

[edit] Go

package main
 
import (
"fmt"
"strings"
"unicode"
)
 
var simple = `
simple `

 
func main() {
show("original", simple)
show("leading ws removed", strings.TrimLeftFunc(simple, unicode.IsSpace))
show("trailing ws removed", strings.TrimRightFunc(simple, unicode.IsSpace))
// equivalent to strings.TrimFunc(simple, unicode.IsSpace)
show("both removed", strings.TrimSpace(simple))
}
 
func show(label, str string) {
fmt.Printf("%s: |%s| %v\n", label, str, []rune(str))
}

Example text is shows a leading linefeed and tab, and three trailing spaces. The code uses the Unicode definition of whitespace. Other defintions could be implemented with a custom function given to TrimXFunc.

Output below shows the text surrounded by vertical bars to show the extent of whitespace, followed by a list of the character values in the string, to show exactly what whitespace is present.

original: |
        simple   | [10 9 115 105 109 112 108 101 32 32 32]
leading ws removed: |simple   | [115 105 109 112 108 101 32 32 32]
trailing ws removed: |
        simple| [10 9 115 105 109 112 108 101]
both removed: |simple| [115 105 109 112 108 101]

[edit] Groovy

Solution uses StringUtils class from Apache Commons "Lang" library:

//Grape setup to get library
@Grab('org.apache.commons:commons-lang3:3.0.1')
import static org.apache.commons.lang3.StringUtils.*
 
def abc = '\r\n\t abc \r\n\t'
 
def printTest = {
println ('|' + it + '|')
}
 
println 'Unstripped\n------------'
printTest abc
 
println '============\n\nStripped\n------------'
printTest strip(abc)
 
println '============\n\nLeft Stripped\n------------'
printTest stripStart(abc, null)
 
println '============\n\nRight Stripped\n------------'
printTest stripEnd(abc, null)
println '============'
Output:
Unstripped
------------
|
	  abc  
	|
============

Stripped
------------
|abc|
============

Left Stripped
------------
|abc  
	|
============

Right Stripped
------------
|
	  abc|
============

[edit] Haskell

import Data.Char
 
trimLeft :: String -> String
trimLeft = dropWhile isSpace
 
trimRight :: String -> String
trimRight str | all isSpace str = ""
trimRight (c : cs) = c : trimRight cs
 
trim :: String -> String
trim = trimLeft . trimRight

[edit] Icon and Unicon

This solution takes the phrase "other such characters that have no corresponding graphical representation" quite literallly.

procedure main()
unp := &cset[1+:32]++' \t'++&cset[127:0] # all 'unprintable' chars
s := " Hello, people of earth! "
write("Original: '",s,"'")
write("leading trim: '",reverse(trim(reverse(s),unp)),"'")
write("trailing trim: '",trim(s,unp),"'")
write("full trim: '",reverse(trim(reverse(trim(s,unp)),unp)),"'")
end
Sample run:
->trim
Original:      ' Hello, people of earth!        '
leading trim:  'Hello, people of earth!         '
trailing trim: ' Hello, people of earth!'
full trim:     'Hello, people of earth!'
->

[edit] J

Note: The quote verb is only used to enclose the resulting string in single quotes so the beginning and end of the new string are visible.

   require 'strings'                      NB. the strings library is automatically loaded in versions from J7 on
quote dlb ' String with spaces ' NB. delete leading blanks
'String with spaces '
quote dtb ' String with spaces ' NB. delete trailing blanks
' String with spaces'
quote dltb ' String with spaces ' NB. delete leading and trailing blanks
'String with spaces'

In addition deb (delete extraneous blanks) will trim both leading and trailing blanks as well as replace consecutive spaces within the string with a single space.

   quote deb '  String   with spaces   '   NB. delete extraneous blanks
'String with spaces'

These existing definitions can be easily amended to include whitespace other than spaces if desired.

whpsc=: ' ',TAB                                NB. define whitespace as desired
dlws=: }.~ (e.&whpsc i. 0:) NB. delete leading whitespace (spaces and tabs)
dtws=: #~ ([: +./\. -.@:e.&whpsc) NB. delete trailing whitespace
dltws=: #~ ([: (+./\ *. +./\.) -.@:e.&whpsc) NB. delete leading & trailing whitespace
dews=: #~ (+. (1: |. (> </\)))@(-.@:e.&whpsc) NB. delete extraneous whitespace

[edit] Java

Left trim and right trim taken from here. Character.isWhitespace() returns true if the character given is one of the following Unicode characters: '\u00A0', '\u2007', '\u202F', '\u0009', '\u000A', '\u000B', '\u000C', '\u000D', '\u001C', '\u001D', '\u001E', or '\u001F'.

 
public class Trims{
public static String ltrim(String s){
int i = 0;
while (i < s.length() && Character.isWhitespace(s.charAt(i))){
i++;
}
return s.substring(i);
}
 
public static String rtrim(String s){
int i = s.length() - 1;
while (i > 0 && Character.isWhitespace(s.charAt(i))){
i--;
}
return s.substring(0, i + 1);
}
 
public static void main(String[] args){
String s = " \t \r \n String with spaces \t \r \n ";
System.out.println(ltrim(s));
System.out.println(rtrim(s));
System.out.println(s.trim()); //trims both ends
}
}

[edit] Julia

Translation of: Python
julia> s = " \t \r \n String with spaces  \t  \r  \n  "
" \t \r \n String with spaces \t \r \n "
 
julia> lstrip(s)
"String with spaces \t \r \n "
 
julia> rstrip(s)
" \t \r \n String with spaces"
 
julia> strip(s)
"String with spaces"

[edit] Lasso

Note that the example below uses the retarget operator ("&") to output as the trim method modifies the string in place.

The '>' and '<' strings have been included in this example to demonstrate the whitespace trim.

// String with leading whitespace removed
'>' + (' \t Hello')->trim& + '<'
 
// String with trailing whitespace removed
'>' + ('Hello \t ')->trim& + '<'
 
// String with both leading and trailing whitespace removed
'>' + (' \t Hello \t ')->trim& + '<'

[edit] Liberty BASIC

a$="   This is a test   "
 
'LB TRIM$ removes characters with codes 0..31 as well as a space(code 32)
'So these versions of ltrim rtrim remove them too
'a$=" "+chr$(31)+"This is a test"+chr$(31)+" "
 
print "Source line"
print ">";a$;"<"
print "Strip left"
print ">";ltrim$(a$);"<"
print "Strip right"
print ">";rtrim$(a$);"<"
print "Strip both"
print ">";trim$(a$);"<"
 
end
 
function ltrim$(a$)
c$=trim$(a$+".")
ltrim$ = mid$(c$, 1, len(c$)-1)
end function
 
function rtrim$(a$)
c$=trim$("."+a$)
rtrim$ = mid$(c$, 2)
end function
 
 

[edit] Logtalk

Using atoms for representing strings and assuming an ASCII text encoding:

 
:- object(whitespace).
 
:- public(trim/4).
 
trim(String, TrimLeft, TrimRight, TrimBoth) :-
trim_left(String, TrimLeft),
trim_right(String, TrimRight),
trim_right(TrimLeft, TrimBoth).
 
trim_left(String, TrimLeft) :-
atom_codes(String, Codes),
trim(Codes, TrimCodes),
atom_codes(TrimLeft, TrimCodes).
 
trim_right(String, TrimRight) :-
atom_codes(String, Codes),
list::reverse(Codes, ReverseCodes),
trim(ReverseCodes, ReverseTrimCodes),
list::reverse(ReverseTrimCodes, TrimCodes),
atom_codes(TrimRight, TrimCodes).
 
trim([], []).
trim([InCode| InCodes], OutCodes) :-
( InCode =< 32 ->
trim(InCodes, OutCodes)
; OutCodes = [InCode| InCodes]
).
 
:- end_object.
 

Sample output:

 
| ?- whitespace::trim('\n\t Rosetta Code \t\n', TrimLeft, TrimRight, TrimBoth).
TrimLeft = 'Rosetta Code \t\n',
TrimRight = '\n\t Rosetta Code',
TrimBoth = 'Rosetta Code'
yes
 

[edit] Lua

str = " \t \r \n String with spaces  \t  \r  \n  "
 
print( string.format( "Leading whitespace removed: %s", str:match( "^%s*(.+)" ) ) )
print( string.format( "Trailing whitespace removed: %s", str:match( "(.-)%s*$" ) ) )
print( string.format( "Leading and trailing whitespace removed: %s", str:match( "^%s*(.-)%s*$" ) ) )


[edit] Maple

str := " \t \r \n String with spaces  \t  \r  \n  ";
 
with(StringTools):
 
TrimLeft(str);
TrimRight(str);
Trim(str);

[edit] Mathematica

StringTrim[" \n\t    string with spaces   \n   \t   "]

[edit] MATLAB / Octave

% remove trailing whitespaces
str = str(1:find(~isspace(str),1,'last'));
% remove leading whitespaces
str = str(find(~isspace(str),1):end);
 
% removes leading and trailing whitespaces, vectorized version
f = ~isspace(str);
str = str(find(f,1,'first'):find(f,1,'last');
 
% a built-in function, removes leading and trailing whitespaces
str = strtrim(str);

[edit] Mercury

:- module top_and_tail.
:- interface.
 
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
:- import_module list, string.
 
main(!IO) :-
TestPhrase = "\t\r\n String with spaces \t\r\n ",
io.format("leading ws removed: %s\n", [s(lstrip(TestPhrase))], !IO),
io.format("trailing ws removed: %s\n", [s(rstrip(TestPhrase))], !IO),
io.format("both removed: %s\b", [s(strip(TestPhrase))], !IO).

[edit] Nemerle

def str = "\t\n\t   A string with\nwhitespace\n\n\t   ";
WriteLine(str.TrimStart());
WriteLine(str.TrimEnd());
WriteLine(str.Trim()); // both ends at once, of course, internal whitespace is preserved in all 3

[edit] NetRexx

NetRexx provides a strip() method which can be used to remove all of a single character from the head and/or tail of a string. To remove all whitespace characters from a string requires a little more work:

/* NetRexx */
options replace format comments java crossref symbols nobinary
 
runSample(arg)
return
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method stripWhitespace(sstring, soption = 'BOTH') public static
wsChars = getWhitspaceCharacterString()
po1 = sstring.verify(wsChars)
if po1 = 0 then do
sstring = ''
end
else do
po2 = sstring.length - (sstring.reverse().verify(wsChars) - 1) + 1
ss = sstring
parse ss sl =(po1) sm =(po2) st
if po1 <= 1 then sl = ''
soption = soption.upper()
select
when 'BOTH'.abbrev(soption, 1) then sstring = sm
when 'LEADING'.abbrev(soption, 1) then sstring = sm || st
when 'TRAILING'.abbrev(soption, 1) then sstring = sl || sm
otherwise sstring = sm
end
end
return sstring
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/**
* Create an array containing a useful subset of unicode whitespace characters
*
* @return an array of unicode whitespace characters
* @see http://www.fileformat.info/info/unicode/category/index.htm
*/

method getWhitspaceCharacters() public static returns Rexx[]
wsChars = [ -
/* LINE SEPARATOR [Zi] */ '\u2028', /* PARAGRAPH SEPARATOR [Zp] */ '\u2029', -
/* SPACE [Zs] */ '\u0020', /* NO-BREAK SPACE [Zs] */ '\u00A0', -
/* OGHAM SPACE MARK [Zs] */ '\u1680', /* MONGOLIAN VOWEL SEPARATOR [Zs] */ '\u180E', -
/* EN QUAD [Zs] */ '\u2000', /* EM QUAD [Zs] */ '\u2001', -
/* EN SPACE [Zs] */ '\u2002', /* EM SPACE [Zs] */ '\u2003', -
/* THREE-PER-EM SPACE [Zs] */ '\u2004', /* FOUR-PER-EM SPACE [Zs] */ '\u2005', -
/* SIX-PER-EM SPACE [Zs] */ '\u2006', /* FIGURE SPACE [Zs] */ '\u2007', -
/* PUNCTUATION SPACE [Zs] */ '\u2008', /* THIN SPACE [Zs] */ '\u2009', -
/* HAIR SPACE [Zs] */ '\u200A', /* NARROW NO-BREAK SPACE [Zs] */ '\u202F', -
/* MEDIUM MATHEMATICAL SPACE [Zs] */ '\u3000', /* IDIOGRAPHIC SPACE [Zs] */ '\u205F', -
/* BACKSPACE [Cc] */ '\u0008', /* CHARACTER TABULATION, HT [Cc] */ '\u0009', -
/* LINE FEED (LF) [Cc] */ '\u000A', /* LINE TABULATION (VT) [Cc] */ '\u000B', -
/* FORM FEED (FF) [Cc] */ '\u000C', /* CARRIAGE RETURN (CR) [Cc] */ '\u000D', -
/* INFORMATION SEPARATOR FOUR [Cc] */ '\u001C', /* INFORMATION SEPARATOR THREE [Cc] */ '\u001D', -
/* INFORMATION SEPARATOR TWO [Cc] */ '\u001E', /* INFORMATION SEPARATOR ONE [Cc] */ '\u001F', -
/* NEXT LINE (NEL) [Cc] */ '\u0085', -
/* ZERO WIDTH SPACE [Cf] */ '\u200B', /* ZERO WIDTH NO-BREAK SPACE [Cf] */ '\uFEFF' -
]
return wsChars
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method getWhitspaceCharacterString() public static returns Rexx
wsCharstring = ''
loop wsChar over getWhitspaceCharacters()
wsCharstring = wsCharstring || wsChar
end wsChar
return wsCharstring
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) public static
sstrings = [ -
' \u0020 \u0009 \u000D\r \n \u2029\uFEFF1 String with white space. \t \r \n \u1680 ', -
' \t 2 String with white space. \t ', -
'3 String with white space. \t', -
' \t 4 String with white space.', -
'5 String with white space.', -
'\u0020\u0009\u2029\uFEFF\u1680\u2006', -
' ', -
'' -
]
loop sstringO over sstrings
sstringL = stripWhitespace(sstringO, 'l')
sstringT = stripWhitespace(sstringO, 't')
sstringB = stripWhitespace(sstringO)
say ' Original string ['sstringO']'
say ' strip leading ['sstringL']'
say ' strip trailing ['sstringT']'
say ' strip both ['sstringB']'
say
end sstringO
 
return
 

Output:

  Original string  [   	 
  1 String with white space.  	  
    ]
    strip leading  [1 String with white space.  	  
    ]
    strip trailing [   	 
 
1 String with white space.]
    strip both     [1 String with white space.]

  Original string  [ 	 2 String with white space. 	   ]
    strip leading  [2 String with white space. 	   ]
    strip trailing [ 	 2 String with white space.]
    strip both     [2 String with white space.]

  Original string  [3 String with white space. 	]
    strip leading  [3 String with white space. 	]
    strip trailing [3 String with white space.]
    strip both     [3 String with white space.]

  Original string  [ 	 4 String with white space.]
    strip leading  [4 String with white space.]
    strip trailing [ 	 4 String with white space.]
    strip both     [4 String with white space.]

  Original string  [5 String with white space.]
    strip leading  [5 String with white space.]
    strip trailing [5 String with white space.]
    strip both     [5 String with white space.]

  Original string  [ 	
  ]
    strip leading  []
    strip trailing []
    strip both     []

  Original string  [   ]
    strip leading  []
    strip trailing []
    strip both     []

  Original string  []
    strip leading  []
    strip trailing []
    strip both     []

[edit] Nimrod

import strutils
 
let s = " \t \n String with spaces \t \n "
echo "'", s, "'"
echo "'", s.strip(trailing = false), "'"
echo "'", s.strip(leading = false), "'"
echo "'", s.strip(), "'"

[edit] Oberon-2

Oxford Oberon-2

 
MODULE Trim;
IMPORT Out,Strings,SYSTEM;
 
CONST
(* whitespaces *)
HT = 09X; VT = 0BX; FF = 0CX; GS = 1DX; US = 1FX;
LF = 0AX; CR = 0DX; FS = 1CX; RS = 1EX; SPC = 20X;
 
PROCEDURE LTrim(VAR s: ARRAY OF CHAR);
VAR
j : INTEGER;
BEGIN
j := 0;
WHILE (s[j] = HT) OR (s[j] = LF) OR (s[j] = VT) OR (s[j] = CR) OR
(s[j] = FF) OR (s[j] = FS) OR (s[j] = FS) OR (s[j] = GS) OR
(s[j] = RS) OR (s[j] = US) OR (s[j] = SPC) DO INC(j) END;
SYSTEM.MOVE(SYSTEM.ADR(s[j]),SYSTEM.ADR(s[0]),LEN(s) - j);
END LTrim;
 
PROCEDURE RTrim(VAR s: ARRAY OF CHAR);
VAR
j : INTEGER;
BEGIN
j := LEN(s) - 1;
WHILE (j >= 0) & (s[j] = 0X) DO DEC(j) END;
WHILE (j >= 0) & ((s[j] = HT) OR (s[j] = LF) OR (s[j] = VT) OR (s[j] = CR) OR
(s[j] = FF) OR (s[j] = FS) OR (s[j] = FS) OR (s[j] = GS) OR
(s[j] = RS) OR (s[j] = US) OR (s[j] = SPC)) DO
s[j] := 0X;
DEC(j)
END
END RTrim;
 
PROCEDURE Trim(VAR s: ARRAY OF CHAR);
BEGIN
LTrim(s);
RTrim(s)
END Trim;
 
VAR
s: ARRAY 100 OF CHAR;
 
BEGIN
s := " A AAA";
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);LTrim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
s := "AAA A ";
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);RTrim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
s := " A AA A ";
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);Trim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
s := " ";
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);Trim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
s := " ";
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);RTrim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
s := " ";
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);LTrim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);RTrim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);LTrim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;
END Trim.
 

Output:

[   A AAA]=	[A AAA]
[AAA A    ]=	[AAA A]
[   A AA A   ]=	[A AA A]
[    ]=	[]
[    ]=	[]
[    ]=	[]
[]=	[]
[]=	[]

[edit] Objective-C

Works with: Cocoa
Works with: GNUstep
#import <Foundation/Foundation.h>
 
@interface NSString (RCExt)
-(NSString *) ltrim;
-(NSString *) rtrim;
-(NSString *) trim;
@end
 
@implementation NSString (RCExt)
-(NSString *) ltrim
{
NSInteger i;
NSCharacterSet *cs = [NSCharacterSet whitespaceAndNewlineCharacterSet];
for(i = 0; i < [self length]; i++)
{
if ( ![cs characterIsMember: [self characterAtIndex: i]] ) break;
}
return [self substringFromIndex: i];
}
 
-(NSString *) rtrim
{
NSInteger i;
NSCharacterSet *cs = [NSCharacterSet whitespaceAndNewlineCharacterSet];
for(i = [self length] -1; i >= 0; i--)
{
if ( ![cs characterIsMember: [self characterAtIndex: i]] ) break;
}
return [self substringToIndex: (i+1)];
}
 
-(NSString *) trim
{
return [self
stringByTrimmingCharactersInSet:
[NSCharacterSet whitespaceAndNewlineCharacterSet]];
}
@end
 
int main()
{
@autoreleasepool {
 
NSString *s = @" this is a string ";
 
NSLog(@"'%@'", s);
NSLog(@"'%@'", [s ltrim]);
NSLog(@"'%@'", [s rtrim]);
NSLog(@"'%@'", [s trim]);
 
}
return 0;
}

[edit] OCaml

let left_pos s len =
let rec aux i =
if i >= len then None
else match s.[i] with
| ' ' | '\n' | '\t' | '\r' -> aux (succ i)
| _ -> Some i
in
aux 0
 
let right_pos s len =
let rec aux i =
if i < 0 then None
else match s.[i] with
| ' ' | '\n' | '\t' | '\r' -> aux (pred i)
| _ -> Some i
in
aux (pred len)
 
let trim s =
let len = String.length s in
match left_pos s len, right_pos s len with
| Some i, Some j -> String.sub s i (j - i + 1)
| None, None -> ""
| _ -> assert false
 
let ltrim s =
let len = String.length s in
match left_pos s len with
| Some i -> String.sub s i (len - i)
| None -> ""
 
let rtrim s =
let len = String.length s in
match right_pos s len with
| Some i -> String.sub s 0 (i + 1)
| None -> ""

we put the previous code in a file called "trim.ml", and then we test these functions in the toplevel:

$ ocaml
# #use "trim.ml" ;;
val left_pos : string -> int -> int option = <fun>
val right_pos : string -> int -> int option = <fun>
val trim : string -> string = <fun>
val ltrim : string -> string = <fun>
val rtrim : string -> string = <fun>
# let s = " \t \r \n String with spaces \t \r \n " ;;
val s : string = " \t \r \n String with spaces \t \r \n "
# trim s ;;
- : string = "String with spaces"
# ltrim s ;;
- : string = "String with spaces \t \r \n "
# rtrim s ;;
- : string = " \t \r \n String with spaces"

[edit] OpenEdge/Progress

DEF VAR cc AS CHAR INIT "   string with spaces   ".
 
MESSAGE
"|" + LEFT-TRIM( cc ) + "|" SKIP
"|" + RIGHT-TRIM( cc ) + "|" SKIP
"|" + TRIM( cc ) + "|"
VIEW-AS ALERT-BOX.
Output:
---------------------------
Message
---------------------------
|string with spaces   | 
|   string with spaces| 
|string with spaces|
---------------------------
OK   
---------------------------

[edit] Perl

sub ltrim { shift =~ s/^\s+//r }
sub rtrim { shift =~ s/\s+$//r }
sub trim { ltrim rtrim shift }
 
# Usage:
my $p = " this is a string ";
print "'", $p, "'\n";
print "'", trim($p), "'\n";
print "'", ltrim($p), "'\n";
print "'", rtrim($p), "'\n";

[edit] Perl 6

my $s = "\r\n \t\x2029 Good Stuff \x202F\n";
say $s.trim;
say $s.trim.perl;
say $s.trim-leading.perl;
say $s.trim-trailing.perl;
Output:
Good Stuff
"Good Stuff"
"Good Stuff  \n"
"\r\n \t
 Good Stuff

[edit] PicoLisp

(de trimLeft (Str)
(pack (flip (trim (flip (chop Str))))) )
 
(de trimRight (Str)
(pack (trim (chop Str))) )
 
(de trimBoth (Str)
(pack (clip (chop Str))) )

Test:

: (trimLeft " ^G ^I trimmed left ^L ")
-> "trimmed left ^L "

: (trimRight " ^G ^I trimmed right ^L ")
-> " ^G ^I trimmed right"

: (trimBoth " ^G ^I trimmed both ^L ")
-> "trimmed both"

[edit] PHP

There is a built-in function that already does this.

<?php 
 
/**
* @author Elad Yosifon
*/

 
$string = ' this is a string ';
echo '^'.trim($string) .'$'.PHP_EOL;
echo '^'.ltrim($string).'$'.PHP_EOL;
echo '^'.rtrim($string).'$'.PHP_EOL;
 
Output:
^this is a string$
^this is a string     $
^      this is a string$

[edit] PL/I

put ( trim(text, ' ', '') );          /* trims leading blanks.       */
put ( trim(text, '', ' ') ); /* trims trailing blanks. */
put ( trim(text) ); /* trims leading and trailing */
/* blanks. */

To remove any white-space character(s) in a portable way:-

declare whitespace character(33) value
((substr(collate(), 1, 32) || ' '));
put ( trim(text, whitespace) ); /* trims leading white space. */
put ( trim(text, '', whitespace) ); /* trims trailing white space. */
put ( trim(text, whitespace, whitespace) );
/* trims leading and trailing */
/* white space. */

[edit] Prolog

Works with SWI-Prolog.

strip :-
In = " There are unwanted blanks here! ",
strip_left(In, OutLeft),
format('In  : ~s__~n', [In]),
format('Strip left  : ~s__~n', [OutLeft]),
strip_right(In, OutRight),
format('Strip right : ~s__~n', [OutRight]),
strip(In, Out),
format('Strip  : ~s__~n', [Out]).
 
 
strip_left(In, Out) :-
strip_action(In, Out, []).
 
strip_right(In, Out) :-
reverse(In, RIn),
strip_left(RIn, ROut),
reverse(ROut, Out).
 
strip(In, Out) :-
strip_left(In, Tmp),
strip_right(Tmp, Out).
 
strip_action([X|T]) -->
{\+code_type(X, graph), !},
strip_action(T).
 
 
strip_action(X) --> X.
 

Output :

 ?- strip.
In          :     There are unwanted blanks here!    __
Strip left  : There are unwanted blanks here!    __
Strip right :     There are unwanted blanks here!__
Strip       : There are unwanted blanks here!__
true.

SWI-Prolog has an integrated version of strip : normalize_space(-Out, +In)

 ?- In = '    There are unwanted blanks here!    ', normalize_space(atom(Out), In).
In = '    There are unwanted blanks here!    ',
Out = 'There are unwanted blanks here!'.

[edit] PureBasic

Note, if only spaces need to be removed, PureBasic provides commands that do this: LTrim(), RTrim(), and Trim(). To handle a larger selection of whitespace the following functions meet the task.

;define the whitespace as desired
#whitespace$ = " " + Chr($9) + Chr($A) + Chr($B) + Chr($C) + Chr($D) + Chr($1C) + Chr($1D) + Chr($1E) + Chr($1F)
 
Procedure.s myLTrim(source.s)
Protected i, *ptrChar.Character, length = Len(source)
*ptrChar = @source
For i = 1 To length
If Not FindString(#whitespace$, Chr(*ptrChar\c))
ProcedureReturn Right(source, length + 1 - i)
EndIf
*ptrChar + SizeOf(Character)
Next
EndProcedure
 
Procedure.s myRTrim(source.s)
Protected i, *ptrChar.Character, length = Len(source)
*ptrChar = @source + (length - 1) * SizeOf(Character)
For i = length To 1 Step - 1
If Not FindString(#whitespace$, Chr(*ptrChar\c))
ProcedureReturn Left(source, i)
EndIf
*ptrChar - SizeOf(Character)
Next
EndProcedure
 
Procedure.s myTrim(source.s)
ProcedureReturn myRTrim(myLTrim(source))
EndProcedure
 
If OpenConsole()
PrintN(#DQUOTE$ + myLTrim(" Top ") + #DQUOTE$)
PrintN(#DQUOTE$ + myRTrim(" Tail ") + #DQUOTE$)
PrintN(#DQUOTE$ + myTrim(" Both ") + #DQUOTE$)
 
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf
Output:
"Top  "
"  Tail"
"Both"

[edit] Python

>>> s = ' \t \r \n String with spaces  \t  \r  \n  '
>>> s
' \t \r \n String with spaces \t \r \n '
>>> s.lstrip()
'String with spaces \t \r \n '
>>> s.rstrip()
' \t \r \n String with spaces'
>>> s.strip()
'String with spaces'
>>>

[edit] Racket

 
#lang racket
 
;; Using Racket's `string-trim'
 
(define str " \n\t foo bar \r\n ")
 
;; both sides:
(string-trim str) ; -> "foo bar"
 
;; one side:
(string-trim str #:right? #f) ; -> "foo bar \r\n "
(string-trim str #:left? #f)  ; -> " \n\t foo bar"
 
;; can also normalize spaces:
(string-normalize-spaces (string-trim str)) ; -> "foo bar"
 

[edit] Retro

"  this is a test   "  ^strings'trimLeft
" this is a test " ^strings'trimRight
" this is a test " ^strings'trimLeft ^strings'trimRight

[edit] REXX

[edit] version 1

There are other methods to remove white space, but they are pretty obtuse compared to these simple methods (functions).

/*REXX program to show how to strip leading and/or trailing spaces.     */
 
yyy=" this is a string that has leading/embedded/trailing blanks, fur shure. "
 
/*white space also includes tabs (VT & HT),*/
/*among other characters. */
 
/*all examples in each group are equivalent*/
/*only the option's first char is examined.*/
 
/*───────────────────────just remove the leading white space. */
noL=strip(yyy,'L')
noL=strip(yyy,"l")
noL=strip(yyy,'leading')
g="Listen, birds / those signs cost money / so roost a while / but don't get funny / Burma-shave"
noL=strip(yyy,g) /*a long way to go to fetch a pail of water.*/
 
/*───────────────────────just remove the trailing white space. */
noT=strip(yyy,'T')
noT=strip(yyy,"t")
noT=strip(yyy,'trailing')
noT=strip(yyy,'trains ride the rails')
j="Toughest Whiskers / In the town / We hold 'em up / You mow 'em down / Burma-Shave"
noT=strip(yyy,j)
 
/*───────────────────────remove leading and trailing white space. */
noB=strip(yyy)
noB=strip(yyy,)
noB=strip(yyy,'B')
noB=strip(yyy,"b")
noB=strip(yyy,'both')
opt='Be a noble / Not a knave / Caesar uses / Burma-Shave'
noB=strip(yyy,opt)
 
/*───────────────────────also remove all superfluous white space, */
noX=space(yyy) /* including white space between words. */

[edit] version 2

/* REXX ***************************************************************
* 01.1.2012 Walter Pachl taking care of all non-printable chars
**********************************************************************/

pc='abcdefghijklmnopqrstuvwxyz'
pc=pc||translate(pc)'äöüÄÖÜß1234567890!"§&/()=?*+''#;:_,.-<>^!'
x01='01'x
s=x01||' Hi '||x01||' there! '||x01
say pc /* all printable characters */
s=x01||' Hi '||x01||' there! '||x01 /* my source string */
Say 's >'s'<' /* show it */
p1=verify(s,pc,'M') /* find first printable char */
sl=substr(s,p1) /* start with it */
Say 'sl>'sl'<'
sr=reverse(s)
p2=verify(sr,pc,'M') /* find last printable char */
sr=left(s,length(s)-p2+1) /* end with it */
Say 'sr>'sr'<'
sb=substr(s,p1,length(s)-p1-p2+1) /* remove leading & trailing */
Say 'sb>'space(sb)'!' /* whitespace */
sa=translate(s,pc,pc!!xrange('00'x,'FF'x)) /* all nonprintable chars */
/* are translated to blanks */
sa=space(sa) /* eliminate them except 1 */
Say 'sa>'sa'<'<' /* between words */
s0=space(sa,0) /* remove all whitespace */
Say '
s0>'s0'<'

Output:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZäöüÄÖÜß1234567890!"§&/()=?*+'#;:_,.-<>^!
s >�  Hi  � there!  �<
sl>Hi  � there!  �<
sr>�  Hi  � there!<
sb>Hi  � there!<
sa>Hi there!<    
s0>Hithere!<      

[edit] Ruby

s = " \t\v\r\n\ffoo bar \t\v\r\n\f"
p s
p s.lstrip # remove leading whitespaces
p s.rstrip # remove trailing whitespaces
p s.strip # remove both leading and trailing whitespace
 
Output:
" \t\v\r\n\ffoo bar \t\v\r\n\f"
"foo bar \t\v\r\n\f"
" \t\v\r\n\ffoo bar"
"foo bar"

[edit] Run BASIC

string$ = "  abcdefg  "
 
print " Top:";trim$(string$+"|") ' top left trim
print "Bottom:";trim$("|"+string$) ' bottom right trim
print " Both:";trim$(string$) ' both left and right
end
   Top:abcdefg 
Bottom:  abcdefg
  Both:abcdefg

[edit] Rust

// rust 0.9-pre
 
fn main()
{
let string = "String without spaces";
let spaces = " \x0B\t\r\n \xA0 \u2000 \u3000 ";
let string_with_spaces = spaces + string + spaces;
 
assert_eq!(string_with_spaces.trim(), string);
assert_eq!(string_with_spaces.trim_left().to_owned(), string + spaces);
assert_eq!(string_with_spaces.trim_right().to_owned(), spaces + string);
}

[edit] Sather

class MAIN is
ltrim(s :STR) :STR is
i ::= 0;
loop while!(i < s.size);
if " \t\f\v\n".contains(s[i]) then
i := i + 1;
else
break!;
end;
end;
return s.tail(s.size - i);
end;
 
rtrim(s :STR) :STR is
i ::= s.size-1;
loop while!(i >= 0);
if " \t\f\v\n".contains(s[i]) then
i := i - 1;
else
break!;
end;
end;
return s.head(i+1);
end;
 
trim(s :STR) :STR is
return ltrim(rtrim(s));
end;
 
 
main is
p ::= " this is a string ";
#OUT + ltrim(p).pretty + "\n";
#OUT + rtrim(p).pretty + "\n";
#OUT + trim(p).pretty + "\n";
end;
end;

[edit] Scala

def trimLeft(str: String) = str dropWhile(_.isWhitespace)
 
def trimRight(str: String) = str take (str.lastIndexWhere(!_.isWhitespace) + 1)
 
def trimRight2(str: String) = trimLeft(str reverse) reverse
 
def trim(str: String) = str trim
 
def testTrim() = {
val str = " \u001F String with spaces \t \n \r "
println("original  : |" + str + "|")
println("trimLeft  : |" + trimLeft(str) + "|")
println("trimRight : |" + trimRight(str) + "|")
println("trimRight2: |" + trimRight2(str) + "|")
println("trim  : |" + trim(str) + "|")
}
Output:
original  : |  �  String with spaces 	  
  
 |
trimLeft  : |String with spaces 	  
  
 |
trimRight : |  �  String with spaces|
trimRight2: |  �  String with spaces|
trim      : |String with spaces|

[edit] Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
local
const string: testStri is " \t \r \n String with spaces \t \r \n ";
begin
writeln(ltrim(testStri));
writeln(rtrim(testStri));
writeln(trim(testStri));
end func;

[edit] Smalltalk

Works with: GNU Smalltalk
String extend
[
ltrim [
^self replacingRegex: '^\s+' with: ''.
]
rtrim [
^self replacingRegex: '\s+$' with: ''.
]
trim [
^self ltrim rtrim.
]
]
 
|a|
a := ' this is a string '.
 
('"%1"' % {a}) displayNl.
('"%1"' % {a ltrim}) displayNl.
('"%1"' % {a rtrim}) displayNl.
('"%1"' % {a trim}) displayNl.

[edit] Tcl

Whitespace stripping is done with string trim and related commands:

set str "      hello world      "
puts "original: >$str<"
puts "trimmed head: >[string trimleft $str]<"
puts "trimmed tail: >[string trimright $str]<"
puts "trimmed both: >[string trim $str]<"
Output:
original: >      hello world      <
trimmed head: >hello world      <
trimmed tail: >      hello world<
trimmed both: >hello world<

[edit] TI-83 BASIC

 
PROGRAM:WHITESPC
Input Str1
0→M
Menu(" REMOVE ","TRAILIN WHTSPC",A,"LEADING WHTSPC",C,"BOTH",B)
 
Lbl B
1→M
 
Lbl A
While sub(Str1,length(Str1)-1),1)=" "
sub(Str1,1,length(Str1)-1)→Str1
End
 
If M=1
Then
Goto C
Else
Goto F
End
 
Lbl C
While sub(str1,1,1)=" "
sub(Str1,2,length(Str1)-1)→Str1
End
 
Lbl F
Disp "'"+Str1+"'"
 

[edit] TorqueScript

Remove leading whitespace

 $string = "                 yep                 ";
 $string = LTrim($string);
 echo($string);

Remove trailing whitespace

 $string = "                 yep                 ";
 $string = RTrim($string);
 echo($string);

Remove leading and trailing white spaces

 $string = "                 yep                 ";
 $string = trim($string);
 echo($string);


Output

 "yep                 "
 "                 yep"
 "yep"

[edit] TUSCRIPT

$$ MODE TUSCRIPT
str= " sentence w/whitespace before and after "
trimmedtop=EXTRACT (str,":<|<> :"|,0)
trimmedtail=EXTRACT (str,0,":<> >|:")
trimmedboth=SQUEEZE(str)
PRINT "string <|", str," >|"
PRINT "trimmed on top <|",trimmedtop,">|"
PRINT "trimmed on tail <|", trimmedtail,">|"
PRINT "trimmed on both <|", trimmedboth,">|"
Output:
string           <|      sentence w/whitespace before and after     >|
trimmed on top   <|sentence w/whitespace before and after    >|
trimmed on tail  <|      sentence w/whitespace before and after>|
trimmed on both  <|sentence w/whitespace before and after>|

[edit] TXR

[edit] Pattern Matching Language Exercise

Here, no builtin functions are used, just text pattern matching logic. Two functions are written, conforming to the proper filter convention, and then employed as filters.

@(define trim_left (in out))
@ (next :list in)
@/[ \t]*/@out
@(end)
@(define trim_right (in out))
@ (local blanks middle)
@ (next :list in)
@ (cases)
@ {blanks /[ \t]*/}@middle@/[\t ]+/
@ (bind out `@blanks@middle`)
@ (or)
@ out
@ (end)
@(end)
@line_of_input
@(output)
trim-left: [@{line_of_input :filter (:fun trim_left)}]
trim_right: [@{line_of_input :filter (:fun trim_right)}]
trim_both: [@{line_of_input :filter ((:fun trim_left) (:fun trim_right))}]
@(end)
Output:
$ echo "" | txr trim.txr  -
trim-left:  []
trim_right: []
trim_both:  []
$ echo "a" | txr trim.txr  -
trim-left:  [a]
trim_right: [a]
trim_both:  [a]
$ echo " a" | txr trim.txr  -
trim-left:  [a]
trim_right: [ a]
trim_both:  [a]
$ echo " a " | txr trim.txr  -
trim-left:  [a ]
trim_right: [ a]
trim_both:  [a]
$ echo " a b " | txr trim.txr  -
trim-left:  [a b ]
trim_right: [ a b]
trim_both:  [a b]

[edit] Using Lisp Primitives

Trimming whitespace from both ends is a builtin:

$ txr -p '(trim-str " a b ")'
"a b"

An unnecessarily cryptic, though educational, left trim:

$ txr -p '[(do progn (del [@1 0..(match-regex @1 #/\s*/)]) @1) " a b "]'
"a b "

Explanation: the basic structure is [function " a b "] where the function is an anonymous lambda generated using the do operator. The function is applied to the string " a b ".

The structure of the do is (do progn (blah @1) @1) where the forms make references to implicit argument @1, and so the generated lambda has one argument, essentially being: (lambda (arg) (blah arg) arg): do something with the argument (the string) and then return it.

What is done with the argument is this: (del [@1 0..(match-regex @1 #/\s+/)]). The match-regex function returns the number of characters at the front of the string which match the regex \s*: one or more spaces. The return value of this is used to express a range 0..length which is applied to the string. The syntax (del [str from..to]) deletes a range of characters in the string.

Lastly, a pedestrian right trim:

@(do
(defun trim-right (str)
(for ()
((and (> (length str) 0) (chr-isspace [str -1])) str)
((del [str -1]))))
 
(format t "{~a}\n" (trim-right " a a "))
(format t "{~a}\n" (trim-right " "))
(format t "{~a}\n" (trim-right "a "))
(format t "{~a}\n" (trim-right "")))

Output:

{ a a}
{}
{a}
{}

[edit] Vala

[edit] Strip Leading White Space

string s = "   word   ";
string s_chug = s.chug();

[edit] Strip Trailing White Space

string s = "   word   ";
string s_chomp = s.chomp();

[edit] Strip Leading & Trailing White Space

string s = "   word   ";
string s_strip = s.strip();

[edit] Ursala

#import std
 
white = ==` !| not @iNC %sI
trim_left = white-~r
trim_right = white~-l
trim_both = trim_left+ trim_right
 
#cast %sgUL
 
main = <.trim_left,trim_right,trim_both> ' string with spaces '
  • The white predicate tests an argument for whiteness by either comparing it to a literal space character or testing whether the singleton list containing it is of a string (%s) type.
  • The -~ postfix operator takes a predicate to a function that takes a string to a pair of strings whose concatenation is the original string and whose left side is the maximal prefix of the original string whose members satisfy the predicate.
  • The r suffix on the -~ predicate extracts the right side of the pair of strings in the result.
  • The ~- operator is similar to the -~ operator except that is concerned with the maximal suffix whose members satisfy the predicate.
  • The l suffix extracts the right side.
Output:
<
   'string with spaces   ',
   '  string with spaces',
   'string with spaces'>

[edit] XPL0

code ChOut=8, CrLf=9, Text=12;
string 0; \use zero-terminated string convention
 
func StripLead(S0); \Strip leading whitespace (<=$20) from string
char S0;
char S1(80); \BEWARE: very temporary string space returned
int I, J, C, Stripped;
[I:= 0; J:= 0; Stripped:= false;
repeat C:= S0(I); I:= I+1;
if Stripped ! C>$20 ! C=0 then
[S1(J):= C; J:= J+1; Stripped:= true];
until C=0;
return S1;
];
 
func StripTrail(S0); \Strip trailing whitespace (<=$20) from string
char S0;
char S1(80); \BEWARE: very temporary string space returned
int I, SI;
[I:= 0;
loop [if S0(I) <= $20 then
[SI:= I;
while S0(I) <= $20 do
[if S0(I) = 0 then [S1(SI):= 0; return S1];
S1(I):= S0(I); I:= I+1;
];
]
else [S1(I):= S0(I); I:= I+1];
];
];
 
char String;
[String:= " Hello World ";
Text(0, StripLead(String)); ChOut(0, ^!); CrLf(0);
Text(0, StripTrail(String)); ChOut(0, ^!); CrLf(0);
Text(0, StripTrail(StripLead(String))); ChOut(0, ^!); CrLf(0);
]

Output:

Hello World  !
  Hello World!
Hello World!

[edit] zkl

Remove white space from both end of string:

"\t\n hoho\n\t\ ".strip() //-->"hoho"
fcn removeLeadingWS(s){n:=0;
try{while(s[n].isSpace()){n+=1}}catch{""} else{s[n,*]} }
removeLeadingWS("\t\n hoho\n\t\ ") //-->"hoho\n\t "
removeLeadingWS("") //-->""
fcn removeTrailingWS(s){n:=-1;
try{while(s[n].isSpace()){n-=1} s[0,n+1]}catch{""} }
removeTrailingWS("\t\n hoho\n\t\ ") //-->"\t\n hoho"
removeTrailingWS("\t\n \n\t\ ") //-->""
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox