String_processing

Comparison of programming languages (string functions)

Add article description

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

More information Definition, Description ...

More information Format, Languages ...

{ Example in Pascal }
var
  MyStr: string = 'Hello, World';
  MyChar: Char;
begin
  MyChar := MyStr[2];          // 'e'

# Example in ALGOL 68 #
"Hello, World"[2];             // 'e'

// Example in C
#include <stdio.h>             // 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 <iostream>            // for "cout"
#include <string.h>            // 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"[2];             // 'l'

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

# Examples in Python
"Hello, World"[2]              #  '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')

Contains

More information Definition, Description ...

More information Format, Languages ...

¢ 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 "

References

[1]
the index can be negative, which then indicates the number of places before the end of the string.
[2]
In Rust, the str::chars method iterates over code points and the std::iter::Iterator::nth method on iterators returns the zero-indexed nth value from the iterator, or None.
[3]
the index can not be negative, use *-N where N indicate the number of places before the end of the string.
[4]
In C++, the overloaded operator<=> method on a string returns a std::strong_ordering object (otherwise std::weak_ordering): less, equal (same as equivalent), or greater.
[5]
returns LESS, EQUAL, or GREATER
[6]
returns LT, EQ, or GT
[7]
returns .TRUE. or .FALSE.. These functions are based on the ASCII collating sequence.
[8]
IBM extension.
[9]
In Rust, the Ord::cmp method on a string returns an Ordering: Less, Equal, or Greater.
[10]
In Rust, the operators == and != and the methods eq, ne are implemented by the PartialEq trait, and the operators <, >, <=, >= and the methods lt, gt, le, ge are implemented by the PartialOrd trait.
[11]
The operators use the compiler's default collating sequence.
[12]
modifies string₁, which must have enough space to store the result
[13]
In Rust, the + operator is implemented by the Add trait.
[14]
See the str::contains method.
[15]
See the std::basic_string::contains method.
[16]
startpos is IBM extension.
[17]
See the str::find method.
[18]
startpos is IBM extension.
[19]
"scan in Fortran Wiki". Fortranwiki.org. 2009-04-30. Retrieved 2013-08-18.
[20]
"verify in Fortran Wiki". Fortranwiki.org. 2012-05-03. Retrieved 2013-08-18.
[21]
formatstring must be a fixed literal at compile time for it to have the correct type.
[22]
See std::format, which is imported by the Rust prelude so that it can be used under the name format.
[23]
See the slice::join method.
[24]
if n is larger than the length of the string, then in Debug mode ArrayRangeException is thrown, in Release mode, the behaviour is unspecified.
[25]
if n is larger than the length of the string, Java will throw an IndexOutOfBoundsException
[26]
if n is larger than length of string, raises Invalid_argument
[27]
if n is larger than length of string, throw the message "StringTake::take:"
[28]
In 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 be indexed by various types of ranges, including Range (0..n), RangeFrom (n..), and RangeTo (..n) because they all implement the SliceIndex trait with str being the type being indexed. The str::get method is the non-panicking way to index. It returns None in the cases in which indexing would panic.
[29]
Ruby lacks Unicode support
[30]
See the str::len method.
[31]
In Rust, the str::chars method iterates over code points and the std::iter::Iterator::count method on iterators consumes the iterator and returns the total number of elements in the iterator.
[32]
operates on one character
[33]
The transform function exists in the std:: namespace. You must include the <algorithm> header file to use it. The tolower and toupper functions are in the global namespace, obtained by the <ctype.h> 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);
[34]
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
[35]
only ASCII characters as Ruby lacks Unicode support
[36]
See the str::to_lowercase method.
[37]
See the str::replace method.
[38]
The "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.
[39]
third parameter is non-standard
[40]
In Rust, the str::chars method iterates over code points, the std::iter::Iterator::rev method on reversible iterators (std::iter::DoubleEndedIterator) creates a reversed iterator, and the std::iter::Iterator::collect method consumes the iterator and creates a collection (which here is specified as a String with the turbofish syntax) from the iterator's elements.
[41]
See the str::rfind method.
[42]
"Annotated ES5". Es5.github.com. Archived from the original on 2013-01-28. Retrieved 2013-08-18.
[43]
if n is larger than length of string, then in Debug mode ArrayRangeException is thrown, and unspecified behaviour in Release mode
[44]
See the str::split and str::rsplit methods.
[45]
startpos can be negative, which indicates to start that number of places before the end of the string.
[46]
numChars can be negative, which indicates to end that number of places before the end of the string.
[47]
startpos can not be negative, use * - startpos to indicate to start that number of places before the end of the string.
[48]
numChars can not be negative, use * - numChars to indicate to end that number of places before the end of the string.
[49]
endpos can be negative, which indicates to end that number of places before the end of the string.
[50]
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
[51]
In Rust, the str::to_uppercase method returns a newly allocated String with any lowercase characters changed to uppercase ones following the Unicode rules.
[52]
In Rust, the str::trim method returns a reference to the original &str.
[53]
"Trim – GNU Pascal priručnik". Gnu-pascal.de. Retrieved 2013-08-24.
[54]
"String library comparison". And.org. Retrieved 2013-08-24.
[55]
"Usage – 1.54.0". Boost.org. 2013-05-22. Retrieved 2013-08-24.
[56]
Archived August 2, 2009, at the Wayback Machine
[57]
dankamongmen. "sprezzos-kernel-packaging/changelog at master · dankamongmen/sprezzos-kernel-packaging · GitHub". Github.com. Retrieved 2016-05-29.

