Strip whitespace from a string/Top and tail: Difference between revisions

{{Template:Strings}}

<br><br>

 

=={{header|Ada}}==

with Ada.Strings; use Ada.Strings;

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

Put_Line ("'" & Trim (str, Right) & "'");

Put_Line ("'" & Trim (str, Both) & "'");

{{out}}

<pre>

=== version 1 ===

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

PROC trim leading whitespace = ( STRING text )STRING:

BEGIN

print( ( "trim trailing: """ + trim trailing whitespace( test ) + """", newline ) );

print( ( "trim both: """ + trim whitespace ( test ) + """", newline ) )

{{out}}

<pre>

A single procedure that trims leading space, trailing space, or both.

 

string_trim

Trim leading and trailing whitespace from string.

print(("string_trim(' foobar '): expected 'foobar'; actual: "

+ string_trim(" foobar "), newline)) FI

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

{{Trans|Haskell}}

 

-- STRIP WHITESPACE ----------------------------------------------------------

|error|:(missing value))'s firstMatchInString:oString options:0 ¬

range:{location:0, |length|:oString's |length|()}) is not missing value

{{Out}}

<--", "-->

 

=={{header|Arturo}}==

 

 

print [pad "strip all:" 15 ">" strip str "<"]

print [pad "strip leading:" 15 ">" strip.start str "<"]

 

{{out}}

=={{header|AutoHotkey}}==

AutoHotkey_L and v2 contain a [http://www.autohotkey.net/~Lexikos/AutoHotkey_L/docs/commands/Trim.htm Trim function]

{{out}}

<pre><abc >

*[:graph:] is a POSIX character class for characters that are both printable and visible. The following strips the entire non-[:graph:] character set. A simplified version for the more common task of removing only spaces and tabs follows it.

 

c = split(str, arr, "")

for ( i = match(str, /[[:graph:]]/); i <= c; i++)

print "right = |" trimright(str) "|"

print "both = |" trim(str) "|"

 

{{out|Output from 26 May 2015}}

Simplified for removing [:blank:] (spaces and tabs) or [:space:] (for [ \t\r\n\v\f] ). This method does not work using [:graph:]

 

gsub(/^[[:blank:]]+/,"", str) # Remove leading

gsub(/[[:blank:]]+$/,"", str) # Remove trailing

gsub(/^[[:blank:]]+|[[:blank:]]+$/, "", str) # Remove both

return str;

 

=={{header|BaCon}}==

 

'---Remove leading whitespace

PRINT CHOP$(" String with spaces "," ",1)

'---Remove both leading and trailing whitespace

PRINT CHOP$(" String with spaces "," ",0)

 

=={{header|BASIC}}==

{{works with|QBasic}}

mystring$=rtrim(mystring$) ' remove trailing whitespace

 

=={{header|BBC BASIC}}==

WHILE ASC(A$)<=32 A$ = MID$(A$,2) : ENDWHILE

REM Remove both leading and trailing whitespace:

WHILE ASC(A$)<=32 A$ = MID$(A$,2) : ENDWHILE

 

=={{header|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.

= s

. @( !arg

& out$(str$("trim :[" trim$!string "]"))

&

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

<pre>Input:[ Hear

=={{header|Burlesque}}==

 

blsq ) " this is a string "t[

"this is a string "

blsq ) " this is a string "tt

"this is a string"

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

free(d);

return 0;

 

=={{header|C sharp|C#}}==

 

public class TrimExample

return "'" + s + "'";

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <string>

#include <iostream>

std::cout << "Trimmed on both sides :" << testphrase << "\n" ;

return 0 ;

{{out}}

<PRE>The test phrase is : There are unwanted blanks here!

 

=={{header|Clojure}}==

(use 'clojure.string)

(triml " my string ")

(trim " \t\r\n my string \t\r\n ")

=> "my string"

 

=={{header|COBOL}}==

{{works with|GNU Cobol|2.0}}

DISPLAY "'" FUNCTION TRIM(str, TRAILING) "'"

 

{{works with|IBM ILE COBOL}}

DISPLAY "'" FUNCTION TRIMR(str) "'"

 

=={{header|Common Lisp}}==

(defvar *whitespace* '(#\Space #\Newline #\Tab))

 

 

(string-right-trim *unicode-whitespace* unicode-str)

 

=={{header|Crystal}}==

def strip_whitepace(s)

puts s.lstrip()

# => hello

# => hello

 

=={{header|D}}==

 

void main() {

assert(s.stripRight() == " \t \r \n String with spaces");

assert(s.strip() == "String with spaces");

 

=={{header|Delphi}}/{{header|Pascal}}==

 

{$APPTYPE CONSOLE}

Writeln('"' + TrimRight(TEST_STRING) + '"');

Writeln('"' + Trim(TEST_STRING) + '"');

 

=={{header|DWScript}}==

{{Trans|Delphi}}

 

PrintLn('"' + TEST_STRING + '"');

PrintLn('"' + TrimLeft(TEST_STRING) + '"');

PrintLn('"' + TrimRight(TEST_STRING) + '"');

 

=={{header|EchoLisp}}==

(define witt

" The limits of my world are the limits of my langage. ")

(string->html (string-trim-right witt))

→ " The limits of my world are the limits of my langage."

 

=={{header|Elena}}==

ELENA 4.x :

public program()

console.printLine("'", toTrim.trimRight(),"'");

console.printLine("'", toTrim.trim(),"'");

{{out}}

<pre>

 

=={{header|Elixir}}==

IO.inspect String.strip(str)

IO.inspect String.rstrip(str)

{{out}}

<pre>

 

=={{header|Emacs Lisp}}==

 

 

 

 

 

 

=={{header|Erlang}}==

1> string:strip(" Hello World! ", left). %remove leading whitespaces

"Hello World! "

3> string:strip(" Hello World! ", both). % remove both leading and trailing whitespace

"Hello World!"

 

=={{header|Euphoria}}==

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/text.e

 

end for

Output:<pre>

String Trimmed is now: A B C

 

=={{header|F_Sharp|F#}}==

let main args =

printfn "%A" (args.[0].TrimStart())

printfn "%A" (args.[0].TrimEnd())

printfn "%A" (args.[0].Trim())

<pre>

>rosetta " a string "

=={{header|Factor}}==

{{works with|Factor|0.98}}

" test string " [ blank? ] trim ! leading and trailing

" test string " [ blank? ] trim-head ! only leading

 

=={{header|Forth}}==

After the string processing is completed on the stack the program can print or copy back to memory as required.

 

begin

over c@ bl = \ fetch character at addr, test if blank (space)

\ cut 1 leading character by incrementing address & decrementing length

1 /string \ "cut-string"

The counterpart function "-trailing" is normally part of a standard forth system,

so by concatenating both we create a "STRIP" function.

Test at the Forth console

<pre>: mystring s" Trim this string. " ;

 

=={{header|FreeBASIC}}==

 

Const whitespace = !" \t\n\v\f\r"

Print "Right trimmed" , "=> Length = "; Len(s2)

Print "Fully trimmed" , "=> Length = "; Len(s3)

 

{{out}}

Right trimmed => Length = 15

Fully trimmed => Length = 12

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=62e56fea0f74819daa3d3a548869fa90 Click this link to run this code]'''

Dim sString As String = " Hello world! "

 

Print Trim(sString) & "\t\tString length = " & Len(Trim(sString)) & " - String with both leading and trailing whitespace removed"

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

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.

 

=={{header|Groovy}}==

Solution uses StringUtils class from [http://commons.apache.org/lang/ Apache Commons "Lang" library]:

@Grab('org.apache.commons:commons-lang3:3.0.1')

import static org.apache.commons.lang3.StringUtils.*

println '============\n\nRight Stripped\n------------'

printTest stripEnd(abc, null)

{{out}}

<pre>Unstripped

 

=={{header|Haskell}}==

import Data.List (dropWhileEnd)

 

 

trim :: String -> String

 

=={{header|Icon}} and {{header|Unicon}}==

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

unp := &cset[1+:32]++' \t'++&cset[127:0] # all 'unprintable' chars

s := " Hello, people of earth! "

write("trailing trim: '",trim(s,unp),"'")

write("full trim: '",reverse(trim(reverse(trim(s,unp)),unp)),"'")

{{out|Sample run}}

<pre>->trim

=={{header|J}}==

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

quote dlb ' String with spaces ' NB. delete leading blanks

'String with spaces '

' String with spaces'

quote dltb ' String with spaces ' NB. delete leading and trailing blanks

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

These existing definitions can be easily amended to include whitespace other than spaces if 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

 

=={{header|Java}}==

Left trim and right trim taken from [http://www.fromdev.com/2009/07/playing-with-java-string-trim-basics.html here].

 

 

 

=={{header|Javascript}}==

{{works with|Node.js}}

{{works with|ECMAScript standard|2015}}

let s = " \t String with spaces \t ";

// a future version of ECMAScript will have trimStart(). Some current

console.log("trimmed right: '" + s.replace(/\s+$/,'') + "'");

console.log("trimmed both: '" + s.trim() + "'");

{{Output}}

<pre>original: ' String with spaces '

 

{{Trans|Haskell}}

'use strict';

 

 

})();

 

{{Out}}

 

Notice that since jq strings are JSON strings, one must, for example, write "\\s" for the regex '\s'.

 

def rstrip: sub( "[\\s\\p{Cc}]+$"; "" );

 

'''Examples''':

"lstrip: \(lstrip)",

"rstrip: \(rstrip)",

"\u0001 \u0002 <- ^A ^B"

) | demo

{{Out}}

"lstrip: String with spaces \t \r \n "

"rstrip: \t \r \n String with spaces"

"lstrip: <- ^A ^B"

"rstrip: \u0001 \u0002 <- ^A ^B"

 

=={{header|Jsish}}==

Using echo-mode unitTest lines. Lines starting with semicolon are echoed and captured during test.

 

/* Strip whitespace from string, in Jsi */

var str = ' \n \t String with whitespace \t \n ';

str.trim() ==> String with whitespace

=!EXPECTEND!=

 

{{out}}

=={{header|Julia}}==

{{trans|Python}}

" \t \r \n String with spaces \t \r \n "

 

 

julia> strip(s)

 

=={{header|Kotlin}}==

 

 

{{out}}

<pre>

 

 

 

=={{header|Lambdatalk}}==

initial string : {def string ___String with "_" displaying space_____}

-> string ___String with "_" displaying space_____

trimBoth : {S.replace _+$ by in {S.replace ^_+ by in {string}}}

-> String with "_" displaying space

 

=={{header|Lasso}}==

 

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

'>' + (' \t Hello')->trim& + '<'

 

 

// String with both leading and trailing whitespace removed

 

=={{header|Liberty BASIC}}==

 

'LB TRIM$ removes characters with codes 0..31 as well as a space(code 32)

end function

 

=={{header|Logtalk}}==

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

:- object(whitespace).

 

 

:- end_object.

Sample output:

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

TrimLeft = 'Rosetta Code \t\n',

TrimBoth = 'Rosetta Code'

yes

 

=={{header|Lua}}==

 

print( string.format( "Leading whitespace removed: %s", str:match( "^%s*(.+)" ) ) )

print( string.format( "Trailing whitespace removed: %s", str:match( "(.-)%s*$" ) ) )

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

filter$=chr$(0)

}

Checkit

{{out}}

<pre style="height:30ex;overflow:scroll">

 

=={{header|Maple}}==

 

with(StringTools):

TrimLeft(str);

TrimRight(str);

 

 

=={{header|MATLAB}} / {{header|Octave}}==

str = str(1:find(~isspace(str),1,'last'));

% remove leading whitespaces

 

% a built-in function, removes leading and trailing whitespaces

 

=={{header|Mercury}}==

:- interface.

 

io.format("leading ws removed: %s\n", [s(lstrip(TestPhrase))], !IO),

io.format("trailing ws removed: %s\n", [s(rstrip(TestPhrase))], !IO),

 

=={{header|Nemerle}}==

WriteLine(str.TrimStart());

WriteLine(str.TrimEnd());

 

=={{header|NetRexx}}==

NetRexx provides a <tt>strip()</tt> 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:

options replace format comments java crossref symbols nobinary

 

 

return

'''Output:'''

<pre style="height: 25ex; overflow:scroll;">

 

=={{header|NewLISP}}==

 

;; trim leading blanks

 

;; trim both leading and trailing blanks

 

=={{header|Nim}}==

 

 

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE Trim;

IMPORT Out,Strings,SYSTEM;

Out.Char("[");Out.String(s);Out.String("]=");Out.Char(HT);LTrim(s);Out.Char("[");Out.String(s);Out.Char("]");Out.Ln;

END Trim.

Output:

<pre>

{{works with|Cocoa}}

{{works with|GNUstep}}

 

@interface NSString (RCExt)

}

return 0;

 

=={{header|OCaml}}==

let rec aux i =

if i >= len then None

match right_pos s len with

| Some i -> String.sub s 0 (i + 1)

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

<pre>$ ocaml

 

=={{header|OpenEdge/Progress}}==

 

MESSAGE

"|" + RIGHT-TRIM( cc ) + "|" SKIP

"|" + TRIM( cc ) + "|"

{{out}}

<pre>

 

=={{header|Perl}}==

sub rtrim { shift =~ s/\s+$//r }

sub trim { ltrim rtrim shift }

print "'", trim($p), "'\n";

print "'", ltrim($p), "'\n";

 

=={{header|Phix}}==

{{out}}

<pre>

"test"

</pre>

=={{header|PHP}}==

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

 

/**

echo '^'.ltrim($string).'$'.PHP_EOL;

echo '^'.rtrim($string).'$'.PHP_EOL;

{{out}}

<pre>

^ this is a string$

</pre>

 

=={{header|PicoLisp}}==

(pack (flip (trim (flip (chop Str))))) )

 

 

(de trimBoth (Str)

Test:

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

 

=={{header|PL/I}}==

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

put ( trim(text) ); /* trims leading and trailing */

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

((substr(collate(), 1, 32) || ' '));

put ( trim(text, whitespace) ); /* trims leading white space. */

put ( trim(text, whitespace, whitespace) );

/* trims leading and trailing */

 

=={{header|PowerShell}}==

$var = " Hello World "

$var.TrimStart() # String with leading whitespace removed

$var.TrimEnd() # String with trailing whitespace removed

$var.Trim() # String with both leading and trailing whitespace removed

<b>Output:</b>

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog.

In = " There are unwanted blanks here! ",

strip_left(In, OutLeft),

 

strip_action(X) --> X.

Output :

<pre> ?- strip.

{{works with|SWI-Prolog|7}}

 

:- system:set_prolog_flag(double_quotes,chars) .

 

\+ [_] % .i.e. at end-of-string .

.

 

 

=={{header|PureBasic}}==

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

#whitespace$ = " " + Chr($9) + Chr($A) + Chr($B) + Chr($C) + Chr($D) + Chr($1C) + Chr($1D) + Chr($1E) + Chr($1F)

 

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>"Top "

 

=={{header|Python}}==

>>> s

' \t \r \n String with spaces \t \r \n '

>>> s.strip()

'String with spaces'

 

=={{header|Quackery}}==

As a dialogue in the Quackery shell.

 

... [ trim trim-trailing ] is trim-both-ends ( $ --> $ )

... $ ' a quick quack ' echo$ say "!" cr

a quick quack!

 

 

=={{header|R}}==

 

 

trimws(s)

 

trimws(s, "right")

 

=={{header|Racket}}==

 

#lang racket

 

;; can also normalize spaces:

(string-normalize-spaces (string-trim str)) ; -> "foo bar"

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2020.08.1}}

say $s.trim;

say $s.trim.raku;

say $s.trim-leading.raku;

 

{{Output}}

 

=={{header|Red}}==

== "remove leading white space "

>> trim/tail " remove trailing white space "

== " remove trailing white space"

>> trim " remove both white spaces "

 

=={{header|Retro}}==

'__this_is_a_test___ s:trim-right

 

=={{header|REXX}}==

 

===version 1===

yyy=" this is a string that has leading/embedded/trailing blanks, fur shure. "

say 'YYY──►'yyy"◄──" /*display the original string + fence. */

noX=space(yyy) /* including white space between words.*/

say 'nox──►'noX"◄──" /*display the string with a title+fence*/

'''output'''

<pre>

 

===version 2===

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

**********************************************************************/

Say 'sa>'sa'<'<' /* between words */

s0=space(sa,0) /* remove all whitespace */

Output:

<pre>

 

=={{header|Ring}}==

aList = " Welcome to the Ring Programming Language "

see aList + nl

see trim(aList) + nl

 

=={{header|Ruby}}==

p s

p s.lstrip # remove leading whitespaces

p s.rstrip # remove trailing whitespaces

p s.strip # remove both leading and trailing whitespace

{{out}}

<pre>

 

=={{header|Run BASIC}}==

 

print " Top:";trim$(string$+"|") ' top left trim

print "Bottom:";trim$("|"+string$) ' bottom right trim

print " Both:";trim$(string$) ' both left and right

<pre> Top:abcdefg

Bottom: abcdefg

 

=={{header|Rust}}==

let spaces = " \t\n\x0B\x0C\r \u{A0} \u{2000}\u{3000}";

let string_with_spaces = spaces.to_owned() + "String without spaces" + spaces;

assert_eq!(string_with_spaces.trim_left(), "String without spaces".to_owned() + spaces);

assert_eq!(string_with_spaces.trim_right(), spaces.to_owned() + "String without spaces");

 

=={{header|Sather}}==

ltrim(s :STR) :STR is

i ::= 0;

#OUT + trim(p).pretty + "\n";

end;

 

=={{header|Scala}}==

 

def trimRight(str: String) = str take (str.lastIndexWhere(!_.isWhitespace) + 1)

println("trimRight2: |" + trimRight2(str) + "|")

println("trim : |" + trim(str) + "|")

{{out}}

<pre>original : | � String with spaces

 

=={{header|Seed7}}==

 

const proc: main is func

writeln(rtrim(testStri));

writeln(trim(testStri));

 

=={{header|Sidef}}==

say s.strip_beg.dump; # remove leading whitespaces

say s.strip_end.dump; # remove trailing whitespaces

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

[

ltrim [

('"%1"' % {a ltrim}) displayNl.

('"%1"' % {a rtrim}) displayNl.

 

=={{header|SNOBOL4}}==

s2 = CHAR(3) s2 CHAR(134)

&ALPHABET TAB(33) . prechars

s2 POS(0) SPAN(stripchars) =

OUTPUT = "Full trim: >" s2 "<"

{{out}}

<pre>

Trailing: >� Hello, people of earth!<

Full trim: >Hello, people of earth!<</pre>

 

=={{header|Stata}}==

See '''[https://www.stata.com/help.cgi?mf_strtrim strtrim]''' in Stata help. Use the equivalent '''[https://www.stata.com/help.cgi?mf_ustrtrim ustrtrim]''' functions with Unicode strings.

 

"("+strtrim(s)+")"

(ars longa)

 

"("+stritrim(s)+")"

 

=={{header|Tcl}}==

Whitespace stripping is done with <code>string trim</code> and related commands:

puts "original: >$str<"

puts "trimmed head: >[string trimleft $str]<"

puts "trimmed tail: >[string trimright $str]<"

{{out}}

<pre>

 

=={{header|TI-83 BASIC}}==

PROGRAM:WHITESPC

Input Str1

Lbl F

Disp "'"+Str1+"'"

 

=={{header|TorqueScript}}==

" yep"

"yep"

 

=={{header|TUSCRIPT}}==

str= " sentence w/whitespace before and after "

trimmedtop=EXTRACT (str,":<|<> :"|,0)

PRINT "trimmed on top <|",trimmedtop,">|"

PRINT "trimmed on tail <|", trimmedtail,">|"

{{out}}

<pre>

===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.

@ (next :list in)

@/[ \t]*/@out

trim_right: [@{line_of_input :filter (:fun trim_right)}]

trim_both: [@{line_of_input :filter ((:fun trim_left) (:fun trim_right))}]

{{out}}

<pre>$ echo "" | txr trim.txr -

Trimming whitespace from both ends is a builtin:

 

 

An unnecessarily cryptic, though educational, left trim:

 

 

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

Lastly, a pedestrian right trim:

 

(for ()

((and (> (length str) 0) (chr-isspace [str -1])) str)

(format t "{~a}\n" (trim-right " "))

(format t "{~a}\n" (trim-right "a "))

 

Output:

 

=={{header|Ursala}}==

 

white = ==` !| not @iNC %sI

#cast %sgUL

 

* The <code>white</code> 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 (<code>%s</code>) type.

* The <code>-~</code> 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.

=={{header|Vala}}==

===Strip Leading White Space===

===Strip Trailing White Space===

===Strip Leading & Trailing White Space===

 

=={{header|VBA}}==

'LTrim trims leading spaces

'RTrim trims tailing spaces

Debug.Print """" & WorksheetFunction.trim(s) & """"

'these functions do not remove tabs or newlines

<pre>" trim "

"trim "

 

=={{header|VBScript}}==

Function LeftTrim(s)

Set regex = New RegExp

WScript.StdOut.WriteLine RightTrim("RosettaCode ")

WScript.StdOut.WriteLine LeftTrim(RightTrim(" RosettaCode "))

 

{{Out}}

=={{header|Wren}}==

In Wren 'whitespace' is defined as: space, tab, carriage return, and line feed characters. To trim off other non-printing characters such as form feed and vertical tab, you need to do a little more work.

var b = "String with trailing whitespace removed \t\r\n"

var c = " \t\r\nString with both leading and trailing whitespace removed \t\r\n"

System.print("'%(b.trimEnd())'")

System.print("'%(c.trim())'")

 

{{out}}

'String with leading whitespace, form feed and vertical tab characters removed'

</pre>

 

=={{header|XPL0}}==

string 0; \use zero-terminated string convention

 

Text(0, StripTrail(String)); ChOut(0, ^!); CrLf(0);

Text(0, StripTrail(StripLead(String))); ChOut(0, ^!); CrLf(0);

 

Output:

 

=={{header|Yabasic}}==

 

print "--",ltrim$(s$),"--"

print "--",rtrim$(s$),"--"

 

=={{header|zkl}}==

Remove white space from both end of string:

try{ while(s[n].isSpace()){ n+=1 } }catch{""}fallthrough{ s[n,*] }

}

removeLeadingWS("\t\n hoho\n\t\ ") //-->"hoho\n\t "

try{ while(s[n].isSpace()){ n-=1 } s[0,n+1] }catch{""}

}

removeTrailingWS("\t\n hoho\n\t\ ") //-->"\t\n hoho"

 

=={{header|Zoea}}==

program: trim_left

input: ' abcd'

input: ' abcd '

output: 'abcd'