Len (programming)

String functions are used in computer programming languages to manipulate a string or query information about a string (some do both).

Most programming languages that have a string datatype will have some string functions although there may be other low-level ways within each language to handle strings directly. In object-oriented languages, string functions are often implemented as properties and methods of string objects. In functional and list-based languages a string is represented as a list (of character codes), therefore all list-manipulation procedures could be considered string functions. However such languages may implement a subset of explicit string-specific functions as well.

For function that manipulate strings, modern object-oriented languages, like C# and Java have immutable strings and return a copy (in newly allocated dynamic memory), while others, like C manipulate the original string unless the programmer copies data to a new string. See for example Concatenation below.

The most basic example of a string function is the length(string) function. This function returns the length of a string literal.

:e.g. length("hello world") would return 11.

Other languages may have string functions with similar or exactly the same syntax or parameters or outcomes. For example, in many languages the length function is usually represented as ''len(string)''. The below list of common functions aims to help limit this confusion.

Common string functions (multi language reference)

String functions common to many languages are listed below, including the different names used. The below list of common functions aims to help programmers find the equivalent function in a language. Note, string concatenation and regular expressions are handled in separate pages. Statements in guillemets (« … ») are optional.

CharAt

var
MyStr: string = 'Hello, World';
MyChar: Char;
begin
MyChar := MyStr // 'e'

# Example in ALGOL 68 #
"Hello, World"              // 'e'

// Example in C
#include // for printf
char MyStr[] = "Hello, World";
printf("%c", *(MyStr+1)); // 'e'
printf("%c", *(MyStr+7)); // 'W'
printf("%c", MyStr[11]); // 'd'
printf("%s", MyStr); // 'Hello, World'
printf("%s", "Hello(2), World(2)"); // 'Hello(2), World(2)'

// Example in C++
#include // for "cout"
#include // for "string" data type
using namespace std;
char MyStr1[] = "Hello(1), World(1)";
string MyStr2 = "Hello(2), World(2)";
cout << "Hello(3), World(3)"; // 'Hello(3), World(3)'
cout << MyStr2[6]; // '2'
cout << MyStr1.substr (5, 3); // '(1)'

// Example in C#
"Hello, World" // 'l'

# Example in Perl 5
substr("Hello, World", 1, 1); # 'e'

# Examples in Python
"Hello, World" # 'l'
"Hello, World" 3 # 'r'

# Example in Raku
"Hello, World".substr(1, 1); # 'e'

' Example in Visual Basic
Mid("Hello, World",2,1)

' Example in Visual Basic .NET
"Hello, World".Chars(2) ' "l"c

" Example in Smalltalk "
'Hello, World' at: 2. "$e"

//Example in Rust
"Hello, World".chars().nth(2); // Some('l')

Compare (integer result)

# Example in Perl 5
"hello" cmp "world"; # returns -1

# Example in Python
cmp("hello", "world") # returns -1

# Examples in Raku
"hello" cmp "world"; # returns Less
"world" cmp "hello"; # returns More
"hello" cmp "hello"; # returns Same

/** Example in Rexx */
compare("hello", "world") /* returns index of mismatch: 1 */

; Example in Scheme
(use-modules (srfi srfi-13))
; returns index of mismatch: 0
(string-compare "hello" "world" values values values)

Compare (relational operator-based, Boolean result)

% Example in Erlang
"hello" > "world". % returns false

# Example in Raku
"art" gt "painting"; # returns False
"art" lt "painting"; # returns True

# Example in Windows PowerShell
"hello" -gt "world" # returns false

;; Example in Common Lisp
(string> "art" "painting") ; returns nil
(string< "art" "painting") ; returns non nil

Concatenation

'abc' + 'def'; // returns "abcdef"

// Example in C#
"abc" + "def"; // returns "abcdef"

' Example in Visual Basic
"abc" & "def" ' returns "abcdef"
"abc" + "def" ' returns "abcdef"
"abc" & Null ' returns "abc"
"abc" + Null ' returns Null

// Example in D
"abc" ~ "def"; // returns "abcdef"