Share this article:

This article uses material from the Wikipedia article String_processing, and is written by contributors. Text is available under a CC BY-SA 4.0 International License; additional terms may apply. Images, videos and audio are available under their respective licenses.

[at1-1] [1]
the index can be negative, which then indicates the number of places before the end of the string.

[2] [2]
In Rust, the str::chars method iterates over code points and the std::iter::Iterator::nth method on iterators returns the zero-indexed nth value from the iterator, or None.

[at2-3] [3]
the index can not be negative, use *-N where N indicate the number of places before the end of the string.

[4] [4]
In C++, the overloaded operator<=> method on a string returns a std::strong_ordering object (otherwise std::weak_ordering): less, equal (same as equivalent), or greater.

[5] [5]
returns LESS, EQUAL, or GREATER

[6] [6]
returns LT, EQ, or GT

[7] [7]
returns .TRUE. or .FALSE.. These functions are based on the ASCII collating sequence.

[lower1-8] [8]
IBM extension.

[9] [9]
In Rust, the Ord::cmp method on a string returns an Ordering: Less, Equal, or Greater.

[Rust_compare-10] [10]
In Rust, the operators == and != and the methods eq, ne are implemented by the PartialEq trait, and the operators <, >, <=, >= and the methods lt, gt, le, ge are implemented by the PartialOrd trait.

[11] [11]
The operators use the compiler's default collating sequence.

[12] [12]
modifies string₁, which must have enough space to store the result

[13] [13]
In Rust, the + operator is implemented by the Add trait.

[14] [14]
See the str::contains method.

[15] [15]
See the std::basic_string::contains method.

[contain1-16] [16]
startpos is IBM extension.

[Rust_find-17] [17]
See the str::find method.

[fc1-18] [18]
startpos is IBM extension.

[19] [19]
"scan in Fortran Wiki". Fortranwiki.org. 2009-04-30. Retrieved 2013-08-18.

[20] [20]
"verify in Fortran Wiki". Fortranwiki.org. 2012-05-03. Retrieved 2013-08-18.

[21] [21]
formatstring must be a fixed literal at compile time for it to have the correct type.

[22] [22]
See std::format, which is imported by the Rust prelude so that it can be used under the name format.

[23] [23]
See the slice::join method.

[24] [24]
if n is larger than the length of the string, then in Debug mode ArrayRangeException is thrown, in Release mode, the behaviour is unspecified.

[25] [25]
if n is larger than the length of the string, Java will throw an IndexOutOfBoundsException

[ReferenceA-26] [26]
if n is larger than length of string, raises Invalid_argument

[ReferenceB-27] [27]
if n is larger than length of string, throw the message "StringTake::take:"

[Rust_indexing-28] [28]
In 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 be indexed by various types of ranges, including Range (0..n), RangeFrom (n..), and RangeTo (..n) because they all implement the SliceIndex trait with str being the type being indexed. The str::get method is the non-panicking way to index. It returns None in the cases in which indexing would panic.

[29] [29]
Ruby lacks Unicode support

[30] [30]
See the str::len method.

[31] [31]
In Rust, the str::chars method iterates over code points and the std::iter::Iterator::count method on iterators consumes the iterator and returns the total number of elements in the iterator.

[32] [32]
operates on one character

[cpptransform-33] [33]
The transform function exists in the std:: namespace. You must include the <algorithm> header file to use it. The tolower and toupper functions are in the global namespace, obtained by the <ctype.h> 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);

[34] [34]
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

[ReferenceC-35] [35]
only ASCII characters as Ruby lacks Unicode support

[36] [36]
See the str::to_lowercase method.

[37] [37]
See the str::replace method.

[regex-38] [38]
The "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.

[39] [39]
third parameter is non-standard

[40] [40]
In Rust, the str::chars method iterates over code points, the std::iter::Iterator::rev method on reversible iterators (std::iter::DoubleEndedIterator) creates a reversed iterator, and the std::iter::Iterator::collect method consumes the iterator and creates a collection (which here is specified as a String with the turbofish syntax) from the iterator's elements.

