Comparison of programming languages (string functions)

"String functions" redirects here. For string functions in formal language theory, see String operations.

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

Most computer programming languages that have a string datatype will have some string functions although it should be noted that 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 both Prolog and Erlang, a string is represented as a list (of character codes), therefore all list-manipulation procedures are applicable, though the latter also implements a set of such procedures that are string-specific.

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

eg. 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)

Here is a list of common string functions which are found in other languages. Any other equivalent functions used by other languages are also listed. 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.

CharAt

Definition	charAt(string,integer) returns character.
Description	Returns character at index in the string.
Equivalent	See substring of length 1 character.

Format	Languages	Base index
string[i]	C, C++, C#, D, Python, PHP, Ruby, Windows PowerShell	0
string(i)	Ada
GetChar(string, i)	VB	1
string.Chars(i)	VB.NET	0
string.charAt(i)	Java, JavaScript	0
string.[i]	OCaml	0
string !! i	Haskell	0
(string-ref string i)	Scheme	0
(char string i)	Common Lisp	0
substr(string, i, 1)	Perl	0
string.at(i)	C++ (std::string only) (w/ bounds checking)	0
string:substr(string, i, 1)	Erlang	1

// Example in C#
"Hello, World"[2];         // 'l'

# Examples in Python
"Hello, World"[2]          #  'l'
"Hello, World"[-3]         #  'r'

' Example in Visual Basic
GetChar("Hello, World", 2) '  "e"c

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

Compare (integer result)

Definition	compare(string1,string2) returns integer.
Description	Compares two strings to each other. If they are equivalent, a zero is returned. Otherwise, most of these routines will return a positive or negative result corresponding to whether string1 is lexicographically greater than, or less than, respectively, than string2. The exceptions are the Scheme and REXX routines which return the index of the first mismatch.

Format	Languages
cmp(string1, string2)	Python
strcmp(string1, string2)	C, C++ (char * only), PHP
std.string.cmp(string1, string2)	D
StrComp(string1, string2)	VB
string1 cmp string2	Perl
string1 <=> string2	Ruby
string1.compare(string2)	C++ (std::string only)
compare(string1, string2)	REXX
CompareStr(string1, string2)	Pascal, Object Pascal (Delphi)
string1.compareTo(string2)	Java
string1.CompareTo(string2)	VB .NET, C#
(string-compare string1 string2 p< p= p>)	Scheme
compare string1 string2	OCaml
compare string1 string2	Haskell (returns LT, EQ, or GT)
[string]::Compare(string1, string2)	Windows PowerShell

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