;; Example in common lisp
(concatenate 'string "abc " "def " "ghi") ; returns "abc def ghi"

# Example in Perl 5
"abc" . "def"; # returns "abcdef"
"Perl " . 5; # returns "Perl 5"

# Example in Raku
"abc" ~ "def"; # returns "abcdef"
"Perl " ~ 6; # returns "Perl 6"

Contains

¢ Example in ALGOL 68 ¢
string in string("e", loc int, "Hello mate"); ¢ returns true ¢
string in string("z", loc int, "word"); ¢ returns false ¢

// Example In C#
"Hello mate".Contains("e"); // returns true
"word".Contains("z"); // returns false

# Example in Python
"e" in "Hello mate" # returns true
"z" in "word" # returns false

# Example in Raku
"Good morning!".contains('z') # returns False
"¡Buenos días!".contains('í'); # returns True

" Example in Smalltalk "
'Hello mate' includesSubstring: 'e' " returns true "
'word' includesSubstring: 'z' " returns false "

Equality

Tests if two strings are equal. See also #Compare and #Compare. Note that doing equality checks via a generic Compare with integer result is not only confusing for the programmer but is often a significantly more expensive operation; this is especially true when using " C-strings".

// Example in C#
"hello"

"world" // returns false

' Example in Visual Basic
"hello" = "world" ' returns false

# Examples in Perl 5
'hello' eq 'world' # returns 0
'hello' eq 'hello' # returns 1

# Examples in Raku
'hello' eq 'world' # returns False
'hello' eq 'hello' # returns True

# Example in Windows PowerShell
"hello" -eq "world" # returns false

⍝ Example in APL
'hello' ≡ 'world' ⍝ returns 0

Find

; Examples in Common Lisp
(search "e" "Hello mate") ; returns 1
(search "z" "word") ; returns NIL

// Examples in C#
"Hello mate".IndexOf("e"); // returns 1
"Hello mate".IndexOf("e", 4); // returns 9
"word".IndexOf("z"); // returns -1

# Examples in Raku
"Hello, there!".index('e') # returns 1
"Hello, there!".index('z') # returns Nil

; Examples in Scheme
(use-modules (srfi srfi-13))
(string-contains "Hello mate" "e") ; returns 1
(string-contains "word" "z") ; returns #f

' Examples in Visual Basic
InStr("Hello mate", "e") ' returns 2
InStr(5, "Hello mate", "e") ' returns 10
InStr("word", "z") ' returns 0

" Examples in Smalltalk "
'Hello mate' indexOfSubCollection:'ate' "returns 8"
'Hello mate' indexOfSubCollection:'late' "returns 0"
I'Hello mate'
indexOfSubCollection:'late'
ifAbsent: 99 "returns 99"
'Hello mate'
indexOfSubCollection:'late'
ifAbsent: self error "raises an exception"

Find character

// Examples in C#
"Hello mate".IndexOf('e'); // returns 1
"word".IndexOf('z') // returns -1

; Examples in Common Lisp
(position #\e "Hello mate") ; returns 1
(position #\z "word") ; returns NIL

Given a set of characters, SCAN returns the position of the first character found, while VERIFY returns the position of the first character that does not belong to the set.

Format

// Example in C#
String.Format("My costs ", "pen", 19.99); // returns "My pen costs $19.99"

// Example in Object Pascal (Delphi)
Format('My %s costs $%2f', pen', 19.99; // returns "My pen costs $19.99"

// Example in Java
String.format("My %s costs $%2f", "pen", 19.99); // returns "My pen costs $19.99"

# Examples in Raku
sprintf "My %s costs \$%.2f", "pen", 19.99; # returns "My pen costs $19.99"
1.fmt("%04d"); # returns "0001"

# Example in Python
"My %s costs $%.2f" % ("pen", 19.99); # returns "My pen costs $19.99"
"My costs $".format("pen", 19.99); # returns "My pen costs $19.99"

#Example in Python 3.6+
pen = "pen"
f"My costs " #returns "My pen costs 19.99"

; Example in Scheme
(format "My ~a costs $~1,2F" "pen" 19.99) ; returns "My pen costs $19.99"

/* example in PL/I */
put string(some_string) edit('My ', 'pen', ' costs', 19.99)(a,a,a,p'$$$V.99')
/* returns "My pen costs $19.99" */

Inequality

Tests if two strings are not equal. See also #Equality.

// Example in C#
"hello" != "world" // returns true

' Example in Visual Basic
"hello" <> "world" ' returns true

;; Example in Clojure
(not= "hello" "world") ; ⇒ true

# Example in Perl 5
'hello' ne 'world' # returns 1

# Example in Raku
'hello' ne 'world' # returns True

# Example in Windows PowerShell
"hello" -ne "world" # returns true

index

''see'' #Find

indexof

''see'' #Find

instr

''see'' #Find

instrrev

''see'' #rfind

join

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, std.string.join(''array_of_strings'', ''separator'')
, D
, -
, string:join(''list_of_strings'', ''separator'')
, Erlang
, -
, join(''separator'', ''list_of_strings'')
, Perl, PHP, Raku
, -
, implode(''separator'', ''array_of_strings'')
, PHP
, -
, ''separator''.join(''sequence_of_strings'')
, Python, Swift 1.x
, -
, ''array_of_strings''.join(''separator'')
, Ruby, JavaScript, Raku, Rust
, -
, (string-join ''array_of_strings'' ''separator'')
, Scheme (SRFI 13)
, -
, (format nil "~{~a~^''separator''~}" ''array_of_strings'')
, Common Lisp
, -
, (clojure.string/join ''separator'' ''list_of_strings'')
(apply str (interpose ''separator'' ''list_of_strings''))
, Clojure
, -
, strings.Join(''array_of_strings'', ''separator'')
, Go
, -
, join(''array_of_strings'', ''separator'')
, Seed7
, -
, String.concat ''separator'' ''list_of_strings''
, OCaml
, -
, String.concatWith ''separator'' ''list_of_strings''
, Standard ML
, -
, Data.List.intercalate ''separator'' ''list_of_strings''
, Haskell (GHC 6.8+)
, -
, Join(''array_of_strings'', ''separator'')
, VB
, -
, String.Join(''separator'', ''array_of_strings'')
, VB .NET, C#, F#
, -
, String.join(''separator'', ''array_of_strings'')
, Java 8+
, -
, &{$OFS=''$separator''; "''$array_of_strings''"}, or
''array_of_strings'' -join ''separator''
, Windows PowerShell
, -
, 'array_of_strings'' componentsJoinedByString:''separator''/code>
, Objective-C (NSString * only)
, -
, table.concat(''table_of_strings'', ''separator'')
, Lua
, -
, {, String streamContents: ''collectionOfAnything'' asStringOn: stream delimiter: ''separator'' /nowiki>
''collectionOfAnything'' joinUsing: ''separator''
, Smalltalk ( Squeak, Pharo)
, -
, ''array_of_strings''.join(''separator''«, ''final_separator''»)
, Cobra
, -
, ''sequence_of_strings''.joinWithSeparator(''separator'')
, Swift 2.x
, -
, 1↓∊''separator'',¨''list_of_strings''
, APL


// Example in C#
String.Join("-", {"a", "b", "c"}) // "a-b-c"



" Example in Smalltalk "
#('a' 'b' 'c') joinUsing: '-' " 'a-b-c' "



# Example in Perl 5
join( '-', ('a', 'b', 'c')); # 'a-b-c'



# Example in Raku
.join('-'); # 'a-b-c'



# Example in Python
"-".join( a", "b", "c" # 'a-b-c'


# Example in Ruby
a", "b", "c"join("-") # 'a-b-c'



; Example in Scheme
(use-modules (srfi srfi-13))
(string-join '("a" "b" "c") "-") ; "a-b-c"


lastindexof

''see'' #rfind

left

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, left(''string'',''n'') returns string
, -
! Description
, Returns the left ''n'' part of a string. If ''n'' is greater than the length of the string then most implementations return the whole string (exceptions exist – see code examples). Note that for variable-length encodings such as UTF-8, UTF-16 or Shift-JIS, it can be necessary to remove string positions at the end, in order to avoid invalid strings.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, string (string'First .. string'First + ''n'' - 1)
, Ada
, -
, substr(''string'', 0, ''n'')
, AWK (changes string), Perl, PHP, Raku
, -
, LEFT$(''string'',''n'')
, BASIC, VB
, -
, left(''string'',''n'')
, , VB, FreeBASIC, Ingres, Pick Basic
, -
, strncpy(''string2'', ''string'', ''n'')
, C standard library
, -
, ''string''.substr(0,''n'')
, C++ (STL), Raku
, -
, 'string'' substringToIndex:''n''/code>
, Objective-C (NSString * only)
, -
, (apply str (take ''n'' ''string''))
, Clojure
, -
, ''string'' .. ''n''/code>
, D
, -
, string:substr(''string'', ''start'', ''length'')
, Erlang
, -
, (subseq ''string'' 0 ''n'')
, Common Lisp
, -
, ''string'' ''n''/code>
, Cobra, Go, Python
, -
, left(''string'',''n'' «,''padchar''»)
, Rexx, Erlang
, -
, ''string'', ''n''
''string'' ..''n'' - 1/code>
, Ruby
, -
, ''string'', ''n''/code>
, Pick Basic
, -
, ''string'' .. ''n''/code>
, Seed7
, -
, ''string''.Substring(0,''n'')
, VB .NET, C#, Windows PowerShell, F#
, -
, leftstr(''string'', ''n'')
, Pascal, Object Pascal (Delphi)
, -
, ''copy'' (''string'',1,''n'')
, Turbo Pascal
, -
, ''string''.substring(0,''n'')
, Java, JavaScript
, -
, (string-take ''string'' ''n'')
, Scheme (SRFI 13)
, -
, take ''n'' ''string''
, Haskell
, -
, String.extract (''string'', ''n'', NONE)
, Standard ML
, -
, String.sub ''string'' 0 ''n''
, OCamlif n is larger than length of string, raises Invalid_argument
, -
, ''string''. .''n''/code>
, F#
, -
, string.sub(''string'', 1, ''n'')
(''string''):sub(1, ''n'')
, Lua
, -
, ''string'' first: ''n''
, Smalltalk ( Squeak, Pharo)
, -
, ''string''(:''n'')
, Fortran
, -
, StringTake 'string'', ''n''/code>
, Mathematicaif n is larger than length of string, throw the message "StringTake::take:"
, -
, ''string'' («FUNCTION» LENGTH(''string'') - ''n'':''n'')
, COBOL
, -
, ''string''.substring(0, ''n'')
, Cobra
, -
, ''n''↑''string''.
, APL
, -
, ''string'' ..n/code>
''string'' .n/code>
''string''.get(0..n)
''string''.get(..n)
, RustIn Rust, strings are indexed in terms of byte offsets and there is a runtime panic if the index is out of bounds or if it would result in invalid UTF-8. A &str (string reference) can b
indexed
by various types of ranges, includin

(0..n)

(n..), an

(..n) because they all implement th

trait with str being the type being indexed.

Th

method is the non-panicking way to index. It returns None in the cases in which indexing would panic.


# Example in Raku
"Hello, there!".substr(0, 6); # returns "Hello,"



/* Examples in Rexx */
left("abcde", 3) /* returns "abc" */
left("abcde", 8) /* returns "abcde " */
left("abcde", 8, "*") /* returns "abcde***" */



; Examples in Scheme
(use-modules (srfi srfi-13))
(string-take "abcde", 3) ; returns "abc"
(string-take "abcde", 8) ; error



' Examples in Visual Basic
Left("sandroguidi", 3) ' returns "san"
Left("sandroguidi", 100) ' returns "sandroguidi"


len

''see'' #length

length

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, length(''string'') returns an integer number
, -
! Description
, Returns the length of a string (not counting the null terminator or any other of the string's internal structural information). An empty string returns a length of 0.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Returns !! Languages
, -
, string'Length
,
, Ada
, -
, UPB string
,
, ALGOL 68
, -
, length(''string'')
,
, Ingres, Perl 5, Pascal, Object Pascal (Delphi), Rexx, Seed7, SQL, PL/I
, -
, len(''string'')
,
, BASIC, FreeBASIC, Python, Go, Pick Basic
, -
, length(''string''), string:len(''string'')
,
, Erlang
, -
, Len(''string'')
,
, VB, Pick Basic
, -
, ''string''.Length
, Number of UTF-16 code units
, VB .NET, C#, Windows PowerShell, F#
, -
, chars(''string'')
''string''.chars
, Number of graphemes (NFG)
, Raku
, -
, codes(''string'')
''string''.codes
, Number of Unicode code points
, Raku
, -
, ''string''.size OR ''string''.length
, Number of bytes
, Ruby
, -
, strlen(''string'')
, Number of bytes
, C, PHP
, -
, ''string''.length()
,
, C++ (STL)
, -
, ''string''.length
,
, Cobra, D, JavaScript
, -
, ''string''.length()
, Number of UTF-16 code units
, Java
, -
, (string-length ''string'')
,
, Scheme
, -
, (length ''string'')
,
, Common Lisp, ISLISP
, -
, (count ''string'')
,
, Clojure
, -
, String.length ''string''
,
, OCaml
, -
, size ''string''
,
, Standard ML
, -
, length ''string''
, Number of Unicode code points
, Haskell
, -
, ''string''.length
, Number of UTF-16 code units
, Objective-C (NSString * only)
, -
, ''string''.characters.count
, Number of characters
, Swift (2.x)
, -
, count(''string'')
, Number of characters
, Swift (1.2)
, -
, countElements(''string'')
, Number of characters
, Swift (1.0–1.1)
, -
, string.len(''string'')
(''string''):len()
#''string''
,
, Lua
, -
, ''string'' size
,
, Smalltalk
, -
, LEN(''string''), or LEN_TRIM(''string'')
,
, Fortran
, -
, StringLength 'string''/code>
,
, Mathematica
, -
, «FUNCTION» LENGTH(''string'') or
«FUNCTION» BYTE-LENGTH(''string'')
, number of characters and number of bytes, respectively
, COBOL
, -
, string length ''string''
, a decimal string giving the number of characters
, Tcl
, -
, ≢ ''string''
,
, APL
, -
, ''string''.len()
, Number of bytes
, Rust
, -
, ''string''.chars().count()
, Number of Unicode code points
, Rust


// Examples in C#
"hello".Length; // returns 5
"".Length; // returns 0



# Examples in Erlang
string:len("hello"). % returns 5
string:len(""). % returns 0



# Examples in Perl 5
length("hello"); # returns 5
length(""); # returns 0



# Examples in Raku
"🏳️‍🌈".chars; chars "🏳️‍🌈"; # both return 1
"🏳️‍🌈".codes; codes "🏳️‍🌈"; # both return 4
"".chars; chars ""; # both return 0
"".codes; codes ""; # both return 0



' Examples in Visual Basic
Len("hello") ' returns 5
Len("") ' returns 0



//Examples in Objective-C
"hello" Length //returns 5
"" Length //returns 0



-- Examples in Lua
("hello"):len() -- returns 5
#"" -- returns 0


locate

''see'' #Find

Lowercase

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, lowercase(''string'') returns string
, -
! Description
, Returns the string in lower case.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, LCase(''string'')
, VB
, -
, lcase(''string'')
, FreeBASIC
, -
, lc(''string'')
, Perl, Raku
, -
, ''string''.lc
, Raku
, -
, tolower(''char'')
, C
, -
, std.string.toLower(''string'')
, D
, -
, transform(''string''.begin(), ''string''.end(), ''result''.begin(), ::tolower)The transform function exists in the std:: namespace. You must include the header file to use it. The tolower and toupper functions are in the global namespace, obtained by the header file. The std::tolower and std::toupper names are overloaded and cannot be passed to std::transform without a cast to resolve a function overloading ambiguity, e.g. std::transform(''string''.begin(), ''string''.end(), ''result''.begin(), (int (*)(int))std::tolower);
, C++
, -
, lowercase(''string'')
, Object Pascal (Delphi)
, -
, strtolower(''string'')
, PHP
, -
, lower(''string'')
, Seed7
, -
, ${''string_param'',,}
, Bash
, -
, echo "string" , tr 'A-Z' 'a-z'
, Unix
, -
, ''string''.lower()
, Python
, -
, downcase(''string'')
, Pick Basic
, -
, ''string''.downcase
, Rubyonly ASCII characters as Ruby lacks Unicode support
, -
, strings.ToLower(''string'')
, Go
, -
, (string-downcase ''string'')
, Scheme (R6RS), Common Lisp
, -
, (lower-case ''string'')
, Clojure
, -
, String.lowercase ''string''
, OCaml
, -
, String.map Char.toLower ''string''
, Standard ML
, -
, map Char.toLower ''string''
, Haskell
, -
, ''string''.toLowerCase()
, Java, JavaScript
, -
, to_lower(''string'')
, Erlang
, -
, ''string''.ToLower()
, VB .NET, C#, Windows PowerShell, F#
, -
, ''string''.lowercaseString
, Objective-C (NSString * only), Swift (Foundation)
, -
, string.lower(''string'')
(''string''):lower()
, Lua
, -
, ''string'' asLowercase
, Smalltalk
, -
, LOWER(''string'')
, SQL
, -
, lowercase(''string'')
, PL/I
, -
, ToLowerCase 'string''/code>
, Mathematica
, -
, «FUNCTION» LOWER-CASE(''string'')
, COBOL
, -
, ''string''.toLower
, Cobra
, -
, string tolower ''string''
, Tcl
, -
, ''string''.to_lowercase()
, Rust


// Example in C#
"Wiki means fast?".ToLower(); // "wiki means fast?"



; Example in Scheme
(use-modules (srfi srfi-13))
(string-downcase "Wiki means fast?") ; "wiki means fast?"



/* Example in C */
#include
#include
int main(void) {
char string[] = "Wiki means fast?";
int i;
for (i = 0; i < sizeof(string) - 1; ++i) {
/* transform characters in place, one by one */
string = tolower(string ;
}
puts(string); /* "wiki means fast?" */
return 0;
}



# Example in Raku
"Wiki means fast?".lc; # "wiki means fast?"


mid

''see'' #substring

partition

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, .partition(''separator'') returns the sub-string before the separator; the separator; then the sub-string after the separator.
, -
! Description
, Splits the given string by the separator and returns the three substrings that together make the original.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages !! Comments
, -
, ''string''.partition(''separator'')
, Python, Ruby(1.9+)
,
, -
, lists:partition(''pred'', ''string'')
, Erlang
,
, -
, split /(''separator'')/, ''string'', 2
, Perl 5
,
, -
, split ''separator'', ''string'', 2
''string''.split( ''separator'', 2 )
, Raku
, Separator does not have to be a regular expression

# Examples in Python
"Spam eggs spam spam and ham".partition('spam') # ('Spam eggs ', 'spam', ' spam and ham')
"Spam eggs spam spam and ham".partition('X') # ('Spam eggs spam spam and ham', "", "")

# Examples in Perl 5 / Raku
split /(spam)/, 'Spam eggs spam spam and ham' ,2; # ('Spam eggs ', 'spam', ' spam and ham');
split /(X)/, 'Spam eggs spam spam and ham' ,2; # ('Spam eggs spam spam and ham');

replace

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, replace(''string'', ''find'', ''replace'') returns string
, -
! Description
, Returns a string with ''find'' occurrences changed to ''replace''.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, changestr(''find'', ''string'', ''replace'')
, Rexx
, -
, std.string.replace(''string'', ''find'', ''replace'')
, D
, -
, Replace(''string'', ''find'', ''replace'')
, VB
, -
, replace(''string'', ''find'', ''replace'')
, Seed7
, -
, change(''string'', ''find'', ''replace'')
, Pick Basic
, -
, ''string''.Replace(''find'', ''replace'')
, C#, F#, VB .NET
, -
, str_replace(''find'', ''replace'', ''string'')
, PHP
, -
, re:replace(''string'', ''find'', ''replace'', «{return, list}»)
, Erlang
, -
, ''string''.replace(''find'', ''replace'')
, Cobra, Java (1.5+), Python, Rust
, -
, ''string''.replaceAll(''find_regex'', ''replace'')
, Java
, -
, ''string''.gsub(''find'', ''replace'')
, Ruby
, -
, ''string'' =~ s/''find_regex''/''replace''/gThe "find" string in this construct is interpreted as a regular expression. Certain characters have special meaning in regular expressions. If you want to find a string literally, you need to quote the special characters.
, Perl 5
, -
, ''string''.subst(''find'', ''replace'', :g)
, Raku
, -
, ''string''.replace(''find'', ''replace'', "g") or
''string''.replace(/''find_regex''/g, ''replace'')
, JavaScript
, -
, echo "''string''" , sed 's/''find_regex''/''replace''/g'
, Unix
, -
, ${''string_param''//''find_pattern''/''replace''}
, Bash
, -
, ''string''.replace(''find'', ''replace''), or
''string'' -replace ''find_regex'', ''replace''
, Windows PowerShell
, -
, Str.global_replace (Str.regexp_string ''find'') ''replace'' ''string''
, OCaml
, -
, 'string'' stringByReplacingOccurrencesOfString:''find'' withString:''replace''/code>
, Objective-C (NSString * only)
, -
, ''string''.stringByReplacingOccurrencesOfString(''find'', withString:''replace'')
, Swift (Foundation)
, -
, string.gsub(''string'', ''find'', ''replace'')
(''string''):gsub(''find'', ''replace'')
, Lua
, -
, ''string'' copyReplaceAll: ''find'' with: ''replace''
, Smalltalk ( Squeak, Pharo)
, -
, string map {''find'' ''replace''} ''string''
, Tcl
, -
, StringReplace 'string'', ''find'' -> ''replace''/code>
, Mathematica
, -
, strings.Replace(''string'', ''find'', ''replace'', -1)
, Go
, -
, INSPECT ''string'' REPLACING ALL/LEADING/FIRST ''find'' BY ''replace''
, COBOL
, -
, ''find_regex'' ⎕R ''replace_regex'' ⊢ ''string''
, APL


// Examples in C#
"effffff".Replace("f", "jump"); // returns "ejumpjumpjumpjumpjumpjump"
"blah".Replace("z", "y"); // returns "blah"



// Examples in Java
"effffff".replace("f", "jump"); // returns "ejumpjumpjumpjumpjumpjump"
"effffff".replaceAll("f*", "jump"); // returns "ejump"



// Examples in Raku
"effffff".subst("f", "jump", :g); # returns "ejumpjumpjumpjumpjumpjump"
"blah".subst("z", "y", :g); # returns "blah"



' Examples in Visual Basic
Replace("effffff", "f", "jump") ' returns "ejumpjumpjumpjumpjumpjump"
Replace("blah", "z", "y") ' returns "blah"



# Examples in Windows PowerShell
"effffff" -replace "f", "jump" # returns "ejumpjumpjumpjumpjumpjump"
"effffff" -replace "f*", "jump" # returns "ejump"


reverse

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, reverse(''string'')
, -
! Description
, Reverses the order of the characters in the string.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, reverse ''string''
, Perl 5, Haskell
, -
, flip ''string''
''string''.flip
, Raku
, -
, lists:reverse(''string'')
, Erlang
, -
, strrev(''string'')
, PHP
, -
, ''string'' :-1/code>
, Python
, -
, (string-reverse ''string'')
, Scheme (SRFI 13)
, -
, (reverse ''string'')
, Common Lisp
, -
, ''string''.reverse
, Ruby, D (modifies string)
, -
, new StringBuilder(''string'').reverse().toString()
, Java
, -
, std::reverse(''string''.begin(), ''string''.end());
, C++ ( std::string only, modifies string)
, -
, StrReverse(''string'')
, VB
, -
, ''string''.Reverse()
, VB .NET, C#
, -
, implode (rev (explode ''string''))
, Standard ML
, -
, ''string''.split("").reverse().join("")
, JavaScript
, -
, string.reverse(''string'')
(''string''):reverse()
, Lua
, -
, ''string'' reverse
, Smalltalk
, -
, StringReverse 'string''/code>
, Mathematica
, -
, reverse(''string'')
, PL/I
, -
, «FUNCTION» REVERSE(''string'')
, COBOL
, -
, ''string''.toCharArray.toList.reversed.join()
, Cobra
, -
, String(''string''.characters.reverse())
, Swift (2.x)
, -
, String(reverse(''string''))
, Swift (1.2)
, -
, string reverse ''string''
, Tcl
, -
, ⌽''string''
, APL
, -
, ''string''.chars().rev().collect::()
, Rust
, -
, echo ''string'' , rev
, Unix


" Example in Smalltalk "
'hello' reversed " returns 'olleh' "



# Example in Perl 5
reverse "hello" # returns "olleh"



# Example in Raku
"hello".flip # returns "olleh"



# Example in Python
"hello" :-1 # returns "olleh"



; Example in Scheme
(use-modules (srfi srfi-13))
(string-reverse "hello") ; returns "olleh"


rfind

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, rfind(''string'',''substring'') returns integer
, -
! Description
, Returns the position of the start of the last occurrence of ''substring'' in ''string''. If the ''substring'' is not found most of these routines return an invalid index value – -1 where indexes are 0-based, 0 where they are 1-based – or some value to be interpreted as Boolean FALSE.
, -
, Related
, instr

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages !! If not found
, -
, InStrRev(«''startpos'',» ''string'',''substring'')
, VB
, returns 0
, -
, instrrev(«''startpos'',» ''string'',''substring'')
, FreeBASIC
, returns 0
, -
, rindex(''string'',''substring''«,''startpos''»)
, Perl 5
, returns −1
, -
, rindex(''string'',''substring''«,''startpos''»)
''string''.rindex(''substring''«,''startpos''»)
, Raku
, returns Nil
, -
, strrpos(''string'',''substring''«,''startpos''»)
, PHP
, returns FALSE
, -
, ''string''.rfind(''substring''«,''startpos''»)
, C++ (STL)
, returns std::string::npos
, -
, std.string.rfind(''string'', ''substring'')
, D
, returns −1
, -
, ''string''.rfind(''substring''«,''startpos''«, ''endpos''»»)
, rowspan=2, Python
, returns −1
, -
, ''string''.rindex(''substring''«,''startpos''«, ''endpos''»»)
, raises ValueError
, -
, rpos(''string'', ''substring''«,''startpos''»)
, Seed7
, returns 0
, -
, ''string''.rindex(''substring''«,''startpos''»)
, Ruby
, returns nil
, -
, strings.LastIndex(''string'', ''substring'')
, Go
, returns −1
, -
, ''string''.lastIndexOf(''substring''«,''startpos''»)
, Java, JavaScript
, returns −1
, -
, ''string''.LastIndexOf(''substring''«,''startpos''«, ''charcount''»»)
, VB .NET, C#, Windows PowerShell, F#
, returns −1
, -
, (search ''substring'' ''string'' :from-end t)
, Common Lisp
, returns NIL
, -
, 'string'' rangeOfString:''substring'' options:NSBackwardsSearchlocation
, Objective-C (NSString * only)
, returns NSNotFound
, -
, Str.search_backward (Str.regexp_string ''substring'') ''string'' (Str.length ''string'' - 1)
, OCaml
, raises Not_found
, -
, string.match(''string'', '.*()'..''substring'')
''string'':match('.*()'..''substring'')
, Lua
, returns nil
, -
, Ada.Strings.Unbounded.Index(Source => ''string'', Pattern => ''substring'',
Going => Ada.Strings.Backward)
, Ada
, returns 0
, -
, ''string''.lastIndexOf(''substring''«,''startpos''«, ''charcount''»»)
, Cobra
, returns −1
, -
, ''string'' lastIndexOfString:''substring''
, Smalltalk
, returns 0
, -
, string last ''substring string startpos''
, Tcl
, returns −1
, -
, (⌽<\⌽''substring''⍷'string')⍳1
, APL
, returns −1
, -
, ''string''.rfind(''substring'')
, Rust
, returns None


; Examples in Common Lisp
(search "e" "Hello mate" :from-end t) ; returns 9
(search "z" "word" :from-end t) ; returns NIL



// Examples in C#
"Hello mate".LastIndexOf("e"); // returns 9
"Hello mate".LastIndexOf("e", 4); // returns 1
"word".LastIndexOf("z"); // returns -1



# Examples in Perl 5
rindex("Hello mate", "e"); # returns 9
rindex("Hello mate", "e", 4); # returns 1
rindex("word", "z"); # returns -1



# Examples in Raku
"Hello mate".rindex("e"); # returns 9
"Hello mate".rindex("e", 4); # returns 1
"word".rindex('z'); # returns Nil



' Examples in Visual Basic
InStrRev("Hello mate", "e") ' returns 10
InStrRev(5, "Hello mate", "e") ' returns 2
InStrRev("word", "z") ' returns 0


right

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, right(''string'',''n'') returns string
, -
! Description
, Returns the right ''n'' part of a string. If ''n'' is greater than the length of the string then most implementations return the whole string (exceptions exist – see code examples).

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, string (string'Last - ''n'' + 1 .. string'Last)
, Ada
, -
, Right(''string'',''n'')
, VB
, -
, RIGHT$(''string'',''n'')
, BASIC
, -
, right(''string'',''n'')
, FreeBASIC, Ingres, Pick Basic
, -
, strcpy(''string2'', ''string''+''n'') (n must not be greater than the length of ''string'')
, C
, -
, ''string''.Substring(''string''.Length()-''n'')
, C#
, -
, ''string'' en(''string'')-''n'':/code>
, Go
, -
, ''string''.substring(''string''.length()-''n'')
, Java
, -
, ''string''.slice(-''n'')
, JavaScript
, -
, right(''string'',''n'' «,''padchar''»)
, Rexx, Erlang
, -
, substr(''string'',-''n'')
, Perl 5, PHP
, -
, substr(''string'',*-''n'')
''string''.substr(*-''n'')
, Raku
, -
, ''string'' ''n'':/code>
, Cobra, Python
, -
, ${''string_param'': -''n''} (note the space after the colon)
, Bash
, -
, ''string'' 'n''/code>
, Pick Basic
, -
, (string-take-right ''string'' ''n'')
, Scheme (SRFI 13)
, -
, ''string'' ''n''..-1/code>
, Ruby
, -
, ''string'' -''n'' .. $/code>
, D
, -
, String.sub ''string'' (String.length ''string'' - ''n'') ''n''
, OCaml
, -
, string.sub(''string'', -''n'')
(''string''):sub(-''n'')
, Lua
, -
, ''string'' last: ''n''
, Smalltalk ( Squeak, Pharo)
, -
, StringTake 'string'', -''n''/code>
, Mathematica
, -
, ''string'' (1:''n'')
, COBOL
, -
, ''¯n''↑''string''.
, APL
, -
, ''string'' ../code>
''string''.get(n..)
, Rust


// Examples in Java; extract rightmost 4 characters
String str = "CarDoor";
str.substring(str.length()-4); // returns 'Door'



# Examples in Raku
"abcde".substr(*-3); # returns "cde"
"abcde".substr(*-8); # 'out of range' error



/* Examples in Rexx */
right("abcde", 3) /* returns "cde" */
right("abcde", 8) /* returns " abcde" */
right("abcde", 8, "*") /* returns "***abcde" */



; Examples in Scheme
(use-modules (srfi srfi-13))
(string-take-right "abcde", 3) ; returns "cde"
(string-take-right "abcde", 8) ; error



' Examples in Visual Basic
Right("sandroguidi", 3) ' returns "idi"
Right("sandroguidi", 100) ' returns "sandroguidi"


rpartition

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, .rpartition(''separator'') Searches for the separator from right-to-left within the string then returns the sub-string before the separator; the separator; then the sub-string after the separator.
, -
! Description
, Splits the given string by the right-most separator and returns the three substrings that together make the original.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, ''string''.rpartition(''separator'')
, Python, Ruby

# Examples in Python
"Spam eggs spam spam and ham".rpartition('spam') ### ('Spam eggs spam ', 'spam', ' and ham')
"Spam eggs spam spam and ham".rpartition('X') ### ("", "", 'Spam eggs spam spam and ham')

slice

''see'' #substring

split

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, .split(''separator'' ''limit'' splits a string on separator, optionally only up to a limited number of substrings
, -
! Description
, Splits the given string by occurrences of the separator (itself a string) and returns a list (or array) of the substrings. If ''limit'' is given, after ''limit'' – 1 separators have been read, the rest of the string is made into the last substring, regardless of whether it has any separators in it. The Scheme and Erlang implementations are similar but differ in several ways. JavaScript differs also in that it cuts, it does not put the rest of the string into the last element
See the example here
The Cobra implementation will default to whitespace. Opposite of ''join''.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, split(/''separator''/, ''string''«, ''limit''»)
, Perl 5
, -
, split(''separator'', ''string''«, ''limit''»)
''string''.split(''separator'', «''limit''»)
, Raku
, -
, explode(''separator'', ''string''«, ''limit''»)
, PHP
, -
, ''string''.split(''separator''«, ''limit''-1»)
, Python
, -
, ''string''.split(''separator''«, ''limit''»)
, JavaScript, Java, Ruby
, -
, string:tokens(''string'', ''sepchars'')
, Erlang
, -
, strings.Split(''string'', ''separator'')
strings.SplitN(''string'', ''separator'', ''limit'')
, Go
, -
, (string-tokenize ''string''« ''charset''« ''start''« ''end''»»»)
, Scheme (SRFI 13)
, -
, Split(''string'', ''sepchars''«, ''limit''»)
, VB
, -
, ''string''.Split(''sepchars''«, ''limit''«, ''options''»»)
, VB .NET, C#, F#
, -
, ''string'' -split ''separator''«, ''limit''«, ''options''»»
, Windows PowerShell
, -
, Str.split (Str.regexp_string ''separator'') ''string''
, OCaml
, -
, std.string.split(''string'', ''separator'')
, D
, -
, 'string'' componentsSeparatedByString:''separator''/code>
, Objective-C (NSString * only)
, -
, ''string''.componentsSeparatedByString(''separator'')
, Swift (Foundation)
, -
, TStringList.Delimiter, TStringList.DelimitedText
, Object Pascal
, -
, StringSplit 'string'', ''separator''«, ''limit''»/code>
, Mathematica
, -
, ''string''.split«(''sepchars''«, ''limit''«, ''options''»»)»
, Cobra
, -
, split ''string separator''
, Tcl
, -
, (''separator''≠''string'')⊂''string'' or ''separator''(≠⊆⊢)''string'' in APL2 and Dyalog APL 16.0 respectively
, APL
, -
, ''string''.split(''separator'')
''string''.split(''limit'', ''separator'')
, Rust


// Example in C#
"abc,defgh,ijk".Split(','); // {"abc", "defgh", "ijk"}
"abc,defgh;ijk".Split(',', ';'); // {"abc", "defgh", "ijk"}



% Example in Erlang
string:tokens("abc;defgh;ijk", ";"). % abc", "defgh", "ijk"


// Examples in Java
"abc,defgh,ijk".split(","); // {"abc", "defgh", "ijk"}
"abc,defgh;ijk".split(",, ;"); // {"abc", "defgh", "ijk"}



{ Example in Pascal }
var
lStrings: TStringList;
lStr: string;
begin
lStrings := TStringList.Create;
lStrings.Delimiter := ',';
lStrings.DelimitedText := 'abc,defgh,ijk';
lStr := lStrings.Strings // 'abc'
lStr := lStrings.Strings // 'defgh'
lStr := lStrings.Strings // 'ijk'
end;



# Examples in Perl 5
split(/spam/, 'Spam eggs spam spam and ham'); # ('Spam eggs ', ' ', ' and ham')
split(/X/, 'Spam eggs spam spam and ham'); # ('Spam eggs spam spam and ham')



# Examples in Raku
'Spam eggs spam spam and ham'.split(/spam/); # (Spam eggs and ham)
split(/X/, 'Spam eggs spam spam and ham'); # (Spam eggs spam spam and ham)


sprintf

''see'' #Format

strip

''see'' #trim

strcmp

''see'' #Compare (integer result)

substring

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, substring(''string'', ''startpos'', ''endpos'') returns string
substr(''string'', ''startpos'', ''numChars'') returns string
, -
! Description
, Returns a substring of ''string'' between starting at ''startpos'' and ''endpos'', or starting at ''startpos'' of length ''numChars''. The resulting string is truncated if there are fewer than ''numChars'' characters beyond the starting point. ''endpos'' represents the index after the last character in the substring. Note that for variable-length encodings such as UTF-8, UTF-16 or Shift-JIS, it can be necessary to remove string positions at the end, in order to avoid invalid strings.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, string 'startpos'':''endpos''/code>
, ALGOL 68 (changes base index)
, -
, string (''startpos'' .. ''endpos'')
, Ada (changes base index)
, -
, Mid(''string'', ''startpos'', ''numChars'')
, VB
, -
, mid(''string'', ''startpos'', ''numChars'')
, FreeBASIC
, -
, ''string'' 'startpos''+(⍳''numChars'')-~⎕IO/code>
, APL
, -
, MID$(''string'', ''startpos'', ''numChars'')
, BASIC
, -
, substr(''string'', ''startpos'', ''numChars'')
, AWK (changes string), Perl 5, PHP
, -
, substr(''string'', ''startpos'', ''numChars'')
''string''.substr(''startpos'', ''numChars'')
, Raku
, -
, substr(''string'', ''startpos'' «,''numChars'', ''padChar''»)
, Rexx
, -
, ''string'' 'startpos'':''endpos''/code>
, Cobra, Python, Go
, -
, ''string'' 'startpos'', ''numChars''/code>
, Pick Basic
, -
, ''string'' 'startpos'', ''numChars''
''string'' 'startpos'' .. ''endpos''-1
''string'' 'startpos'' ... ''endpos''/code>
, Ruby
, -
, ''string'' 'startpos'' .. ''endpos''
''string'' 'startpos'' len ''numChars''/code>
, Seed7
, -
, ''string''.slice(''startpos''«, ''endpos''»)
, JavaScript
, -
, ''string''.substr(''startpos''«, ''numChars''»)
, C++ (STL), JavaScript
, -
, ''string''.Substring(''startpos'', ''numChars'')
, VB .NET, C#, Windows PowerShell, F#
, -
, ''string''.substring(''startpos''«, ''endpos''»)
, Java, JavaScript
, -
, copy(''string'', ''startpos'', ''numChars'')
, Object Pascal (Delphi)
, -
, (substring ''string'' ''startpos'' ''endpos'')
, Scheme
, -
, (subseq ''string'' ''startpos'' ''endpos'')
, Common Lisp
, -
, (subseq ''string'' ''startpos'' ''endpos'')
, ISLISP
, -
, String.sub ''string'' ''startpos'' ''numChars''
, OCaml
, -
, substring (''string'', ''startpos'', ''numChars'')
, Standard ML
, -
, string:sub_string(''string'', ''startpos'', ''endpos'')
string:substr(''string'', ''startpos'', ''numChars'')
, Erlang
, -
, strncpy(''result'', ''string'' + ''startpos'', ''numChars'');
, C
, -
, ''string'' 'startpos'' .. ''endpos''+1/code>
, D
, -
, take ''numChars'' $ drop ''startpos'' ''string''
, Haskell
, -
, 'string'' substringWithRange:NSMakeRange(''startpos'', ''numChars'')/code>
, Objective-C (NSString * only)
, -
, ''string''. 'startpos''..''endpos''/code>
, F#
, -
, string.sub(''string'', ''startpos'', ''endpos'')
(''string''):sub(''startpos'', ''endpos'')
, Lua
, -
, ''string'' copyFrom: ''startpos'' to: ''endpos''
, Smalltalk
, -
, ''string''(''startpos'':''endpos'')
, Fortran
, -
, SUBSTRING(''string'' FROM ''startpos'' «FOR ''numChars''»)
, SQL
, -
, StringTake 'string'', {''startpos'', ''endpos''}/code>
, Mathematica
, -
, ''string'' (''startpos'':''numChars'')
, COBOL
, -
, ${''string_param'':''startpos'':''numChars''}
, Bash
, -
, string range ''string startpos endpos''
, Tcl
, -
, ''string'' 'startpos''..''endpos''/code>
''string''.get(''startpos''..''endpos'')
, Rust


// Examples in C#
"abc".Substring(1, 1): // returns "b"
"abc".Substring(1, 2); // returns "bc"
"abc".Substring(1, 6); // error



;; Examples in Common Lisp
(subseq "abc" 1 2) ; returns "b"
(subseq "abc" 2) ; returns "c"



% Examples in Erlang
string:substr("abc", 2, 1). % returns "b"
string:substr("abc", 2). % returns "bc"



# Examples in Perl 5
substr("abc", 1, 1); # returns "b"
substr("abc", 1); # returns "bc"



# Examples in Raku
"abc".substr(1, 1); # returns "b"
"abc".substr(1); # returns "bc"



# Examples in Python
"abc" :2 # returns "b"
"abc" :3 # returns "bc"



/* Examples in Rexx */
substr("abc", 2, 1) /* returns "b" */
substr("abc", 2) /* returns "bc" */
substr("abc", 2, 6) /* returns "bc " */
substr("abc", 2, 6, "*") /* returns "bc****" */


Uppercase

{, class="wikitable"
, - style="background:#fffeed;"
! Definition
, uppercase(''string'') returns string
, -
! Description
, Returns the string in upper case.

{, class="wikitable sortable"
, - style="text-align:left;"
! Format !! Languages
, -
, UCase(''string'')
, VB
, -
, ucase(''string'')
, FreeBASIC
, -
, toupper(''string'')
, AWK (changes string)
, -
, uc(''string'')
, Perl, Raku
, -
, ''string''.uc
, Raku
, -
, toupper(''char'')
, C (operates on one character)
, -
, for(size_t i = 0, len = strlen(''string''); i< len; i++) ''string'' = toupper(''string'' ;
for (char *c = ''string''; *c != '\0'; c++) *c = toupper(*c);
, C (string / char array)
, -
, std.string.toUpper(''string'')
, D
, -
, transform(''string''.begin(), ''string''.end(), ''result''.begin(), toupper)
, C++
, -
, uppercase(''string'')
, Object Pascal (Delphi)
, -
, upcase(''char'')
, Object Pascal (Delphi) (operates on one character)
, -
, strtoupper(''string'')
, PHP
, -
, upper(''string'')
, Seed7
, -
, ${''string_param''^^} (mnemonic: ^ is pointing up)
, Bash
, -
, echo "string" , tr 'a-z' 'A-Z'
, Unix
, -
, translate(''string''), or

UPPER variables, or

PARSE UPPER VAR SrcVar DstVar
, Rexx
, -
, ''string''.upper()
, Python
, -
, upcase(''string'')
, Pick Basic
, -
, ''string''.upcase
, Ruby
, -
, strings.ToUpper(''string'')
, Go
, -
, (string-upcase ''string'')
, Scheme, Common Lisp
, -
, String.uppercase ''string''
, OCaml
, -
, String.map Char.toUpper ''string''
, Standard ML
, -
, map Char.toUpper ''string''
, Haskell
, -
, ''string''.toUpperCase()
, Java, JavaScript
, -
, to_upper(''string'')
, Erlang
, -
, ''string''.ToUpper()
, VB .NET, C#, Windows PowerShell, F#
, -
, ''string''.uppercaseString
, Objective-C (NSString * only), Swift (Foundation)
, -
, string.upper(''string'')
(''string''):upper()
, Lua
, -
, ''string'' asUppercase
, Smalltalk
, -
, UPPER(''string'')
, SQL
, -
, ToUpperCase 'string''/code>
, Mathematica
, -
, «FUNCTION» UPPER-CASE(''string'')
, COBOL
, -
, ''string''.toUpper
, Cobra
, -
, string toupper ''string''
, Tcl
, -
, ''string''.to_uppercase()
, Rust


// Example in C#
"Wiki means fast?".ToUpper(); // "WIKI MEANS FAST?"



# Example in Perl 5
uc("Wiki means fast?"); # "WIKI MEANS FAST?"



# Example in Raku
uc("Wiki means fast?"); # "WIKI MEANS FAST?"
"Wiki means fast?".uc; # "WIKI MEANS FAST?"



/* Example in Rexx */
translate("Wiki means fast?") /* "WIKI MEANS FAST?" */

/* Example #2 */
A='This is an example.'
UPPER A /* "THIS IS AN EXAMPLE." */

/* Example #3 */
A='upper using Translate Function.'
Translate UPPER VAR A Z /* Z="UPPER USING TRANSLATE FUNCTION." */



; Example in Scheme
(use-modules (srfi srfi-13))
(string-upcase "Wiki means fast?") ; "WIKI MEANS FAST?"



' Example in Visual Basic
UCase("Wiki means fast?") ' "WIKI MEANS FAST?"




trim

trim or strip is used to remove whitespace from the beginning, end, or both beginning and end, of a string.

{, class="wikitable"
, - style="text-align:left;"
! Example usage !! Languages
, -
, ''String''.Trim( 'chars''
, C#, VB.NET, Windows PowerShell
, -
, ''string''.strip();
, D
, -
, (.trim ''string'')
, Clojure
, -
, ''sequence'' predicate? trim
, Factor
, -
, (string-trim '(#\Space #\Tab #\Newline) ''string'')
, Common Lisp
, -
, (string-trim ''string'')
, Scheme
, -
, ''string''.trim()
, Java, JavaScript (1.8.1+, Firefox 3.5+), Rust
, -
, Trim(''String'')
, Pascal, QBasic, Visual Basic, Delphi
, -
, ''string''.strip()
, Python
, -
, strings.Trim(''string'', ''chars'')
, Go
, -
, LTRIM(RTRIM(''String''))
, Oracle SQL, T-SQL
, -
, strip(''string'' ''option'', ''char''
, REXX
, -
, string:strip(''string'' ''option'', ''char''
, Erlang
, -
, ''string''.strip or ''string''.lstrip or ''string''.rstrip
, Ruby
, -
, ''string''.trim
, Raku
, -
, trim(''string'')
, PHP, Raku
, -
, 'string'' stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet
, Objective-C using Cocoa (API), Cocoa
, -
, ''string'' withBlanksTrimmed
''string'' withoutSpaces
''string'' withoutSeparators
, Smalltalk (Squeak, Pharo)
Smalltalk
, -
, strip(string)
, SAS
, -
, string trim ''$string''
, Tcl
, -
, TRIM(''string'') or TRIM(ADJUSTL(''string''))
, Fortran
, -
, TRIM(''string'')
, SQL
, -
, TRIM(''string'') or LTrim(''string'') or RTrim(''String'')
, ColdFusion
, -
, String.trim ''string''
, OCaml 4+

Other languages

In languages without a built-in trim function, it is usually simple to create a custom function which accomplishes the same task.


APL

APL can use regular expressions directly:

Trim←'^ +, +$'⎕R''

Alternatively, a functional approach combining Boolean masks that filter away leading and trailing spaces:

Trim←{⍵/⍨(∨\∧∘⌽∨\∘⌽)' '≠⍵}

Or reverse and remove leading spaces, twice:

Trim←{(∨\' '≠⍵)/⍵}∘⌽⍣2

AWK

In AWK, one can use regular expressions to trim:

ltrim(v) = gsub(/^ \t/, "", v)
rtrim(v) = gsub(/ \t$/, "", v)
trim(v) = ltrim(v); rtrim(v)

or:

function ltrim(s) { sub(/^ \t/, "", s); return s }
function rtrim(s) { sub(/ \t$/, "", s); return s }
function trim(s) { return rtrim(ltrim(s)); }

C/C++

There is no standard trim function in C or C++. Most of the available string libraries for C contain code which implements trimming, or functions that significantly ease an efficient implementation. The function has also often been called EatWhitespace in some non-standard C libraries.

In C, programmers often combine a ltrim and rtrim to implement trim:

#include
#include

void rtrim(char *str)
{
char *s;
s = str + strlen(str);
while (--s >= str) {
if (!isspace(*s)) break;
*s = 0;
}
}

void ltrim(char *str)
{
size_t n;
n = 0;
while (str != '\0' && isspace((unsigned char) str ) {
n++;
}
memmove(str, str + n, strlen(str) - n + 1);
}

void trim(char *str)
{
rtrim(str);
ltrim(str);
}

The open source C++ library Boost has several trim variants, including a standard one:

#include
trimmed = boost::algorithm::trim_copy("string");

Note that with boost's function named simply trim the input sequence is modified in-place, and does not return a result.

Another open source C++ library Qt has several trim variants, including a standard one:

#include
trimmed = s.trimmed();

The Linux kernel also includes a strip function, strstrip(), since 2.6.18-rc1, which trims the string "in place". Since 2.6.33-rc1, the kernel uses strim() instead of strstrip() to avoid false warnings.

Haskell

A trim algorithm in Haskell:

import Data.Char (isSpace)
trim :: String -> String
trim = f . f
where f = reverse . dropWhile isSpace

may be interpreted as follows: ''f'' drops the preceding whitespace, and reverses the string. ''f'' is then again applied to its own output. Note that the type signature (the second line) is optional.

J

The trim algorithm in J is a functional description:

trim =. #~ [: (+./\ *. +./\.) ' '&~:

That is: filter (#~) for non-space characters (' '&~:) between leading (+./\) and (*.) trailing (+./\.) spaces.

JavaScript

There is a built-in trim function in JavaScript 1.8.1 (Firefox 3.5 and later), and the ECMAScript 5 standard. In earlier versions it can be added to the String object's prototype as follows:

String.prototype.trim = function() {
return this.replace(/^\s+/g, "").replace(/\s+$/g, "");
};

Perl

Perl 5 has no built-in trim function. However, the functionality is commonly achieved using regular expressions.

Example:

$string =~ s/^\s+//; # remove leading whitespace
$string =~ s/\s+$//; # remove trailing whitespace

or:

$string =~ s/^\s+, \s+$//g ; # remove both leading and trailing whitespace

These examples modify the value of the original variable $string.

Also available for Perl is StripLTSpace in String::Strip from CPAN.

There are, however, two functions that are commonly used to strip whitespace from the end of strings, chomp and chop:
* chop
/code> removes the last character from a string and returns it.
*
/code> removes the trailing newline character(s) from a string if present. (What constitutes a newline i

dependent).

In Raku, the upcoming sister language of Perl, strings have a trim method.

Example:

$string = $string.trim; # remove leading and trailing whitespace
$string .= trim; # same thing

Tcl

The Tcl string command has three relevant subcommands: trim, trimright and trimleft. For each of those commands, an additional argument may be specified: a string that represents a set of characters to remove—the default is whitespace (space, tab, newline, carriage return).

Example of trimming vowels:

set string onomatopoeia
set trimmed tring trim $string aeiou ;# result is nomatop
set r_trimmed tring trimright $string aeiou ;# result is onomatop
set l_trimmed tring trimleft $string aeiou ;# result is nomatopoeia

XSLT

XSLT includes the function normalize-space(''string'') which strips leading and trailing whitespace, in addition to replacing any whitespace sequence (including line breaks) with a single space.

Example:





XSLT 2.0 includes regular expressions, providing another mechanism to perform string trimming.

Another XSLT technique for trimming is to utilize the XPath 2.0 substring() function.

References

{{Reflist, refs=
the index can be negative, which then indicates the number of places before the end of the string.
the index can not be negative, use *-N where N indicate the number of places before the end of the string.

''startpos'' can be negative, which indicates to start that number of places before the end of the string.
''endpos'' can be negative, which indicates to end that number of places before the end of the string.
''numChars'' can be negative, which indicates to end that number of places before the end of the string.
''startpos'' can not be negative, use ''* - startpos'' to indicate to start that number of places before the end of the string.
''numChars'' can not be negative, use ''* - numChars'' to indicate to end that number of places before the end of the string.

*String functions
Programming language comparison
Articles with example Python (programming language) code