[41] [41]
See the str::rfind method.

[42] [42]
"Annotated ES5". Es5.github.com. Archived from the original on 2013-01-28. Retrieved 2013-08-18.

[43] [43]
if n is larger than length of string, then in Debug mode ArrayRangeException is thrown, and unspecified behaviour in Release mode

[44] [44]
See the str::split and str::rsplit methods.

[substr2-45] [45]
startpos can be negative, which indicates to start that number of places before the end of the string.

[substr4-46] [46]
numChars can be negative, which indicates to end that number of places before the end of the string.

[substr5-47] [47]
startpos can not be negative, use * - startpos to indicate to start that number of places before the end of the string.

[substr6-48] [48]
numChars can not be negative, use * - numChars to indicate to end that number of places before the end of the string.

[substr3-49] [49]
endpos can be negative, which indicates to end that number of places before the end of the string.

[50] [50]
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

[51] [51]
In Rust, the str::to_uppercase method returns a newly allocated String with any lowercase characters changed to uppercase ones following the Unicode rules.

[52] [52]
In Rust, the str::trim method returns a reference to the original &str.

[53] [53]
"Trim – GNU Pascal priručnik". Gnu-pascal.de. Retrieved 2013-08-24.

[54] [54]
"String library comparison". And.org. Retrieved 2013-08-24.

[55] [55]
"Usage – 1.54.0". Boost.org. 2013-05-22. Retrieved 2013-08-24.

[56] [56]
Archived August 2, 2009, at the Wayback Machine

[57] [57]
dankamongmen. "sprezzos-kernel-packaging/changelog at master · dankamongmen/sprezzos-kernel-packaging · GitHub". Github.com. Retrieved 2016-05-29.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[17]

[a]

[18]

[19]

[20]

[21]

[22]

[23]

[24]

[25]

[26]

[27]

[28]

[29]

[30]

[31]

[32]

[33]

[34]

[35]

[36]

[37]

[38]

[39]

[40]

[41]

[42]

[43]

[44]

[45]

[46]

[47]

[48]

[49]

[50]

[51]

[52]

[53]

[54]

[55]

[56]