/** 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 (integer result, fast/non-human ordering)

Definition

compare(string1,string2) returns integer.

Description

Compares two strings to each other. If they are equivalent, a zero is returned. Otherwise, most of these routines will return a positive or negative result corresponding to whether string1 is greater than, or less than, respectively, than string2. The reason for the difference between this and #Compare (integer result) is that no ordering guarantees are given, leaving the implementation to do whatever ordering is fastest, a common implementation is to order by length and then by byte value (which can be significantly faster, but much less useful to humans).

Format	Languages
if (!(ret = (string1_len - string2_len))) ret = memcmp(string1, string2, string1_len)	C
ustr_cmp_fast(string1, string2)	Ustr string library
(length(string1) <=> length(string2) ¦¦ string1 cmp string2)	Perl
cmp(len(string1), len(string2)) or cmp(string1, string2)	Python
(Length(string1) <> Length(string2)) or CompareStr(string1, string2)	Pascal, Object Pascal (Delphi)

Compare (relational operator-based, Boolean result)

Definition	string1 op string2 OR (compare string1 string2) returns Boolean.
Description	Lexicographically compares two strings using a relational operator or function. Boolean result returned.

Format	Languages
string1 op string2, where op can be any of =, <>, <, >, <= and >=	Pascal, Object Pascal (Delphi), OCaml, VB, VB .NET
(stringX string1 string2), where X can be any of =, -ci=, <>, -ci<>, <, -ci<, >, -ci>, <=, -ci<=, >= and -ci>= (operators starting with '-ci' are case-insensitive)	Scheme
(stringX string1 string2), where X can be any of =, -equal, /=, -not-equal, <, -lessp, >, -greaterp, <=, -not-greaterp, >= and -not-lessp (the verbal operators are case-insensitive)	Common Lisp
string1 op string2, where op can be any of =, \=, <, >, <= and >=	REXX
string1 op string2, where op can be any of =, /=, <, >, <= and >=	Ada
string1 op string2, where op can be any of ==, /=, <, >, =< and >=	Erlang
string1 op string2, where op can be any of ==, /=, <, >, <= and >=	Haskell
string1 op string2, where op can be any of eq, ne, lt, gt, le and ge	Perl
string1 op string2, where op can be any of ==, !=, <, >, <= and >=	C++ (std::string only), C#, D, JavaScript, Python, PHP, Ruby
string1 op string2, where op can be any of -eq, -ceq, -ne, -cne, -lt, -clt, -gt, -cgt, -le, -cle, -ge, and -cge (operators starting with 'c' are case-sensitive)	Windows PowerShell

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

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

Concatenation

Main article: Concatenation

Definition	concatenate(string1,string2) returns string.
Description	Concatenates (joins) two strings to each other, returning the combined string. Note that some languages like C have mutable strings, so really the second string is being appended to the first string and the mutated string is returned.

Format	Languages
string1 & string2	Ada, VB, VB .NET
strcat(string1, string2)	C, C++ (char * only; modifies string1, which must have enough space to store the result)
string1 . string2	Perl, PHP
string1 + string2	C++ (std::string only), C#, Pascal, Object Pascal (Delphi), Java, JavaScript, Windows PowerShell, Python, Ruby
string1 ~ string2	D
(string-append string1 string2)	Scheme
(concatenate 'string string1 string2)	Common Lisp
string1 || string2	REXX, Fortran
string1 ++ string2	Erlang, Haskell
string1 ^ string2	OCaml

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

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

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

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 programer but is often a significantly more expensive operation, this is especially true when using "C-strings".

Format	Languages
string1 == string2	Python, C++(std::string only), C#, JavaScript PHP, Ruby, Erlang, Haskell
strcmp(string1, string2) == 0	C, C++ (char * only)
string1 == string2	D
(string= string1 string2)	Scheme, Common Lisp
string1 = string2	Ada, Object Pascal (Delphi), OCaml, Pascal, REXX, VB, VB .NET
test string1 = string2, or [ string1 = string2 ]	Bourne Shell
string1 eq string2	Perl
string1.equals(string2)	Java
string1 -eq string2, or [string]::Equals(string1, string2)	Windows PowerShell

// Example in C#
"hello" == "world"           // returns false

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

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

Find

Definition	find(string,substring) returns integer
Description	Returns the position of the start of the first 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	instrrev

Format	Languages	If not found
InStr([startpos,]string,substring)	VB (positions start at 1)	returns 0
index(string,substring)	AWK	returns 0
index(string,substring[,startpos])	Perl	returns -1
strpos(string,substring[,startpos])	PHP	returns FALSE
locate(string, substring)	Ingres	returns string length + 1
strstr(string, substring)	C, C++ (char * only, returns pointer to first character)	returns NULL
std.string.find(string, substring)	D	returns -1
pos(substring, string)	Pascal, Object Pascal (Delphi)	returns 0
pos(substring, string[,startpos])	REXX	returns 0
string.find(substring[,startpos])	C++ (std::string only)	returns std::string::npos
string.find(substring[,startpos[,endpos]])	Python	returns -1
string.index(substring[,startpos])	Ruby	returns nil
string.indexOf(substring[,startpos])	Java, JavaScript	returns -1
string.IndexOf(substring[,startpos[, charcount]])	VB .NET, C#, Windows PowerShell	returns -1
string:str(string, substring)	Erlang	returns 0
(string-contains string substring)	Scheme	returns #f
(search substring string)	Common Lisp	returns NIL
List.findIndex (List.isPrefixOf substring) (List.tails string)	Haskell (returns Just index)	returns Nothing
Str.search_forward (Str.regexp_string substring) string 0	OCaml	raises Not_found

; 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 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

Find character

Definition	find character(string,char) returns integer
Description	Returns the position of the start of the first occurrence of the character char in string. If the character 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. This can be accomplished as a special case of #Find, with a string of one character; but it may be simpler or more efficient in many languages to locate just a single character. Also, in many languages, characters and strings are different types, so it is convenient to have such a function.
Related	find

Format	Languages	If not found
strchr(string,char)	C, C++ (char * only, returns pointer to character)	returns NULL
std.string.find(string, dchar)	D	returns -1
string.find(char[,startpos])	C++ (std::string only)	returns std::string::npos
string.indexOf(char[,startpos])	Java	returns -1
(position char string)	Common Lisp	returns NIL
List.elemIndex char string	Haskell (returns Just index)	returns Nothing
String.index string char	OCaml	raises Not_found

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

Format

Definition	format(formatstring, items) returns string
Description	Returns the formatted string representation of one or more items. See sprintf for more information.

Format	Languages
Format(item, formatstring)	VB
sprintf(formatstring, items)	Perl, PHP, Ruby
io:format(formatstring, items)	Erlang
sprintf(outputstring, formatstring, items)	C, C++ (char * only)
std.string.format(formatstring, items)	D
printf -v outputstring formatstring items	Unix
formatstring % (items)	Python, Ruby
formatstring.format(items)	Python 3.x (format specification is different from printf)
Printf.sprintf formatstring items	OCaml
Text.Printf.printf formatstring items	Haskell (GHC)
String.format(formatstring, items)	Java
String.Format(formatstring, items)	VB .NET, C#
(format formatstring items)	Scheme
(format nil formatstring items)	Common Lisp
formatstring -f items	Windows PowerShell

// Example in C#
String.Format("My {0} costs {1:C2}", "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"

# Example in Perl
sprintf("My %s costs $%2f", "pen", 19.99);          #  returns "My pen costs $19.99"

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

Inequality

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

Format	Languages
string1 <> string2	VB,VB .NET, Pascal, Object Pascal (Delphi), OCaml
string1 ne string2	Perl
(string<>? string1 string2)	Scheme
(string/= string1 string2))	Common Lisp
string1 != string2	C++ (std::string only), C#, JavaScript, Python, Ruby, D
string1 \= string2	REXX
string1 /= string2	Ada, Erlang, Haskell
test string1 != string2, or [ string1 != string2 ]	Bourne Shell
string1 -ne string2, or -not [string]::Equals(string1, string2)	Windows PowerShell

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

' Example in Visual Basic
"hello" <> "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

Definition	join(separator, list_of_strings) joins a list of strings with a separator
Description	Joins the list of strings into a new string, with the separator string between each of the substrings. Opposite of split.
Related	sprintf

Format	Languages
std.string.join(array_of_strings, separator)	D
join(separator, list_of_strings)	Perl
implode(separator, array_of_strings)	PHP
separator.join(sequence_of_strings)	Python
array_of_strings.join(separator)	Ruby, JavaScript
(string-join array_of_strings separator)	Scheme
(format nil "~{~a~^separator~}" array_of_strings)	Common Lisp
String.concat separator list_of_strings	OCaml
Data.List.intercalate separator list_of_strings	Haskell (GHC)
Join(array_of_strings, separator)	VB
String.Join(separator, array_of_strings)	VB .NET, C#
&{$OFS=$separator; "$array_of_strings"}, or array_of_strings -join separator	Windows PowerShell

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

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

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

lastindexof

see #rfind

left

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

Format	Languages
string (string'First .. string'First + n - 1)	Ada
string:substr(string, start, length)	Erlang
Left(string,n)	VB
left(string,n)	Ingres
left(string,n [,padchar])	REXX, Erlang
substr(string, 0, n)	AWK (changes string), Perl, PHP
string[:n]	Python
string[0, n] string[0..n - 1]	Ruby
string.substr(0,n)	C++ (std::string only)
string[0 .. n]	D (if n is largerer than length of string, then in Debug mode ArrayRangeException is thrown, in Release mode behaviour is unspecified, mostly Segmentation Fault)
string.Substring(0,n)	VB .NET, C#, Windows PowerShell
leftstr(string, n)	Pascal, Object Pascal (Delphi)
string.substring(0,n)	Java, JavaScript
(string-take string n)	Scheme
take n string	Haskell

/* 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

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.

Format	Languages
string'Length	Ada
length(string)	Perl, Ingres, Pascal, Object Pascal (Delphi), REXX
len(string)	Python
length(string), string:len(string)	Erlang
Len(string)	VB
string.Length	VB .NET, C#, Windows PowerShell
string.size OR string.length	Ruby
strlen(string)	C, C++ (char * only), PHP
string.length()	C++ (std::string only), Java
string.length	D
string.length	JavaScript
(string-length string)	Scheme
(length string)	Common Lisp
String.length string	OCaml
length string	Haskell

// 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
length("hello");     #  returns 5
length("");          #  returns 0

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

locate

see #Find

Lowercase

Definition	lowercase(string) returns string
Description	Returns the string in lower case.

Format	Languages
LCase(string)	VB
lc(string)	Perl
tolower(char)	C (operates on a single character)
std.string.tolower(string)	D
transform(string.begin(), string.end(), result.begin(), tolower)	C++ (std::string only, result is stored in string result which is at least as long as string, and may or may not be string itself)
lowercase(string)	Delphi
strtolower(string)	PHP
echo "string" | tr 'A-Z' 'a-z'	Unix
string.lower()	Python
string.downcase	Ruby
(string-downcase string)	Scheme, Common Lisp
String.lowercase string	OCaml
map Char.toLower string	Haskell
string.toLowerCase()	Java, JavaScript
to_lower(string)	Erlang
string.ToLower()	VB .NET, C#, Windows PowerShell

// 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 Visual Basic
LCase("Wiki means fast?")            '  "wiki means fast?"

mid

see #substring

partition

Definition	<string>.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.

Format	Languages
string.partition(separator)	Python, Ruby
lists:partition(pred, string)	Erlang

# 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', "", "")

replace

Definition	replace(string, find, replace) returns string
Description	Returns a string the with find occurrences changed to replace.

Format	Languages
changestr(find, string, replace)	REXX
std.string.replace(string, find, replace)	D
Replace(string, find, replace)	VB
string.Replace(find, replace)	VB .NET, C#
str_replace(find, replace, string)	PHP
re:replace(string, find, replace, [{return, list}])	Erlang
string.replace(find, replace)	Python, Java (1.5+)
string.replaceAll(find_regex, replace)	Java
string.gsub(find, replace)	Ruby
string =~ s/find_regex/replace/g	Perl
string.replace(find, replace, "g") or string.replace(/find_regex/g, replace)	JavaScript
echo "string" | sed 's/find_regex/replace/g'	Unix
string.replace(find, replace), or string -replace find_regex, replace	Windows PowerShell
Str.global_replace (Str.regexp_string find) replace string	OCaml

// 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 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

Definition	reverse(string)
Description	Reverses the order of the characters in the string.

Format	Languages
reverse string	Perl, Haskell
lists:reverse(string)	Erlang
strrev(string)	PHP
string[::-1]	Python
(string-reverse string)	Scheme
(reverse string)	Common Lisp
string.reverse	Ruby
new StringBuilder(string).reverse().toString()	Java
std::reverse(string.begin(), string.end());	C++ (std::string only)
StrReverse(string)	VB
string.Reverse().ToString()	VB .NET, C#

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

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

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

rfind

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

Format	Languages	If not found
InStrRev([startpos, ]string,substring)	VB	returns 0
rindex(string,substring[,startpos])	Perl	returns -1
strrpos(string,substring[,startpos])	PHP	returns FALSE
string.rfind(substring[,startpos])	C++ (std::string only)	returns std::string::npos
std.string.rfind(string, substring)	D	returns -1
string.rfind(substring[,startpos[, endpos]])	Python	returns -1
string.rindex(substring[,startpos])	Ruby	returns nil
string.lastIndexOf(substring[,startpos])	Java, JavaScript	returns -1
string.LastIndexOf(substring[,startpos[, charcount]])	VB .NET, C#, Windows PowerShell	returns -1
(search substring string :from-end)	Common Lisp	returns NIL

; Examples in Common Lisp
(search "e" "Hello mate" :from-end)      ;  returns 9
(search "z" "word" :from-end)            ;  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 Visual Basic
InStrRev("Hello mate", "e")              '  returns 10
InStrRev(5, "Hello mate", "e")           '  returns 2
InStrRev("word", "z")                    '  returns 0

right

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

Format	Languages
string (string'Last - n + 1 .. string'Last)	Ada
Right(string,n)	VB
right(string,n)	Ingres
string.substring(string.length()-n, string.length())	Java
right(string,n [,padchar])	REXX, Erlang
substr(string,-n)	Perl, PHP
string[-n:]	Python
(string-take-right string n)	Scheme
string[-n..-1]	Ruby
string[$-n .. $]	D (if n is largerer than lenght of string, then in Debug mode ArrayRangeException is thrown, and unspecified behaviour in Release mode)

/* 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"

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

rpartition

Definition	<string>.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.

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

Definition	<string>.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. Opposite of join.

Format	Languages
split(/separator/, string[, limit])	Perl
explode(separator, string[, limit])	PHP
string.split(separator[, limit])	Javascript, Java, Python, Ruby
string:tokens(string, sepchars)	Erlang
(string-tokenize string[ charset[ start[ end]]])	Scheme
Split(string, sepchars[, limit])	VB
string.Split(sepchars[, limit[, options]])	VB .NET, C#
string -split separator[, limit[, options]]	Windows PowerShell
Str.split (Str.regexp_string separator) string	OCaml
std.string.split(string, separator)	D

// 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"}

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

sprintf

see #Format

strip

see #trim

strcmp

see #Compare (integer result)

substring

Definition	substr(string, startpos, numChars) returns string
Description	Returns a substring of string starting at startpos of length numChars. The resulting string is truncated if there are fewer than numChars characters beyond the starting point

Format	Languages
string (startpos .. endpos)	Ada (changes base index)
Mid(string, startpos, numChars)	VB
substr(string, startpos, numChars)	AWK (changes string), Perl, PHP
substr(string, startpos [,numChars, padChar])	REXX
string[startpos:endpos]	Python
string[startpos, numChars] string[startpos .. endpos-1]	Ruby
string.slice(startpos, endpos)	JavaScript
string.substr(startpos, numChars)	C++ (std::string only)
string.Substring(startpos, numChars)	VB .NET, C#, Windows PowerShell
string.substring(startpos, endpos)	Java, JavaScript
copy(string, startpos, numChars)	Delphi
(string-copy string startpos endpos)	Scheme
(subseq string startpos endpos)	Common Lisp
String.sub string startpos numChars	Ocaml
substr(string, startpos, numChars)	Erlang
char result[numChars+1] = ""; strncat(result, string + startpos, numChars);	C
string[startpos .. endpos+1)	D
take numChars $ drop startpos string	Haskell

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

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

# Examples in Python
"abc"[1:1]                 #  returns "b"
"abc"[1:2]                 #  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

Definition	uppercase(string) returns string
Description	Returns the string in upper case.

Format	Languages
UCase(string)	VB
toupper(string)	AWK (changes string)
uc(string)	Perl
toupper(char)	C (operates on a single character)
std.string.toupper(string)	D
transform(string.begin(), string.end(), result.begin(), toupper)	C++ (std::string only, result is stored in string result which is at least as long as string, and may or may not be string itself)
uppercase(string)	Delphi
strtoupper(string)	PHP
echo "string" | tr 'a-z' 'A-Z'	Unix
translate(string)	REXX
string.upper()	Python
string.upcase	Ruby
(string-upcase string)	Scheme, Common Lisp
String.uppercase string	OCaml
map Char.toUpper string	Haskell
string.toUpperCase()	Java, JavaScript
to_upper(string)	Erlang
string.ToUpper()	VB .NET, C#, Windows PowerShell

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

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

; 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

Main article: Trim (programming)

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

External links

• Perl String Functions
• Python String Methods
• Scheme String Procedures
• Erlang String Functions
• The Ustr String Library
• .NET String Methods and Properties
• Ruby String Class
• PHP String functions
• java.lang.String members
• Online String Manipulation Tools
• Haskell Hierarchical Libraries
• std.string from Phobos (D standard library)