[57]

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]`	ALGOL 68, APL, Julia, Pascal, Object Pascal (Delphi), Seed7	1
`string[i]`	C, C++, C#, Cobra, D, FreeBASIC, Go, Python,^[1] PHP, Ruby,^[1] Windows PowerShell, JavaScript, APL	0
`string{i}`	PHP (deprecated in 5.3)	0
`string(i)`	Ada	≥1
`Mid(string,i,1)`	VB	1
`MID$(string,i,1)`	BASIC	1
`string.Chars(i)`	VB.NET	0
`string(i:i)`	Fortran	1
`string.charAt(i)`	Java, JavaScript	0
`string.[i]`	OCaml, F#	0
`string.chars().nth(i)`	Rust^[2]	0
`string[i,1]`	Pick Basic	1
`String.sub (string, i)`	Standard ML	0
`string !! i`	Haskell	0
`(string-ref string i)`	Scheme	0
`(char string i)`	Common Lisp	0
`(elt string i)`	ISLISP	0
`(get string i)`	Clojure	0
`substr(string, i, 1)`	Perl 5^[1]	0
`substr(string, i, 1)` `string.substr(i, 1)`	Raku^[3]	0
`substr(string, i, 1)`	PL/I	1
`string.at(i)`	C++ (STL) (w/ bounds checking)	0
`lists:nth(i, string)`	Erlang	1
`[string characterAtIndex:i]`	Objective-C (`NSString *` only)	0
`string.sub(string, i, i)` `(string):sub(i, i)`	Lua^[1]	1
`string at: i`	Smalltalk (w/ bounds checking)	1
`string index string i`	Tcl	0
`StringTake[string, {i}]`	Mathematica, Wolfram Language^[1]	1
`string@i`	Eiffel	1
`string (i:1)`	COBOL	1
`${string_param:i:1}`	Bash	0
`i⌷string`	APL	0 or 1

Format	Languages
`IF string₁<string₂ THEN -1 ELSE ABS (string₁>string₂) FI`	ALGOL 68
`cmp(string₁, string₂)`	Python 2
`(string₁ > string₂) - (string₁ < string₂)`	Python
`strcmp(string₁, string₂)`	C, PHP
`std.string.cmp(string₁, string₂)`	D
`StrComp(string₁, string₂)`	VB, Object Pascal (Delphi)
`string₁ cmp string₂`	Perl, Raku
`string₁ compare: string₂`	Smalltalk (Squeak, Pharo)
`string₁ <=> string₂`	Ruby, C++ (STL, C++20)^[4]
`string₁.compare(string₂)`	C++ (STL), Swift (Foundation)
`compare(string₁, string₂)`	Rexx, Seed7
`CompareStr(string₁, string₂)`	Pascal, Object Pascal (Delphi)
`string₁.compareTo(string₂)`	Cobra, Java
`string₁.CompareTo(string₂)`	VB .NET, C#, F#
`(compare string₁ string₂)`	Clojure
`(string= string₁ string₂)`	Common Lisp
`(string-compare string₁ string₂ p< p= p>)`	Scheme (SRFI 13)
`(string= string₁ string₂)`	ISLISP
`compare string₁ string₂`	OCaml
`String.compare (string₁, string₂)`	Standard ML^[5]
`compare string₁ string₂`	Haskell^[6]
`[string]::Compare(string₁, string₂)`	Windows PowerShell
`[string₁ compare:string₂]`	Objective-C (`NSString *` only)
`LLT(string₁,string₂)` `LLE(string₁,string₂)` `LGT(string₁,string₂)` `LGE(string₁,string₂)`	Fortran^[7]
`string₁.localeCompare(string₂)`	JavaScript
`bytes.Compare([]byte(string₁), []byte(string₂))`	Go
`string compare string₁ string₂`	Tcl
`compare(string₁,string₂,count)`	PL/I^[8]
`string₁.cmp(string₂)`	Rust^[9]

Format	Languages
`string₁ OP string₂`, where `OP` can be any of `=, <>, <, >, <=` and `>=`	Pascal, Object Pascal (Delphi), OCaml, Seed7, Standard ML, BASIC, VB, VB .NET, F#
`string₁ OP string₂`, where `OP` can be any of `=, /=, ≠, <, >, <=, ≤` and `≥`; Also: `EQ, NE, LT, LE, GE` and `GT`	ALGOL 68
`(stringOP? string₁ string₂)`, where `OP` can be any of `=, -ci=, <, -ci<, >, -ci>, <=, -ci<=, >=` and `-ci>=` (operators starting with '`-ci`' are case-insensitive)	Scheme
`(stringOP string₁ string₂)`, where `OP` can be any of `=, -ci=, <>, -ci<>, <, -ci<, >, -ci>, <=, -ci<=, >=` and `-ci>=` (operators starting with '`-ci`' are case-insensitive)	Scheme (SRFI 13)
`(stringOP string₁ string₂)`, where `OP` can be any of `=, -equal, /=, -not-equal, <, -lessp, >, -greaterp, <=, -not-greaterp, >=` and `-not-lessp` (the verbal operators are case-insensitive)	Common Lisp
`(stringOP string₁ string₂)`, where `OP` can be any of `=, /=, <, >, <=,` and `>=`	ISLISP
`string₁ OP string₂`, where `OP` can be any of `=, \=, <, >, <=` and `>=`	Rexx
`string₁ OP string₂`, where `OP` can be any of `=, ¬=, <, >, <=, >=, ¬<` and `¬>`	PL/I
`string₁ OP string₂`, where `OP` can be any of `=, /=, <, >, <=` and `>=`	Ada
`string₁ OP string₂`, where `OP` can be any of `==, /=, <, >, =<` and `>=`	Erlang
`string₁ OP string₂`, where `OP` can be any of `==, /=, <, >, <=` and `>=`	Haskell
`string₁ OP string₂`, where `OP` can be any of `eq, ne, lt, gt, le` and `ge`	Perl, Raku
`string₁ OP string₂`, where `OP` can be any of `==, !=, <, >, <=` and `>=`	C++ (STL), C#, D, Go, JavaScript, Python, PHP, Ruby, Rust,^[10] Swift
`string₁ OP string₂`, 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
`string₁ OP string₂`, where `OP` can be any of `==, ~=, <, >, <=` and `>=`	Lua
`string₁ OP string₂`, where `OP` can be any of `=, ~=, <, >, <=` and `>=`	Smalltalk
`string₁ OP string₂`, where `OP` can be any of `==, /=, <, >, <=` and `>=; Also: .EQ., .NE., .LT., .LE., .GT.` and `.GE.`	Fortran.^[11]
`string₁ OP string₂` where `OP` can be any of `=, <>, <, >, <=, >=` as well as worded equivalents	COBOL
`string₁ OP string₂` where `OP` can be any of `==, <>, <, >, <=` and `>=`	Cobra
`string₁ OP string₂` is available in the syntax, but means comparison of the pointers pointing to the strings, not of the string contents. Use the Compare (integer result) function.	C, Java
`string₁.METHOD(string₂)` where `METHOD` is any of `eq`, `ne`, `gt`, `lt`, `ge`, `le`	Rust^[10]

Format	Languages
`string₁ & string₂`	Ada, FreeBASIC, Seed7, BASIC, VB, VB .NET, COBOL (between literals only)
`strcat(string₁, string₂)`	C, C++ (`char *` only)^[12]
`string₁ . string₂`	Perl, PHP
`string₁ + string₂`	ALGOL 68, C++ (STL), C#, Cobra, FreeBASIC, Go, Pascal, Object Pascal (Delphi), Java, JavaScript, Windows PowerShell, Python, Ruby, Rust,^[13] F#, Swift, Turing, VB
`string₁ ~ string₂`	D, Raku
`(string-append string₁ string₂)`	Scheme, ISLISP
`(concatenate 'string string₁ string₂)`	Common Lisp
`(str string₁ string₂)`	Clojure
`string₁ \|\| string₂`	Rexx, SQL, PL/I
`string₁ // string₂`	Fortran
`string₁ ++ string₂`	Erlang, Haskell
`string₁ ^ string₂`	OCaml, Standard ML, F#
`[string₁ stringByAppendingString:string₂]`	Objective-C (`NSString *` only)
`string₁ .. string₂`	Lua
`string₁ , string₂`	Smalltalk, APL
`string₁ string₂`	SNOBOL
`string₁string₂`	Bash
`string₁ <> string₂`	Mathematica
concat string₁ string₂	Tcl

Definition	`compare(string₁,string₂)` 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 string₁ is lexicographically greater than, or less than, respectively, than string₂. The exceptions are the Scheme and Rexx routines which return the index of the first mismatch, and Smalltalk which answer a comparison code telling how the receiver sorts relative to string parameter.

Definition	`string₁ OP string₂` OR `(compare string₁ string₂)` returns Boolean.
Description	Lexicographically compares two strings using a relational operator or function. Boolean result returned.

Definition	`concatenate(string₁,string₂)` 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.

Definition	`contains(string,substring)` returns boolean
Description	Returns whether string contains substring as a substring. This is equivalent to using Find and then detecting that it does not result in the failure condition listed in the third column of the Find section. However, some languages have a simpler way of expressing this test.
Related	Find

Format	Languages
`string_in_string(string, loc int, substring)`	ALGOL 68
`ContainsStr(string, substring)`	Object Pascal (Delphi)
`strstr(string, substring) != NULL`	C, C++ (`char *` only)
`string.Contains(substring)`	C#, VB .NET, Windows PowerShell, F#
`string.contains(substring)`	Cobra, Java (1.5+), Raku, Rust,^[14] C++ (C++23)^[15]
`string.indexOf(substring) >= 0`	JavaScript
`strpos(string, substring) !== false`	PHP
`str_contains(string, substring)`	PHP (8+)
`pos(string, substring) <> 0`	Seed7
`substring in string`	Cobra, Python (2.3+)
`string.find(string, substring) ~= nil`	Lua
`string.include?(substring)`	Ruby
`Data.List.isInfixOf substring string`	Haskell (GHC 6.6+)
`string includesSubstring: substring`	Smalltalk (Squeak, Pharo, Smalltalk/X)
`String.isSubstring substring string`	Standard ML
`(search substring string)`	Common Lisp
`(not (null (string-index substring string)))`	ISLISP
`(substring? substring string)`	Clojure
`! StringFreeQ[string, substring]`	Mathematica
`index(string, substring, startpos)>0`	Fortran, PL/I^[16]
`index(string, substring, occurrence)>0`	Pick Basic
`strings.Contains(string, substring)`	Go
`string.find(substring) != string::npos`	C++
`[string containsString:substring]`	Objective-C (`NSString *` only, iOS 8+/OS X 10.10+)
`string.rangeOfString(substring) != nil`	Swift (Foundation)
`∨/substring⍷string`	APL

Format	Languages
`string₁ == string₂`	Python, C++ (STL), C#, Cobra, Go, JavaScript (similarity), PHP (similarity), Ruby, Rust,^[10] Erlang, Haskell, Lua, D, Mathematica, Swift
`string₁ === string₂`	JavaScript, PHP
`string₁ == string₂` `string₁ .EQ. string₂`	Fortran
`strcmp(string₁, string₂) == 0`	C
`(string=? string₁ string₂)`	Scheme
`(string= string₁ string₂)`	Common Lisp, ISLISP
`string₁ = string₂`	ALGOL 68, Ada, Object Pascal (Delphi), OCaml, Pascal, Rexx, Seed7, Standard ML, BASIC, VB, VB .NET, F#, Smalltalk, PL/I, COBOL
`test string₁ = string₂` `[ string₁ = string₂ ]`	Bourne Shell
`string₁ eq string₂`	Perl, Raku
`string₁.equals(string₂)`	Cobra, Java
`string₁.Equals(string₂)`	C#
`string₁ -eq string₂` `[string]::Equals(string₁, string₂)`	Windows PowerShell
`[string₁ isEqualToString:string₂]` `[string₁ isEqual:string₂]`	Objective-C (`NSString *` only)
`string₁ ≡ string₂`	APL
`string₁.eq(string₂)`	Rust^[10]

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
`string in string(substring, pos, string[startpos:])`	ALGOL 68	returns BOOL: TRUE or FALSE, and position in REF INT pos.
`InStr(«startpos,»string,substring)`	VB (positions start at 1)	returns 0
`INSTR$(string,substring)`	BASIC (positions start at 1)	returns 0
`index(string,substring)`	AWK	returns 0
`index(string,substring«,startpos»)`	Perl 5	returns −1
`index(string,substring«,startpos»)` `string.index(substring,«,startpos»)`	Raku	returns Nil
`instr(«startpos,»string,substring)`	FreeBASIC	returns 0
`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.indexOf(string, substring)`	D	returns −1
`pos(string, substring«, startpos»)`	Seed7	returns 0
`strings.Index(string, substring)`	Go	returns −1
`pos(substring, string)`	Pascal, Object Pascal (Delphi)	returns 0
`pos(substring, string«,startpos»)`	Rexx	returns 0
`string.find(substring«,startpos»)`	C++ (STL)	returns std::string::npos
`string.find(substring«,startpos«,endpos»»)`	Python	returns −1
`string.index(substring«,startpos«,endpos»»)`	Python	raises ValueError
`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, F#	returns −1
`string:str(string, substring)`	Erlang	returns 0
`(string-contains string substring)`	Scheme (SRFI 13)	returns #f
`(search substring string)`	Common Lisp	returns NIL
`(string-index substring string)`	ISLISP	returns `nil`
`List.findIndex (List.isPrefixOf substring) (List.tails string)`	Haskell (returns only index)	returns Nothing
`Str.search_forward (Str.regexp_string substring) string 0`	OCaml	raises Not_found
`Substring.size (#1 (Substring.position substring (Substring.full string)))`	Standard ML	returns string length
`[string rangeOfString:substring].location`	Objective-C (`NSString *` only)	returns NSNotFound
`string.find(string, substring)` `(string):find(substring)`	Lua	returns nil
`string indexOfSubCollection: substring startingAt: startpos ifAbsent: aBlock` `string findString: substring startingAt: startpos`	Smalltalk (Squeak, Pharo)	evaluate aBlock which is a block closure (or any object understanding value) returns 0
`startpos = INDEX(string, substring «,back» «, kind»)`	Fortran	returns 0 if substring is not in string; returns LEN(string)+1 if substring is empty
`POSITION(substring IN string)`	SQL	returns 0 (positions start at 1)
`index(string, substring, startpos )`	PL/I^[16]	returns 0 (positions start at 1)
`index(string, substring, occurrence )`	Pick Basic	returns 0 if occurrence of substring is not in string; (positions start at 1)
`string.indexOf(substring«,startpos«, charcount»»)`	Cobra	returns −1
`string first substring string startpos`	Tcl	returns −1
`(substring⍷string)⍳1`	APL	returns 1 + the last position in string
`string.find(substring)`	Rust^[17]	returns `None`

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 one 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
`char in string(char, pos, string[startpos:])`	ALGOL 68	returns BOOL: TRUE or FALSE, and position in REF INT pos.
`instr(string, any char«,startpos»)` (char, can contain more them one char, in which case the position of the first appearance of any of them is returned.)	FreeBASIC	returns 0
`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++ (STL)	returns std::string::npos
`pos(string, char«, startpos»)`	Seed7	returns 0
`strings.IndexRune(string,char)`	Go	returns −1
`string.indexOf(char«,startpos»)`	Java, JavaScript	returns −1
`string.IndexOf(char«,startpos«, charcount»»)`	VB .NET, C#, Windows PowerShell, F#	returns −1
`(position char string)`	Common Lisp	returns NIL
`(char-index char string)`	ISLISP	returns nil
`List.elemIndex char string`	Haskell (returns `Just index`)	returns Nothing
`String.index string char`	OCaml	raises Not_found
`position = SCAN (string, set «, back» «, kind»)` `position = VERIFY (string, set «, back» «, kind»)^[a]`	Fortran	returns zero
`string indexOf: char ifAbsent: aBlock` `string indexOf: char` `string includes: char`	Smalltalk	evaluate `aBlock` which is a `BlockClosure` (or any object understanding value) returns 0 returns `true` or `false`
`index(string, char, startpos )`	PL/I^[18]	returns 0 (positions start at 1)
`string.index(?char)`	Ruby	returns nil
`strpos(string,char,startpos)`	PHP	returns false
`string.indexOf(char«,startpos«, charcount»»)`	Cobra	returns −1
`string⍳char`	APL	returns 1 + the last position in string
`string.find(substring)`	Rust^[17]	returns None

Format	Languages	Format string syntax
`associate(file, string); putf(file, $formatstring$, items)`	ALGOL 68	ALGOL
`Format(item, formatstring)`	VB
`sprintf(formatstring, items)`	Perl, PHP, Raku, Ruby	C
`item.fmt(formatstring)`	Raku	C
`io_lib:format(formatstring, items)`	Erlang
`sprintf(outputstring, formatstring, items)`	C	C
`std::format(formatstring, items)`	C++ (C++20)	Python
`std.string.format(formatstring, items)`	D	C
`Format(formatstring, items)`	Object Pascal (Delphi)
`fmt.Sprintf(formatstring, items)`	Go	C
`printf formatstring items`	Unix	C
`formatstring % (items)`	Python, Ruby	C
`formatstring.format(items)`	Python	.NET
`fformatstring`	Python 3
`Printf.sprintf formatstring`^[21] `items`	OCaml, F#	C
`Text.Printf.printf formatstring items`	Haskell (GHC)	C
`formatstring printf: items`	Smalltalk	C
`String.format(formatstring, items)`	Java	C
`String.Format(formatstring, items)`	VB .NET, C#, F#	.NET
`(format formatstring items)`	Scheme (SRFI 28)	Lisp
`(format nil formatstring items)`	Common Lisp	Lisp
`(format formatstring items)`	Clojure	Lisp
`formatstring -f items`	Windows PowerShell	.NET
`[NSString stringWithFormat:formatstring, items]`	Objective-C (`NSString *` only)	C
`String(format:formatstring, items)`	Swift (Foundation)	C
`string.format(formatstring, items)` `(formatstring):format(items)`	Lua	C
`WRITE (outputstring, formatstring) items`	Fortran	Fortran
`put string(string) edit(items)(format)`	PL/I	PL/I (similar to Fortran)
`String.format(formatstring, items)`	Cobra	.NET
`format formatstring items`	Tcl	C
`formatnumbers ⍕ items` `formatstring ⎕FMT items`	APL	APL
`format!(formatstring, items)`	Rust^[22]	Python

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^[23]
`(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"}` `array_of_strings -join separator`	Windows PowerShell
`[array_of_strings componentsJoinedByString:separator]`	Objective-C (`NSString *` only)
`table.concat(table_of_strings, separator)`	Lua
`{\|String streamContents: [ :stream \| collectionOfAnything asStringOn: stream delimiter: separator ]` `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

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]`	Objective-C (`NSString *` only)
`(apply str (take n string))`	Clojure
`string[0 .. n]`	D^[24]
`string:substr(string, start, length)`	Erlang
`(subseq string 0 n)`	Common Lisp
`string[:n]`	Cobra, Go, Python
`left(string,n «,padchar»)`	Rexx, Erlang
`string[0, n]` `string[0..n - 1]`	Ruby
`string[1, n]`	Pick Basic
`string[ .. n]`	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,^[25] JavaScript
`(string-take string n)`	Scheme (SRFI 13)
`take n string`	Haskell
`String.extract (string, n, NONE)`	Standard ML
`String.sub string 0 n`	OCaml^[26]
`string.[..n]`	F#
`string.sub(string, 1, n)` `(string):sub(1, n)`	Lua
`string first: n`	Smalltalk (Squeak, Pharo)
`string(:n)`	Fortran
`StringTake[string, n]`	Mathematica^[27]
`string («FUNCTION» LENGTH(string) - n:n)`	COBOL
`string.substring(0, n)`	Cobra
`n↑string.`	APL
`string[0..n]` `string[..n]` `string.get(0..n)` `string.get(..n)`	Rust^[28]

Format	Returns	Languages
`string'Length`		Ada
`UPB string`		ALGOL 68
`echo "${#string_param}"`		Bash
`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^[29]	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)` `LEN_TRIM(string)`		Fortran
`StringLength[string]`		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^[30]
`string.chars().count()`	Number of Unicode code points	Rust^[31]

Definition	`format(formatstring, items)` returns string
Description	Returns the formatted string representation of one or more items.

Format	Languages
`string₁ ne string₂` `string₁ NE string₂`	ALGOL 68 – note: the operator "ne" is literally in bold type-font.
`string₁ /= string₂`	ALGOL 68, Ada, Erlang, Fortran, Haskell
`string₁ <> string₂`	BASIC, VB, VB .NET, Pascal, Object Pascal (Delphi), OCaml, PHP, Seed7, Standard ML, F#, COBOL, Cobra, Python 2 (deprecated)
`string₁ # string₂`	BASIC (some implementations)
`string₁ ne string₂`	Perl, Raku
`(string<> string₁ string₂)`	Scheme (SRFI 13)
`(string/= string₁ string₂)`	Common Lisp
`(string/= string₁ string₂)`	ISLISP
`(not= string₁ string₂)`	Clojure
`string₁ != string₂`	C++ (STL), C#, Go, JavaScript (not similar), PHP (not similar), Python, Ruby, Rust,^[10] Swift, D, Mathematica
`string₁ !== string₂`	JavaScript, PHP
`string₁ \= string₂`	Rexx
`string₁ ¬= string₂`	PL/I
`test string₁ != string₂` `[ string₁ != string₂ ]`	Bourne Shell
`string₁ -ne string₂` `-not [string]::Equals(string₁, string₂)`	Windows PowerShell
`string₁ ~= string₂`	Lua, Smalltalk
`string₁ ≢ string₂`	APL
`string₁.ne(string₂)`	Rust^[10]

Definition	`join(separator, list_of_strings)` returns a list of strings joined 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

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.

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.

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

Format	Languages
`LCase(string)`	VB
`lcase(string)`	FreeBASIC
`lc(string)`	Perl, Raku
`string.lc`	Raku
`tolower(char)`	C^[32]
`std.string.toLower(string)`	D
`transform(string.begin(), string.end(), result.begin(), ::tolower)`^[33]	C++^[34]
`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`	Ruby^[35]
`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^[8]
`ToLowerCase[string]`	Mathematica
`«FUNCTION» LOWER-CASE(string)`	COBOL
`string.toLower`	Cobra
`string tolower string`	Tcl
`string.to_lowercase()`	Rust^[36]

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

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

String_processing

Common string functions (multi language reference)

CharAt

Compare (integer result)

Compare (relational operator-based, Boolean result)

Concatenation

Contains

Equality

Find

Find character

Format

Inequality

index

indexof

instr

instrrev

join

lastindexof

left

len

length

locate

Lowercase

mid

partition

replace

reverse

rfind

right

rpartition

slice

split

sprintf

strip

strcmp

substring

Uppercase

trim

APL

AWK

C/C++

Haskell

J

JavaScript

Perl

Tcl

XSLT

References

Share this article:

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^[37]
`string.replaceAll(find_regex, replace)^[38]`	Java
`string.gsub(find, replace)`	Ruby
`string =~ s/find_regex/replace/g^[38]`	Perl 5
`string.subst(find, replace, :g)`	Raku
`string.replace(find, replace, "g") ^[39]` `string.replace(/find_regex/g, replace)^[38]`	JavaScript
`echo "string" \| sed 's/find_regex/replace/g'^[38]`	Unix
`${string_param//find_pattern/replace}`	Bash
`string.replace(find, replace)` `string -replace find_regex, replace^[38]`	Windows PowerShell
`Str.global_replace (Str.regexp_string find) replace string`	OCaml
`[string stringByReplacingOccurrencesOfString:find withString:replace]`	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]`	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

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

Format	Languages
`reverse string`	Perl 5, Haskell
`flip string` `string.flip`	Raku
`lists:reverse(string)`	Erlang
`strrev(string)`	PHP
`string[::-1]`	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]`	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::<String>()`	Rust^[40]
`echo string \| rev`	Unix

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
`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»»)`	Python	returns −1
`string.rindex(substring«,startpos«, endpos»»)`	Python	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:NSBackwardsSearch].location`	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^[41]	returns None

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)`	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[len(string)-n:]`	Go
`string.substring(string.length()-n)`	Java
`string.slice(-n)`	JavaScript^[42]
`right(string,n «,padchar»)`	Rexx, Erlang
`substr(string,-n)`	Perl 5, PHP
`substr(string,-n)` `string.substr(-n)`	Raku
`string[-n:]`	Cobra, Python
`${string_param: -n}` (note the space after the colon)	Bash
`string[n]`	Pick Basic
`(string-take-right string n)`	Scheme (SRFI 13)
`string[-n..-1]`	Ruby
`string[$-n .. $]`	D^[43]
`String.sub string (String.length string - n) n`	OCaml^[26]
`string.sub(string, -n)` `(string):sub(-n)`	Lua
`string last: n`	Smalltalk (Squeak, Pharo)
`StringTake[string, -n]`	Mathematica^[27]
`string (1:n)`	COBOL
`¯n↑string.`	APL
`string[n..]` `string.get(n..)`	Rust^[28]

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.

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

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]`	Objective-C (`NSString *` only)
`string.componentsSeparatedByString(separator)`	Swift (Foundation)
`TStringList.Delimiter, TStringList.DelimitedText`	Object Pascal
`StringSplit[string, separator«, limit»]`	Mathematica
`string.split«(sepchars«, limit«, options»»)»`	Cobra
`split string separator`	Tcl
`(separator≠string)⊂string` in APL2 `separator(≠⊆⊢)string` in Dyalog APL 16.0	APL
`string.split(separator)` `string.split(limit, separator)`	Rust^[44]