Comparison of programming languages (string functions)
- 40 min read
- 1 chapter
Related on Lably
Through Function (computer programming), String (computer science) and Data type
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 functions 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. String concatenation and regular expressions are handled in separate pages. Statements in guillemets (« … ») are optional.
CharAt
<span id="mwAYk"></span><span class="cm" id="mwAYo">{ Example in Pascal }</span> <span class="k" id="mwAYs">var</span> <span class="w" id="mwAYw"> </span><span class="n" id="mwAY0">MyStr</span><span class="o" id="mwAY4">:</span><span class="w" id="mwAY8"> </span><span class="k" id="mwAZA">string</span><span class="w" id="mwAZE"> </span><span class="o" id="mwAZI">=</span><span class="w" id="mwAZM"> </span><span class="s" id="mwAZQ">'Hello, World'</span><span class="o" id="mwAZU">;</span> <span class="w" id="mwAZY"> </span><span class="n" id="mwAZc">MyChar</span><span class="o" id="mwAZg">:</span><span class="w" id="mwAZk"> </span><span class="kt" id="mwAZo">Char</span><span class="o" id="mwAZs">;</span> <span class="k" id="mwAZw">begin</span> <span class="w" id="mwAZ0"> </span><span class="n" id="mwAZ4">MyChar</span><span class="w" id="mwAZ8"> </span><span class="o" id="mwAaA">:=</span><span class="w" id="mwAaE"> </span><span class="n" id="mwAaI">MyStr</span><span class="p" id="mwAaM">[</span><span class="mi" id="mwAaQ">2</span><span class="p" id="mwAaU">]</span><span class="o" id="mwAaY">;</span><span class="w" id="mwAac"> </span><span class="c1" id="mwAag">// 'e'</span># Example in ALGOL 68 # "Hello, World"[2]; // 'e'
<span id="mwAaw"></span><span class="c1" id="mwAa0">// Example in C</span> <span class="cp" id="mwAa4">#include</span><span class="w" id="mwAa8"> </span><span class="cpf" id="mwAbA"><stdio.h></span> <span class="kt" id="mwAbE">char</span><span class="w" id="mwAbI"> </span><span class="n" id="mwAbM">myStr1</span><span class="p" id="mwAbQ">[]</span><span class="w" id="mwAbU"> </span><span class="o" id="mwAbY">=</span><span class="w" id="mwAbc"> </span><span class="s" id="mwAbg">"Hello, World"</span><span class="p" id="mwAbk">;</span> <span class="n" id="mwAbo">printf</span><span class="p" id="mwAbs">(</span><span class="s" id="mwAbw">"%c"</span><span class="p" id="mwAb0">,</span><span class="w" id="mwAb4"> </span><span class="o" id="mwAb8">*</span><span class="p" id="mwAcA">(</span><span class="n" id="mwAcE">myStr1</span><span class="w" id="mwAcI"> </span><span class="o" id="mwAcM">+</span><span class="w" id="mwAcQ"> </span><span class="mi" id="mwAcU">1</span><span class="p" id="mwAcY">));</span><span class="w" id="mwAcc"> </span><span class="c1" id="mwAcg">// 'e'</span> <span class="n" id="mwAck">printf</span><span class="p" id="mwAco">(</span><span class="s" id="mwAcs">"%c"</span><span class="p" id="mwAcw">,</span><span class="w" id="mwAc0"> </span><span class="o" id="mwAc4">*</span><span class="p" id="mwAc8">(</span><span class="n" id="mwAdA">myStr1</span><span class="w" id="mwAdE"> </span><span class="o" id="mwAdI">+</span><span class="w" id="mwAdM"> </span><span class="mi" id="mwAdQ">7</span><span class="p" id="mwAdU">));</span><span class="w" id="mwAdY"> </span><span class="c1" id="mwAdc">// 'W'</span> <span class="n" id="mwAdg">printf</span><span class="p" id="mwAdk">(</span><span class="s" id="mwAdo">"%c"</span><span class="p" id="mwAds">,</span><span class="w" id="mwAdw"> </span><span class="n" id="mwAd0">myStr1</span><span class="p" id="mwAd4">[</span><span class="mi" id="mwAd8">11</span><span class="p" id="mwAeA">]);</span><span class="w" id="mwAeE"> </span><span class="c1" id="mwAeI">// 'd'</span> <span class="n" id="mwAeM">printf</span><span class="p" id="mwAeQ">(</span><span class="s" id="mwAeU">"%s"</span><span class="p" id="mwAeY">,</span><span class="w" id="mwAec"> </span><span class="n" id="mwAeg">myStr1</span><span class="p" id="mwAek">);</span><span class="w" id="mwAeo"> </span><span class="c1" id="mwAes">// 'Hello, World'</span> <span class="n" id="mwAew">printf</span><span class="p" id="mwAe0">(</span><span class="s" id="mwAe4">"%s"</span><span class="p" id="mwAe8">,</span><span class="w" id="mwAfA"> </span><span class="s" id="mwAfE">"Hello(2), World(2)"</span><span class="p" id="mwAfI">);</span><span class="w" id="mwAfM"> </span><span class="c1" id="mwAfQ">// 'Hello(2), World(2)'</span>
<span id="mwAfc"></span><span class="k" id="mwAfg">import</span><span class="w" id="mwAfk"> </span><span class="n" id="mwAfo">std</span><span class="p" id="mwAfs">;</span> <span class="k" id="mwAfw">using</span><span class="w" id="mwAf0"> </span><span class="n" id="mwAf4">std</span><span class="o" id="mwAf8">::</span><span class="n" id="mwAgA">string</span><span class="p" id="mwAgE">;</span> <span class="kt" id="mwAgI">char</span><span class="w" id="mwAgM"> </span><span class="n" id="mwAgQ">myStr1</span><span class="p" id="mwAgU">[]</span><span class="w" id="mwAgY"> </span><span class="o" id="mwAgc">=</span><span class="w" id="mwAgg"> </span><span class="s" id="mwAgk">"Hello(1), World(1)"</span><span class="p" id="mwAgo">;</span> <span class="n" id="mwAgs">string</span><span class="w" id="mwAgw"> </span><span class="n" id="mwAg0">myStr2</span><span class="w" id="mwAg4"> </span><span class="o" id="mwAg8">=</span><span class="w" id="mwAhA"> </span><span class="s" id="mwAhE">"Hello(2), World(2)"</span><span class="p" id="mwAhI">;</span> <span class="n" id="mwAhM">std</span><span class="o" id="mwAhQ">::</span><span class="n" id="mwAhU">println</span><span class="p" id="mwAhY">(</span><span class="s" id="mwAhc">"Hello(3), World(3)"</span><span class="p" id="mwAhg">);</span><span class="w" id="mwAhk"> </span><span class="c1" id="mwAho">// 'Hello(3), World(3)'</span> <span class="n" id="mwAhs">std</span><span class="o" id="mwAhw">::</span><span class="n" id="mwAh0">println</span><span class="p" id="mwAh4">(</span><span class="s" id="mwAh8">"{}"</span><span class="p" id="mwAiA">,</span><span class="w" id="mwAiE"> </span><span class="n" id="mwAiI">myStr2</span><span class="p" id="mwAiM">[</span><span class="mi" id="mwAiQ">6</span><span class="p" id="mwAiU">]);</span><span class="w" id="mwAiY"> </span><span class="c1" id="mwAic">// '2'</span> <span class="n" id="mwAig">std</span><span class="o" id="mwAik">::</span><span class="n" id="mwAio">println</span><span class="p" id="mwAis">(</span><span class="s" id="mwAiw">"{}"</span><span class="p" id="mwAi0">,</span><span class="w" id="mwAi4"> </span><span class="n" id="mwAi8">myStr1</span><span class="p" id="mwAjA">.</span><span class="n" id="mwAjE">substr</span><span class="p" id="mwAjI">(</span><span class="mi" id="mwAjM">5</span><span class="p" id="mwAjQ">,</span><span class="w" id="mwAjU"> </span><span class="mi" id="mwAjY">3</span><span class="p" id="mwAjc">));</span><span class="w" id="mwAjg"> </span><span class="c1" id="mwAjk">// '(1)'</span><span id="mwAjw"></span><span class="c1" id="mwAj0">// Example in C#</span> <span class="s" id="mwAj4">"Hello, World"</span><span class="p" id="mwAj8">[</span><span class="mi" id="mwAkA">2</span><span class="p" id="mwAkE">];</span><span class="w" id="mwAkI"> </span><span class="c1" id="mwAkM">// 'l'</span>
<span id="mwAkY"></span><span class="c1" id="mwAkc"># Example in Perl 5</span> <span class="nb" id="mwAkg">substr</span><span class="p" id="mwAkk">(</span><span class="s" id="mwAko">"Hello, World"</span><span class="p" id="mwAks">,</span><span class="w" id="mwAkw"> </span><span class="mi" id="mwAk0">1</span><span class="p" id="mwAk4">,</span><span class="w" id="mwAk8"> </span><span class="mi" id="mwAlA">1</span><span class="p" id="mwAlE">);</span><span class="w" id="mwAlI"> </span><span class="c1" id="mwAlM"># 'e'</span>
<span id="mwAlY"></span><span class="c1" id="mwAlc"># Examples in Python</span> <span class="s2" id="mwAlg">"Hello, World"</span><span class="p" id="mwAlk">[</span><span class="mi" id="mwAlo">2</span><span class="p" id="mwAls">]</span> <span class="c1" id="mwAlw"># 'l'</span> <span class="s2" id="mwAl0">"Hello, World"</span><span class="p" id="mwAl4">[</span><span class="o" id="mwAl8">-</span><span class="mi" id="mwAmA">3</span><span class="p" id="mwAmE">]</span> <span class="c1" id="mwAmI"># 'r'</span>
<span id="mwAmU"></span><span class="c1" id="mwAmY"># Example in Raku</span> <span class="s" id="mwAmc">"Hello, World"</span>.<span class="nb" id="mwAmg">substr</span>(<span class="mi" id="mwAmk">1</span>, <span class="mi" id="mwAmo">1</span>); <span class="c1" id="mwAms"># 'e'</span>
<span id="mwAm4"></span><span class="c" id="mwAm8">' Example in Visual Basic</span> <span class="n" id="mwAnA">Mid</span><span class="p" id="mwAnE">(</span><span class="s" id="mwAnI">"Hello, World"</span><span class="p" id="mwAnM">,</span><span class="mi" id="mwAnQ">2</span><span class="p" id="mwAnU">,</span><span class="mi" id="mwAnY">1</span><span class="p" id="mwAnc">)</span>
<span id="mwAno"></span><span class="c" id="mwAns">' Example in Visual Basic .NET</span> <span class="s" id="mwAnw">"Hello, World"</span><span class="p" id="mwAn0">.</span><span class="n" id="mwAn4">Chars</span><span class="p" id="mwAn8">(</span><span class="mi" id="mwAoA">2</span><span class="p" id="mwAoE">)</span><span class="w" id="mwAoI"> </span><span class="c" id="mwAoM">' "l"c</span>
<span id="mwAoY"></span><span class="c" id="mwAoc">" Example in Smalltalk "</span> <span class="s" id="mwAog">'Hello, World'</span> <span class="nf" id="mwAok">at:</span> <span class="m" id="mwAoo">2</span><span class="p" id="mwAos">.</span> <span class="c" id="mwAow">"$e"</span>
<span id="mwAo8"></span><span class="c1" id="mwApA">//Example in Rust</span> <span class="s" id="mwApE">"Hello, World"</span><span class="p" id="mwApI">.</span><span class="n" id="mwApM">chars</span><span class="p" id="mwApQ">().</span><span class="n" id="mwApU">nth</span><span class="p" id="mwApY">(</span><span class="mi" id="mwApc">2</span><span class="p" id="mwApg">);</span><span class="w" id="mwApk"> </span><span class="c1" id="mwApo">// Some('l')</span>Compare (integer result)
<span id="mwBBg"></span><span class="c1" id="mwBBk"># Example in Perl 5</span> <span class="s" id="mwBBo">"hello"</span><span class="w" id="mwBBs"> </span><span class="ow" id="mwBBw">cmp</span><span class="w" id="mwBB0"> </span><span class="s" id="mwBB4">"world"</span><span class="p" id="mwBB8">;</span><span class="w" id="mwBCA"> </span><span class="c1" id="mwBCE"># returns -1</span>
<span id="mwBCQ"></span><span class="c1" id="mwBCU"># Example in Python</span> <span class="n" id="mwBCY">cmp</span><span class="p" id="mwBCc">(</span><span class="s2" id="mwBCg">"hello"</span><span class="p" id="mwBCk">,</span> <span class="s2" id="mwBCo">"world"</span><span class="p" id="mwBCs">)</span> <span class="c1" id="mwBCw"># returns -1</span>
<span id="mwBC8"></span><span class="c1" id="mwBDA"># Examples in Raku</span> <span class="s" id="mwBDE">"hello"</span> <span class="o" id="mwBDI">cmp</span> <span class="s" id="mwBDM">"world"</span>; <span class="c1" id="mwBDQ"># returns Less</span> <span class="s" id="mwBDU">"world"</span> <span class="o" id="mwBDY">cmp</span> <span class="s" id="mwBDc">"hello"</span>; <span class="c1" id="mwBDg"># returns More</span> <span class="s" id="mwBDk">"hello"</span> <span class="o" id="mwBDo">cmp</span> <span class="s" id="mwBDs">"hello"</span>; <span class="c1" id="mwBDw"># returns Same</span>
<span id="mwBD8"></span><span class="cm" id="mwBEA">/** Example in Rexx */</span> <span class="nb" id="mwBEE">compare</span><span class="o" id="mwBEI">(</span><span class="s" id="mwBEM">"hello"</span><span class="o" id="mwBEQ">,</span><span class="w" id="mwBEU"> </span><span class="s" id="mwBEY">"world"</span><span class="o" id="mwBEc">)</span><span class="w" id="mwBEg"> </span><span class="cm" id="mwBEk">/* returns index of mismatch: 1 */</span>
<span id="mwBEw"></span><span class="c1" id="mwBE0">; Example in Scheme</span> <span class="p" id="mwBE4">(</span><span class="k" id="mwBE8">use-modules</span><span class="w" id="mwBFA"> </span><span class="p" id="mwBFE">(</span><span class="nf" id="mwBFI">srfi</span><span class="w" id="mwBFM"> </span><span class="nv" id="mwBFQ">srfi-13</span><span class="p" id="mwBFU">))</span> <span class="c1" id="mwBFY">; returns index of mismatch: 0</span> <span class="p" id="mwBFc">(</span><span class="nb" id="mwBFg">string-compare</span><span class="w" id="mwBFk"> </span><span class="s" id="mwBFo">"hello"</span><span class="w" id="mwBFs"> </span><span class="s" id="mwBFw">"world"</span><span class="w" id="mwBF0"> </span><span class="nb" id="mwBF4">values</span><span class="w" id="mwBF8"> </span><span class="nb" id="mwBGA">values</span><span class="w" id="mwBGE"> </span><span class="nb" id="mwBGI">values</span><span class="p" id="mwBGM">)</span>
Compare (relational operator-based, Boolean result)
<span id="mwBdM"></span><span class="c" id="mwBdQ">% Example in Erlang</span> <span class="s" id="mwBdU">"hello"</span><span class="w" id="mwBdY"> </span><span class="o" id="mwBdc">></span><span class="w" id="mwBdg"> </span><span class="s" id="mwBdk">"world"</span><span class="p" id="mwBdo">.</span><span class="w" id="mwBds"> </span><span class="c" id="mwBdw">% returns false</span>
<span id="mwBd8"></span><span class="c1" id="mwBeA"># Example in Raku</span> <span class="s" id="mwBeE">"art"</span> <span class="o" id="mwBeI">gt</span> <span class="s" id="mwBeM">"painting"</span>; <span class="c1" id="mwBeQ"># returns False</span> <span class="s" id="mwBeU">"art"</span> <span class="o" id="mwBeY">lt</span> <span class="s" id="mwBec">"painting"</span>; <span class="c1" id="mwBeg"># returns True</span>
<span id="mwBes"></span><span class="c" id="mwBew"># Example in Windows PowerShell</span> <span class="s2" id="mwBe0">"hello"</span> <span class="o" id="mwBe4">-gt</span> <span class="s2" id="mwBe8">"world"</span> <span class="c" id="mwBfA"># returns false</span>
<span id="mwBfM"></span><span class="c1" id="mwBfQ">;; Example in Common Lisp</span> <span class="p" id="mwBfU">(</span><span class="nb" id="mwBfY">string></span><span class="w" id="mwBfc"> </span><span class="s" id="mwBfg">"art"</span><span class="w" id="mwBfk"> </span><span class="s" id="mwBfo">"painting"</span><span class="p" id="mwBfs">)</span><span class="w" id="mwBfw"> </span><span class="c1" id="mwBf0">; returns nil</span> <span class="p" id="mwBf4">(</span><span class="nb" id="mwBf8">string<</span><span class="w" id="mwBgA"> </span><span class="s" id="mwBgE">"art"</span><span class="w" id="mwBgI"> </span><span class="s" id="mwBgM">"painting"</span><span class="p" id="mwBgQ">)</span><span class="w" id="mwBgU"> </span><span class="c1" id="mwBgY">; returns non nil</span>
Concatenation
<span id="mwBxo"></span><span class="cm" id="mwBxs">{ Example in Pascal }</span> <span class="s" id="mwBxw">'abc'</span><span class="w" id="mwBx0"> </span><span class="o" id="mwBx4">+</span><span class="w" id="mwBx8"> </span><span class="s" id="mwByA">'def'</span><span class="o" id="mwByE">;</span><span class="w" id="mwByI"> </span><span class="c1" id="mwByM">// returns "abcdef"</span><span id="mwByY"></span><span class="c1" id="mwByc">// Example in C#</span> <span class="s" id="mwByg">"abc"</span><span class="w" id="mwByk"> </span><span class="o" id="mwByo">+</span><span class="w" id="mwBys"> </span><span class="s" id="mwByw">"def"</span><span class="p" id="mwBy0">;</span><span class="w" id="mwBy4"> </span><span class="c1" id="mwBy8">// returns "abcdef"</span>
<span id="mwBzI"></span><span class="c" id="mwBzM">' Example in Visual Basic</span> <span class="s" id="mwBzQ">"abc"</span><span class="w" id="mwBzU"> </span><span class="o" id="mwBzY">&</span><span class="w" id="mwBzc"> </span><span class="s" id="mwBzg">"def"</span><span class="w" id="mwBzk"> </span><span class="c" id="mwBzo">' returns "abcdef"</span> <span class="s" id="mwBzs">"abc"</span><span class="w" id="mwBzw"> </span><span class="o" id="mwBz0">+</span><span class="w" id="mwBz4"> </span><span class="s" id="mwBz8">"def"</span><span class="w" id="mwB0A"> </span><span class="c" id="mwB0E">' returns "abcdef"</span> <span class="s" id="mwB0I">"abc"</span><span class="w" id="mwB0M"> </span><span class="o" id="mwB0Q">&</span><span class="w" id="mwB0U"> </span><span class="n" id="mwB0Y">Null</span><span class="w" id="mwB0c"> </span><span class="c" id="mwB0g">' returns "abc"</span> <span class="s" id="mwB0k">"abc"</span><span class="w" id="mwB0o"> </span><span class="o" id="mwB0s">+</span><span class="w" id="mwB0w"> </span><span class="n" id="mwB00">Null</span><span class="w" id="mwB04"> </span><span class="c" id="mwB08">' returns Null</span>
<span id="mwB1I"></span><span class="c1" id="mwB1M">// Example in D</span> <span class="s" id="mwB1Q">"abc"</span><span class="w" id="mwB1U"> </span><span class="p" id="mwB1Y">~</span><span class="w" id="mwB1c"> </span><span class="s" id="mwB1g">"def"</span><span class="p" id="mwB1k">;</span><span class="w" id="mwB1o"> </span><span class="c1" id="mwB1s">// returns "abcdef"</span>
<span id="mwB14"></span><span class="c1" id="mwB18">;; Example in common lisp</span> <span class="p" id="mwB2A">(</span><span class="nb" id="mwB2E">concatenate</span><span class="w" id="mwB2I"> </span><span class="ss" id="mwB2M">'string</span><span class="w" id="mwB2Q"> </span><span class="s" id="mwB2U">"abc "</span><span class="w" id="mwB2Y"> </span><span class="s" id="mwB2c">"def "</span><span class="w" id="mwB2g"> </span><span class="s" id="mwB2k">"ghi"</span><span class="p" id="mwB2o">)</span><span class="w" id="mwB2s"> </span><span class="c1" id="mwB2w">; returns "abc def ghi"</span>
<span id="mwB28"></span><span class="c1" id="mwB3A"># Example in Perl 5</span> <span class="s" id="mwB3E">"abc"</span><span class="w" id="mwB3I"> </span><span class="o" id="mwB3M">.</span><span class="w" id="mwB3Q"> </span><span class="s" id="mwB3U">"def"</span><span class="p" id="mwB3Y">;</span><span class="w" id="mwB3c"> </span><span class="c1" id="mwB3g"># returns "abcdef"</span> <span class="s" id="mwB3k">"Perl "</span><span class="w" id="mwB3o"> </span><span class="o" id="mwB3s">.</span><span class="w" id="mwB3w"> </span><span class="mi" id="mwB30">5</span><span class="p" id="mwB34">;</span><span class="w" id="mwB38"> </span><span class="c1" id="mwB4A"># returns "Perl 5"</span>
<span id="mwB4M"></span><span class="cm" id="mwB4Q">/* Example in PL/I */</span> <span class="s" id="mwB4U">"abc"</span><span class="w" id="mwB4Y"> </span><span class="o" id="mwB4c">||</span><span class="w" id="mwB4g"> </span><span class="s" id="mwB4k">"def"</span><span class="w" id="mwB4o"> </span><span class="cm" id="mwB4s">/* returns "abcdef" */</span>
<span id="mwB44"></span><span class="c1" id="mwB48"># Example in Raku</span> <span class="s" id="mwB5A">"abc"</span> ~ <span class="s" id="mwB5E">"def"</span>; <span class="c1" id="mwB5I"># returns "abcdef"</span> <span class="s" id="mwB5M">"Perl "</span> ~ <span class="mi" id="mwB5Q">6</span>; <span class="c1" id="mwB5U"># returns "Perl 6"</span>
<span id="mwB5g"></span><span class="cm" id="mwB5k">/* Example in Rexx */</span> <span class="s" id="mwB5o">"Strike"</span><span class="m" id="mwB5s">2</span><span class="w" id="mwB5w"> </span><span class="cm" id="mwB50">/* returns "Strike2" */</span> <span class="s" id="mwB54">"Strike"</span><span class="w" id="mwB58"> </span><span class="m" id="mwB6A">2</span><span class="w" id="mwB6E"> </span><span class="cm" id="mwB6I">/* returns "Strike 2" */</span>
Contains
¢ Example in <a rel="mw:WikiLink" href="./ALGOL_68" title="ALGOL 68" id="mwCKQ">ALGOL 68</a> ¢ string in string("e", <b id="mwCKU">loc int</b>, "Hello mate"); ¢ returns <b id="mwCKY">true</b> ¢ string in string("z", <b id="mwCKc">loc int</b>, "word"); ¢ returns <b id="mwCKg">false</b> ¢<span id="mwCKs"></span><span class="c1" id="mwCKw">// Example In C#</span> <span class="s" id="mwCK0">"Hello mate"</span><span class="p" id="mwCK4">.</span><span class="n" id="mwCK8">Contains</span><span class="p" id="mwCLA">(</span><span class="s" id="mwCLE">"e"</span><span class="p" id="mwCLI">);</span><span class="w" id="mwCLM"> </span><span class="c1" id="mwCLQ">// returns true</span> <span class="s" id="mwCLU">"word"</span><span class="p" id="mwCLY">.</span><span class="n" id="mwCLc">Contains</span><span class="p" id="mwCLg">(</span><span class="s" id="mwCLk">"z"</span><span class="p" id="mwCLo">);</span><span class="w" id="mwCLs"> </span><span class="c1" id="mwCLw">// returns false</span>
<span id="mwCL8"></span><span class="c1" id="mwCMA"># Example in Python</span> <span class="s2" id="mwCME">"e"</span> <span class="ow" id="mwCMI">in</span> <span class="s2" id="mwCMM">"Hello mate"</span> <span class="c1" id="mwCMQ"># returns true</span> <span class="s2" id="mwCMU">"z"</span> <span class="ow" id="mwCMY">in</span> <span class="s2" id="mwCMc">"word"</span> <span class="c1" id="mwCMg"># returns false</span>
<span id="mwCMs"></span><span class="c1" id="mwCMw"># Example in Raku</span> <span class="s" id="mwCM0">"Good morning!"</span>.<span class="nb" id="mwCM4">contains</span>(<span class="s" id="mwCM8">'z'</span>) <span class="c1" id="mwCNA"># returns False</span> <span class="s" id="mwCNE">"¡Buenos días!"</span>.<span class="nb" id="mwCNI">contains</span>(<span class="s" id="mwCNM">'í'</span>); <span class="c1" id="mwCNQ"># returns True</span>
<span id="mwCNc"></span><span class="c" id="mwCNg">" Example in Smalltalk "</span> <span class="s" id="mwCNk">'Hello mate'</span> <span class="nf" id="mwCNo">includesSubstring:</span> <span class="s" id="mwCNs">'e'</span> <span class="c" id="mwCNw">" returns true "</span> <span class="err" id="mwCN0">'</span><span class="nf" id="mwCN4">word</span><span class="err" id="mwCN8">'</span> <span class="nf" id="mwCOA">includesSubstring:</span> <span class="s" id="mwCOE">'z'</span> <span class="c" id="mwCOI">" returns false "</span>
Equality
Tests if two strings are equal. See also #Compare and #Compare. 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".
<span id="mwCbo"></span><span class="c1" id="mwCbs">// Example in C#</span> <span class="s" id="mwCbw">"hello"</span><span class="w" id="mwCb0"> </span><span class="o" id="mwCb4">==</span><span class="w" id="mwCb8"> </span><span class="s" id="mwCcA">"world"</span><span class="w" id="mwCcE"> </span><span class="c1" id="mwCcI">// returns false</span>
<span id="mwCcU"></span><span class="c" id="mwCcY">' Example in Visual Basic</span> <span class="s" id="mwCcc">"hello"</span><span class="w" id="mwCcg"> </span><span class="o" id="mwCck">=</span><span class="w" id="mwCco"> </span><span class="s" id="mwCcs">"world"</span><span class="w" id="mwCcw"> </span><span class="c" id="mwCc0">' returns false</span>
<span id="mwCdA"></span><span class="c1" id="mwCdE"># Examples in Perl 5</span> <span class="s" id="mwCdI">'hello'</span><span class="w" id="mwCdM"> </span><span class="ow" id="mwCdQ">eq</span><span class="w" id="mwCdU"> </span><span class="s" id="mwCdY">'world'</span><span class="w" id="mwCdc"> </span><span class="c1" id="mwCdg"># returns 0</span> <span class="s" id="mwCdk">'hello'</span><span class="w" id="mwCdo"> </span><span class="ow" id="mwCds">eq</span><span class="w" id="mwCdw"> </span><span class="s" id="mwCd0">'hello'</span><span class="w" id="mwCd4"> </span><span class="c1" id="mwCd8"># returns 1</span>
<span id="mwCeI"></span><span class="c1" id="mwCeM"># Examples in Raku</span> <span class="s" id="mwCeQ">'hello'</span> <span class="o" id="mwCeU">eq</span> <span class="s" id="mwCeY">'world'</span> <span class="c1" id="mwCec"># returns False</span> <span class="s" id="mwCeg">'hello'</span> <span class="o" id="mwCek">eq</span> <span class="s" id="mwCeo">'hello'</span> <span class="c1" id="mwCes"># returns True</span>
<span id="mwCe4"></span><span class="c" id="mwCe8"># Example in Windows PowerShell</span> <span class="s2" id="mwCfA">"hello"</span> <span class="o" id="mwCfE">-eq</span> <span class="s2" id="mwCfI">"world"</span> <span class="c" id="mwCfM"># returns false</span>
<span id="mwCfY"></span><span class="c1" id="mwCfc">⍝ Example in APL</span> <span class="s1" id="mwCfg">'hello'</span><span class="w" id="mwCfk"> </span><span class="o" id="mwCfo">≡</span><span class="w" id="mwCfs"> </span><span class="s1" id="mwCfw">'world'</span><span class="w" id="mwCf0"> </span><span class="c1" id="mwCf4">⍝ returns 0</span>
Find
Examples
- Common Lisp
<span id="mwC5Y"></span><span class="p" id="mwC5c">(</span><span class="nb" id="mwC5g">search</span><span class="w" id="mwC5k"> </span><span class="s" id="mwC5o">"e"</span><span class="w" id="mwC5s"> </span><span class="s" id="mwC5w">"Hello mate"</span><span class="p" id="mwC50">)</span><span class="w" id="mwC54"> </span><span class="c1" id="mwC58">; returns 1</span> <span class="p" id="mwC6A">(</span><span class="nb" id="mwC6E">search</span><span class="w" id="mwC6I"> </span><span class="s" id="mwC6M">"z"</span><span class="w" id="mwC6Q"> </span><span class="s" id="mwC6U">"word"</span><span class="p" id="mwC6Y">)</span><span class="w" id="mwC6c"> </span><span class="c1" id="mwC6g">; returns NIL</span>
- C#
<span id="mwC64"></span><span class="s" id="mwC68">"Hello mate"</span><span class="p" id="mwC7A">.</span><span class="n" id="mwC7E">IndexOf</span><span class="p" id="mwC7I">(</span><span class="s" id="mwC7M">"e"</span><span class="p" id="mwC7Q">);</span><span class="w" id="mwC7U"> </span><span class="c1" id="mwC7Y">// returns 1</span> <span class="s" id="mwC7c">"Hello mate"</span><span class="p" id="mwC7g">.</span><span class="n" id="mwC7k">IndexOf</span><span class="p" id="mwC7o">(</span><span class="s" id="mwC7s">"e"</span><span class="p" id="mwC7w">,</span><span class="w" id="mwC70"> </span><span class="mi" id="mwC74">4</span><span class="p" id="mwC78">);</span><span class="w" id="mwC8A"> </span><span class="c1" id="mwC8E">// returns 9</span> <span class="s" id="mwC8I">"word"</span><span class="p" id="mwC8M">.</span><span class="n" id="mwC8Q">IndexOf</span><span class="p" id="mwC8U">(</span><span class="s" id="mwC8Y">"z"</span><span class="p" id="mwC8c">);</span><span class="w" id="mwC8g"> </span><span class="c1" id="mwC8k">// returns -1</span>
- Raku
<span id="mwC88"></span><span class="s" id="mwC9A">"Hello, there!"</span>.<span class="nb" id="mwC9E">index</span>(<span class="s" id="mwC9I">'e'</span>) <span class="c1" id="mwC9M"># returns 1</span> <span class="s" id="mwC9Q">"Hello, there!"</span>.<span class="nb" id="mwC9U">index</span>(<span class="s" id="mwC9Y">'z'</span>) <span class="c1" id="mwC9c"># returns Nil</span>
- Scheme
<span id="mwC90"></span><span class="p" id="mwC94">(</span><span class="k" id="mwC98">use-modules</span><span class="w" id="mwC-A"> </span><span class="p" id="mwC-E">(</span><span class="nf" id="mwC-I">srfi</span><span class="w" id="mwC-M"> </span><span class="nv" id="mwC-Q">srfi-13</span><span class="p" id="mwC-U">))</span> <span class="p" id="mwC-Y">(</span><span class="nb" id="mwC-c">string-contains</span><span class="w" id="mwC-g"> </span><span class="s" id="mwC-k">"Hello mate"</span><span class="w" id="mwC-o"> </span><span class="s" id="mwC-s">"e"</span><span class="p" id="mwC-w">)</span><span class="w" id="mwC-0"> </span><span class="c1" id="mwC-4">; returns 1</span> <span class="p" id="mwC-8">(</span><span class="nb" id="mwC_A">string-contains</span><span class="w" id="mwC_E"> </span><span class="s" id="mwC_I">"word"</span><span class="w" id="mwC_M"> </span><span class="s" id="mwC_Q">"z"</span><span class="p" id="mwC_U">)</span><span class="w" id="mwC_Y"> </span><span class="c1" id="mwC_c">; returns #f</span>
- Visual Basic
<span id="mwC_0"></span><span class="c" id="mwC_4">' Examples in</span> <span class="n" id="mwC_8">InStr</span><span class="p" id="mwDAA">(</span><span class="s" id="mwDAE">"Hello mate"</span><span class="p" id="mwDAI">,</span><span class="w" id="mwDAM"> </span><span class="s" id="mwDAQ">"e"</span><span class="p" id="mwDAU">)</span><span class="w" id="mwDAY"> </span><span class="c" id="mwDAc">' returns 2</span> <span class="n" id="mwDAg">InStr</span><span class="p" id="mwDAk">(</span><span class="mi" id="mwDAo">5</span><span class="p" id="mwDAs">,</span><span class="w" id="mwDAw"> </span><span class="s" id="mwDA0">"Hello mate"</span><span class="p" id="mwDA4">,</span><span class="w" id="mwDA8"> </span><span class="s" id="mwDBA">"e"</span><span class="p" id="mwDBE">)</span><span class="w" id="mwDBI"> </span><span class="c" id="mwDBM">' returns 10</span> <span class="n" id="mwDBQ">InStr</span><span class="p" id="mwDBU">(</span><span class="s" id="mwDBY">"word"</span><span class="p" id="mwDBc">,</span><span class="w" id="mwDBg"> </span><span class="s" id="mwDBk">"z"</span><span class="p" id="mwDBo">)</span><span class="w" id="mwDBs"> </span><span class="c" id="mwDBw">' returns 0</span>
- Smalltalk
<span id="mwDCI"></span><span class="s" id="mwDCM">'Hello mate'</span> <span class="nf" id="mwDCQ">indexOfSubCollection:</span><span class="s" id="mwDCU">'ate'</span> <span class="c" id="mwDCY">"returns 8"</span>
<span id="mwDCo"></span><span class="s" id="mwDCs">'Hello mate'</span> <span class="nf" id="mwDCw">indexOfSubCollection:</span><span class="s" id="mwDC0">'late'</span> <span class="c" id="mwDC4">"returns 0"</span>
<span id="mwDDI"></span><span class="nc" id="mwDDM">I</span><span class="err" id="mwDDQ">'</span><span class="nf" id="mwDDU">Hello</span> <span class="nf" id="mwDDY">mate</span><span class="err" id="mwDDc">'</span> <span class="nf" id="mwDDg">indexOfSubCollection:</span><span class="s" id="mwDDk">'late'</span> <span class="nf" id="mwDDo">ifAbsent:</span>[ <span class="m" id="mwDDs">99</span> ] <span class="c" id="mwDDw">"returns 99"</span>
<span id="mwDEA"></span><span class="s" id="mwDEE">'Hello mate'</span> <span class="nf" id="mwDEI">indexOfSubCollection:</span><span class="s" id="mwDEM">'late'</span> <span class="nf" id="mwDEQ">ifAbsent:</span>[ <span class="bp" id="mwDEU">self</span> <span class="nf" id="mwDEY">error</span> ] <span class="c" id="mwDEc">"raises an exception"</span>
Find character
<span id="mwDVk"></span><span class="c1" id="mwDVo">// Examples in C#</span> <span class="s" id="mwDVs">"Hello mate"</span><span class="p" id="mwDVw">.</span><span class="n" id="mwDV0">IndexOf</span><span class="p" id="mwDV4">(</span><span class="sc" id="mwDV8">'e'</span><span class="p" id="mwDWA">);</span><span class="w" id="mwDWE"> </span><span class="c1" id="mwDWI">// returns 1</span> <span class="s" id="mwDWM">"word"</span><span class="p" id="mwDWQ">.</span><span class="n" id="mwDWU">IndexOf</span><span class="p" id="mwDWY">(</span><span class="sc" id="mwDWc">'z'</span><span class="p" id="mwDWg">)</span><span class="w" id="mwDWk"> </span><span class="c1" id="mwDWo">// returns -1</span>
<span id="mwDW0"></span><span class="c1" id="mwDW4">; Examples in Common Lisp</span> <span class="p" id="mwDW8">(</span><span class="nb" id="mwDXA">position</span><span class="w" id="mwDXE"> </span><span class="sc" id="mwDXI">#\e</span><span class="w" id="mwDXM"> </span><span class="s" id="mwDXQ">"Hello mate"</span><span class="p" id="mwDXU">)</span><span class="w" id="mwDXY"> </span><span class="c1" id="mwDXc">; returns 1</span> <span class="p" id="mwDXg">(</span><span class="nb" id="mwDXk">position</span><span class="w" id="mwDXo"> </span><span class="sc" id="mwDXs">#\z</span><span class="w" id="mwDXw"> </span><span class="s" id="mwDX0">"word"</span><span class="p" id="mwDX4">)</span><span class="w" id="mwDX8"> </span><span class="c1" id="mwDYA">; returns NIL</span>
^a 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
<span id="mwDt4"></span><span class="c1" id="mwDt8">// Example in C#</span> <span class="n" id="mwDuA">String</span><span class="p" id="mwDuE">.</span><span class="n" id="mwDuI">Format</span><span class="p" id="mwDuM">(</span><span class="s" id="mwDuQ">"My {0} costs {1:C2}"</span><span class="p" id="mwDuU">,</span><span class="w" id="mwDuY"> </span><span class="s" id="mwDuc">"pen"</span><span class="p" id="mwDug">,</span><span class="w" id="mwDuk"> </span><span class="mf" id="mwDuo">19.99</span><span class="p" id="mwDus">);</span><span class="w" id="mwDuw"> </span><span class="c1" id="mwDu0">// returns "My pen costs $19.99"</span><span id="mwDvA"></span><span class="c1" id="mwDvE">// Example in Object Pascal (Delphi)</span> <span class="nb" id="mwDvI">Format</span><span class="p" id="mwDvM">(</span><span class="s" id="mwDvQ">'My %s costs $%2f'</span><span class="o" id="mwDvU">,</span><span class="w" id="mwDvY"> </span><span class="p" id="mwDvc">[</span><span class="s" id="mwDvg">'pen'</span><span class="o" id="mwDvk">,</span><span class="w" id="mwDvo"> </span><span class="mi" id="mwDvs">1</span><span class="mf" id="mwDvw">9.99</span><span class="p" id="mwDv0">])</span><span class="o" id="mwDv4">;</span><span class="w" id="mwDv8"> </span><span class="c1" id="mwDwA">// returns "My pen costs $19.99"</span>
<span id="mwDwM"></span><span class="c1" id="mwDwQ">// Example in Java</span> <span class="n" id="mwDwU">String</span><span class="p" id="mwDwY">.</span><span class="na" id="mwDwc">format</span><span class="p" id="mwDwg">(</span><span class="s" id="mwDwk">"My %s costs $%2f"</span><span class="p" id="mwDwo">,</span><span class="w" id="mwDws"> </span><span class="s" id="mwDww">"pen"</span><span class="p" id="mwDw0">,</span><span class="w" id="mwDw4"> </span><span class="mf" id="mwDw8">19.99</span><span class="p" id="mwDxA">);</span><span class="w" id="mwDxE"> </span><span class="c1" id="mwDxI">// returns "My pen costs $19.99"</span>
<span id="mwDxU"></span><span class="c1" id="mwDxY"># Examples in Raku</span> <span class="nb" id="mwDxc">sprintf</span> <span class="s" id="mwDxg">"My %s costs \$%.2f"</span>, <span class="s" id="mwDxk">"pen"</span>, <span class="mf" id="mwDxo">19.99</span>; <span class="c1" id="mwDxs"># returns "My pen costs $19.99"</span> <span class="mi" id="mwDxw">1</span>.<span class="nb" id="mwDx0">fmt</span>(<span class="s" id="mwDx4">"%04d"</span>); <span class="c1" id="mwDx8"># returns "0001"</span>
<span id="mwDyI"></span><span class="c1" id="mwDyM"># Example in Python</span> <span class="s2" id="mwDyQ">"My </span><span class="si" id="mwDyU">%s</span><span class="s2" id="mwDyY"> costs $</span><span class="si" id="mwDyc">%.2f</span><span class="s2" id="mwDyg">"</span> <span class="o" id="mwDyk">%</span> <span class="p" id="mwDyo">(</span><span class="s2" id="mwDys">"pen"</span><span class="p" id="mwDyw">,</span> <span class="mf" id="mwDy0">19.99</span><span class="p" id="mwDy4">);</span> <span class="c1" id="mwDy8"># returns "My pen costs $19.99"</span> <span class="s2" id="mwDzA">"My </span><span class="si" id="mwDzE">{0}</span><span class="s2" id="mwDzI"> costs $</span><span class="si" id="mwDzM">{1:.2f}</span><span class="s2" id="mwDzQ">"</span><span class="o" id="mwDzU">.</span><span class="n" id="mwDzY">format</span><span class="p" id="mwDzc">(</span><span class="s2" id="mwDzg">"pen"</span><span class="p" id="mwDzk">,</span> <span class="mf" id="mwDzo">19.99</span><span class="p" id="mwDzs">);</span> <span class="c1" id="mwDzw"># returns "My pen costs $19.99"</span><span id="mwDz8"></span><span class="c1" id="mwD0A">#Example in Python 3.6+</span> <span class="n" id="mwD0E">pen</span> <span class="o" id="mwD0I">=</span> <span class="s2" id="mwD0M">"pen"</span> <span class="sa" id="mwD0Q">f</span><span class="s2" id="mwD0U">"My </span><span class="si" id="mwD0Y">{</span><span class="n" id="mwD0c">pen</span><span class="si" id="mwD0g">}</span><span class="s2" id="mwD0k"> costs </span><span class="si" id="mwD0o">{</span><span class="mf" id="mwD0s">19.99</span><span class="si" id="mwD0w">}</span><span class="s2" id="mwD00">"</span> <span class="c1" id="mwD04">#returns "My pen costs 19.99"</span><span id="mwD1E"></span><span class="c1" id="mwD1I">; Example in Scheme</span> <span class="p" id="mwD1M">(</span><span class="nb" id="mwD1Q">format</span><span class="w" id="mwD1U"> </span><span class="s" id="mwD1Y">"My ~a costs $~1,2F"</span><span class="w" id="mwD1c"> </span><span class="s" id="mwD1g">"pen"</span><span class="w" id="mwD1k"> </span><span class="mf" id="mwD1o">19.99</span><span class="p" id="mwD1s">)</span><span class="w" id="mwD1w"> </span><span class="c1" id="mwD10">; returns "My pen costs $19.99"</span>
<span id="mwD2A"></span><span class="cm" id="mwD2E">/* example in PL/I */</span> put<span class="w" id="mwD2I"> </span>string<span class="o" id="mwD2M">(</span>some_string<span class="o" id="mwD2Q">)</span><span class="w" id="mwD2U"> </span>edit<span class="o" id="mwD2Y">(</span><span class="s" id="mwD2c">'My '</span><span class="o" id="mwD2g">,</span><span class="w" id="mwD2k"> </span><span class="s" id="mwD2o">'pen'</span><span class="o" id="mwD2s">,</span><span class="w" id="mwD2w"> </span><span class="s" id="mwD20">' costs'</span><span class="o" id="mwD24">,</span><span class="w" id="mwD28"> </span><span class="m" id="mwD3A">19.99</span><span class="o" id="mwD3E">)(</span>a<span class="o" id="mwD3I">,</span>a<span class="o" id="mwD3M">,</span>a<span class="o" id="mwD3Q">,</span>p<span class="s" id="mwD3U">'$$$V.99'</span><span class="o" id="mwD3Y">)</span> <span class="cm" id="mwD3c">/* returns "My pen costs $19.99" */</span>
Inequality
Tests if two strings are not equal. See also #Equality.
<span id="mwEGk"></span><span class="c1" id="mwEGo">// Example in C#</span> <span class="s" id="mwEGs">"hello"</span><span class="w" id="mwEGw"> </span><span class="o" id="mwEG0">!=</span><span class="w" id="mwEG4"> </span><span class="s" id="mwEG8">"world"</span><span class="w" id="mwEHA"> </span><span class="c1" id="mwEHE">// returns true</span>
<span id="mwEHQ"></span><span class="c" id="mwEHU">' Example in Visual Basic</span> <span class="s" id="mwEHY">"hello"</span><span class="w" id="mwEHc"> </span><span class="o" id="mwEHg"><></span><span class="w" id="mwEHk"> </span><span class="s" id="mwEHo">"world"</span><span class="w" id="mwEHs"> </span><span class="c" id="mwEHw">' returns true</span>
<span id="mwEH8"></span><span class="c1" id="mwEIA">;; Example in Clojure</span> <span class="p" id="mwEIE">(</span><span class="nb" id="mwEII">not= </span><span class="s" id="mwEIM">"hello"</span><span class="w" id="mwEIQ"> </span><span class="s" id="mwEIU">"world"</span><span class="p" id="mwEIY">)</span><span class="w" id="mwEIc"> </span><span class="c1" id="mwEIg">; ⇒ true</span>
<span id="mwEIs"></span><span class="c1" id="mwEIw"># Example in Perl 5</span> <span class="s" id="mwEI0">'hello'</span><span class="w" id="mwEI4"> </span><span class="ow" id="mwEI8">ne</span><span class="w" id="mwEJA"> </span><span class="s" id="mwEJE">'world'</span><span class="w" id="mwEJI"> </span><span class="c1" id="mwEJM"># returns 1</span>
<span id="mwEJY"></span><span class="c1" id="mwEJc"># Example in Raku</span> <span class="s" id="mwEJg">'hello'</span> <span class="o" id="mwEJk">ne</span> <span class="s" id="mwEJo">'world'</span> <span class="c1" id="mwEJs"># returns True</span>
<span id="mwEJ4"></span><span class="c" id="mwEJ8"># Example in Windows PowerShell</span> <span class="s2" id="mwEKA">"hello"</span> <span class="o" id="mwEKE">-ne</span> <span class="s2" id="mwEKI">"world"</span> <span class="c" id="mwEKM"># returns true</span>
index
see #Find
indexof
see #Find
instr
see #Find
instrrev
see #rfind
join
<span id="mwEZk"></span><span class="c1" id="mwEZo">// Example in C#</span> <span class="n" id="mwEZs">String</span><span class="p" id="mwEZw">.</span><span class="n" id="mwEZ0">Join</span><span class="p" id="mwEZ4">(</span><span class="s" id="mwEZ8">"-"</span><span class="p" id="mwEaA">,</span><span class="w" id="mwEaE"> </span><span class="p" id="mwEaI">{</span><span class="s" id="mwEaM">"a"</span><span class="p" id="mwEaQ">,</span><span class="w" id="mwEaU"> </span><span class="s" id="mwEaY">"b"</span><span class="p" id="mwEac">,</span><span class="w" id="mwEag"> </span><span class="s" id="mwEak">"c"</span><span class="p" id="mwEao">})</span><span class="w" id="mwEas"> </span><span class="c1" id="mwEaw">// "a-b-c"</span><span id="mwEa8"></span><span class="c" id="mwEbA">" Example in Smalltalk "</span> <span class="ss" id="mwEbE">#(</span><span class="s" id="mwEbI">'a'</span> <span class="s" id="mwEbM">'b'</span> <span class="s" id="mwEbQ">'c'</span><span class="ss" id="mwEbU">)</span> <span class="nf" id="mwEbY">joinUsing:</span> <span class="s" id="mwEbc">'-'</span> <span class="c" id="mwEbg">" 'a-b-c' "</span>
<span id="mwEbs"></span><span class="c1" id="mwEbw"># Example in Perl 5</span> <span class="nb" id="mwEb0">join</span><span class="p" id="mwEb4">(</span><span class="w" id="mwEb8"> </span><span class="s" id="mwEcA">'-'</span><span class="p" id="mwEcE">,</span><span class="w" id="mwEcI"> </span><span class="p" id="mwEcM">(</span><span class="s" id="mwEcQ">'a'</span><span class="p" id="mwEcU">,</span><span class="w" id="mwEcY"> </span><span class="s" id="mwEcc">'b'</span><span class="p" id="mwEcg">,</span><span class="w" id="mwEck"> </span><span class="s" id="mwEco">'c'</span><span class="p" id="mwEcs">));</span><span class="w" id="mwEcw"> </span><span class="c1" id="mwEc0"># 'a-b-c'</span>
<span id="mwEdA"></span><span class="c1" id="mwEdE"># Example in Raku</span> <span class="s" id="mwEdI"><a b c></span>.<span class="nb" id="mwEdM">join</span>(<span class="s" id="mwEdQ">'-'</span>); <span class="c1" id="mwEdU"># 'a-b-c'</span>
<span id="mwEdg"></span><span class="c1" id="mwEdk"># Example in Python</span> <span class="s2" id="mwEdo">"-"</span><span class="o" id="mwEds">.</span><span class="n" id="mwEdw">join</span><span class="p" id="mwEd0">([</span><span class="s2" id="mwEd4">"a"</span><span class="p" id="mwEd8">,</span> <span class="s2" id="mwEeA">"b"</span><span class="p" id="mwEeE">,</span> <span class="s2" id="mwEeI">"c"</span><span class="p" id="mwEeM">])</span> <span class="c1" id="mwEeQ"># 'a-b-c'</span>
<span id="mwEec"></span><span class="c1" id="mwEeg"># Example in Ruby</span> <span class="o" id="mwEek">[</span><span class="s2" id="mwEeo">"a"</span><span class="p" id="mwEes">,</span><span class="w" id="mwEew"> </span><span class="s2" id="mwEe0">"b"</span><span class="p" id="mwEe4">,</span><span class="w" id="mwEe8"> </span><span class="s2" id="mwEfA">"c"</span><span class="o" id="mwEfE">].</span><span class="n" id="mwEfI">join</span><span class="p" id="mwEfM">(</span><span class="s2" id="mwEfQ">"-"</span><span class="p" id="mwEfU">)</span><span class="w" id="mwEfY"> </span><span class="c1" id="mwEfc"># 'a-b-c'</span>
<span id="mwEfo"></span><span class="c1" id="mwEfs">; Example in Scheme</span> <span class="p" id="mwEfw">(</span><span class="k" id="mwEf0">use-modules</span><span class="w" id="mwEf4"> </span><span class="p" id="mwEf8">(</span><span class="nf" id="mwEgA">srfi</span><span class="w" id="mwEgE"> </span><span class="nv" id="mwEgI">srfi-13</span><span class="p" id="mwEgM">))</span> <span class="p" id="mwEgQ">(</span><span class="nb" id="mwEgU">string-join</span><span class="w" id="mwEgY"> </span><span class="o" id="mwEgc">'</span><span class="p" id="mwEgg">(</span><span class="s" id="mwEgk">"a"</span><span class="w" id="mwEgo"> </span><span class="s" id="mwEgs">"b"</span><span class="w" id="mwEgw"> </span><span class="s" id="mwEg0">"c"</span><span class="p" id="mwEg4">)</span><span class="w" id="mwEg8"> </span><span class="s" id="mwEhA">"-"</span><span class="p" id="mwEhE">)</span><span class="w" id="mwEhI"> </span><span class="c1" id="mwEhM">; "a-b-c"</span>
lastindexof
see #rfind
left
<span id="mwE2Q"></span><span class="c1" id="mwE2U"># Example in Raku</span> <span class="s" id="mwE2Y">"Hello, there!"</span>.<span class="nb" id="mwE2c">substr</span>(<span class="mi" id="mwE2g">0</span>, <span class="mi" id="mwE2k">6</span>); <span class="c1" id="mwE2o"># returns "Hello,"</span>
<span id="mwE20"></span><span class="cm" id="mwE24">/* Examples in Rexx */</span> <span class="nb" id="mwE28">left</span><span class="o" id="mwE3A">(</span><span class="s" id="mwE3E">"abcde"</span><span class="o" id="mwE3I">,</span><span class="w" id="mwE3M"> </span><span class="m" id="mwE3Q">3</span><span class="o" id="mwE3U">)</span><span class="w" id="mwE3Y"> </span><span class="cm" id="mwE3c">/* returns "abc" */</span> <span class="nb" id="mwE3g">left</span><span class="o" id="mwE3k">(</span><span class="s" id="mwE3o">"abcde"</span><span class="o" id="mwE3s">,</span><span class="w" id="mwE3w"> </span><span class="m" id="mwE30">8</span><span class="o" id="mwE34">)</span><span class="w" id="mwE38"> </span><span class="cm" id="mwE4A">/* returns "abcde " */</span> <span class="nb" id="mwE4E">left</span><span class="o" id="mwE4I">(</span><span class="s" id="mwE4M">"abcde"</span><span class="o" id="mwE4Q">,</span><span class="w" id="mwE4U"> </span><span class="m" id="mwE4Y">8</span><span class="o" id="mwE4c">,</span><span class="w" id="mwE4g"> </span><span class="s" id="mwE4k">"*"</span><span class="o" id="mwE4o">)</span><span class="w" id="mwE4s"> </span><span class="cm" id="mwE4w">/* returns "abcde***" */</span>
<span id="mwE48"></span><span class="c1" id="mwE5A">; Examples in Scheme</span> <span class="p" id="mwE5E">(</span><span class="k" id="mwE5I">use-modules</span><span class="w" id="mwE5M"> </span><span class="p" id="mwE5Q">(</span><span class="nf" id="mwE5U">srfi</span><span class="w" id="mwE5Y"> </span><span class="nv" id="mwE5c">srfi-13</span><span class="p" id="mwE5g">))</span> <span class="p" id="mwE5k">(</span><span class="nb" id="mwE5o">string-take</span><span class="w" id="mwE5s"> </span><span class="s" id="mwE5w">"abcde"</span><span class="o" id="mwE50">,</span><span class="w" id="mwE54"> </span><span class="mi" id="mwE58">3</span><span class="p" id="mwE6A">)</span><span class="w" id="mwE6E"> </span><span class="c1" id="mwE6I">; returns "abc"</span> <span class="p" id="mwE6M">(</span><span class="nb" id="mwE6Q">string-take</span><span class="w" id="mwE6U"> </span><span class="s" id="mwE6Y">"abcde"</span><span class="o" id="mwE6c">,</span><span class="w" id="mwE6g"> </span><span class="mi" id="mwE6k">8</span><span class="p" id="mwE6o">)</span><span class="w" id="mwE6s"> </span><span class="c1" id="mwE6w">; error</span>
<span id="mwE68"></span><span class="c1" id="mwE7A">' Examples in Visual Basic</span> <span class="nb" id="mwE7E">Left</span><span class="p" id="mwE7I">(</span><span class="s2" id="mwE7M">"sandroguidi"</span><span class="p" id="mwE7Q">,</span><span class="w" id="mwE7U"> </span><span class="mi" id="mwE7Y">3</span><span class="p" id="mwE7c">)</span><span class="w" id="mwE7g"> </span><span class="c1" id="mwE7k">' returns "san"</span> <span class="nb" id="mwE7o">Left</span><span class="p" id="mwE7s">(</span><span class="s2" id="mwE7w">"sandroguidi"</span><span class="p" id="mwE70">,</span><span class="w" id="mwE74"> </span><span class="mi" id="mwE78">100</span><span class="p" id="mwE8A">)</span><span class="w" id="mwE8E"> </span><span class="c1" id="mwE8I">' returns "sandroguidi"</span>
len
see #length
length
<span id="mwFRg"></span><span class="c1" id="mwFRk">// Examples in C#</span> <span class="s" id="mwFRo">"hello"</span><span class="p" id="mwFRs">.</span><span class="n" id="mwFRw">Length</span><span class="p" id="mwFR0">;</span><span class="w" id="mwFR4"> </span><span class="c1" id="mwFR8">// returns 5</span> <span class="s" id="mwFSA">""</span><span class="p" id="mwFSE">.</span><span class="n" id="mwFSI">Length</span><span class="p" id="mwFSM">;</span><span class="w" id="mwFSQ"> </span><span class="c1" id="mwFSU">// returns 0</span>
<span id="mwFSg"></span><span class="err" id="mwFSk">#</span><span class="w" id="mwFSo"> </span><span class="nv" id="mwFSs">Examples</span><span class="w" id="mwFSw"> </span><span class="n" id="mwFS0">in</span><span class="w" id="mwFS4"> </span><span class="nv" id="mwFS8">Erlang</span> <span class="nn" id="mwFTA">string</span><span class="p" id="mwFTE">:</span><span class="nf" id="mwFTI">len</span><span class="p" id="mwFTM">(</span><span class="s" id="mwFTQ">"hello"</span><span class="p" id="mwFTU">).</span><span class="w" id="mwFTY"> </span><span class="c" id="mwFTc">% returns 5</span> <span class="nn" id="mwFTg">string</span><span class="p" id="mwFTk">:</span><span class="nf" id="mwFTo">len</span><span class="p" id="mwFTs">(</span><span class="s" id="mwFTw">""</span><span class="p" id="mwFT0">).</span><span class="w" id="mwFT4"> </span><span class="c" id="mwFT8">% returns 0</span>
<span id="mwFUI"></span><span class="c1" id="mwFUM"># Examples in Perl 5</span> <span class="nb" id="mwFUQ">length</span><span class="p" id="mwFUU">(</span><span class="s" id="mwFUY">"hello"</span><span class="p" id="mwFUc">);</span><span class="w" id="mwFUg"> </span><span class="c1" id="mwFUk"># returns 5</span> <span class="nb" id="mwFUo">length</span><span class="p" id="mwFUs">(</span><span class="s" id="mwFUw">""</span><span class="p" id="mwFU0">);</span><span class="w" id="mwFU4"> </span><span class="c1" id="mwFU8"># returns 0</span>
<span id="mwFVI"></span><span class="c1" id="mwFVM"># Examples in Raku</span> <span class="s" id="mwFVQ">""</span>.<span class="nb" id="mwFVU">chars</span>; <span class="nb" id="mwFVY">chars</span> <span class="s" id="mwFVc">""</span>; <span class="c1" id="mwFVg"># both return 0</span> <span class="s" id="mwFVk">""</span>.<span class="nb" id="mwFVo">codes</span>; <span class="nb" id="mwFVs">codes</span> <span class="s" id="mwFVw">""</span>; <span class="c1" id="mwFV0"># both return 0</span>
<span id="mwFWA"></span><span class="c" id="mwFWE">' Examples in Visual Basic</span> <span class="n" id="mwFWI">Len</span><span class="p" id="mwFWM">(</span><span class="s" id="mwFWQ">"hello"</span><span class="p" id="mwFWU">)</span><span class="w" id="mwFWY"> </span><span class="c" id="mwFWc">' returns 5</span> <span class="n" id="mwFWg">Len</span><span class="p" id="mwFWk">(</span><span class="s" id="mwFWo">""</span><span class="p" id="mwFWs">)</span><span class="w" id="mwFWw"> </span><span class="c" id="mwFW0">' returns 0</span>
<span id="mwFXA"></span><span class="c1" id="mwFXE">//Examples in Objective-C</span> <span class="p" id="mwFXI">[</span><span class="s" id="mwFXM">@"hello"</span><span class="w" id="mwFXQ"> </span><span class="n" id="mwFXU">Length</span><span class="p" id="mwFXY">]</span><span class="w" id="mwFXc"> </span><span class="c1" id="mwFXg">//returns 5</span> <span class="p" id="mwFXk">[</span><span class="s" id="mwFXo">@""</span><span class="w" id="mwFXs"> </span><span class="n" id="mwFXw">Length</span><span class="p" id="mwFX0">]</span><span class="w" id="mwFX4"> </span><span class="c1" id="mwFX8">//returns 0</span>
<span id="mwFYI"></span><span class="c1" id="mwFYM">-- Examples in Lua</span> <span class="p" id="mwFYQ">(</span><span class="s2" id="mwFYU">"hello"</span><span class="p" id="mwFYY">):</span><span class="nf" id="mwFYc">len</span><span class="p" id="mwFYg">()</span><span class="w" id="mwFYk"> </span><span class="c1" id="mwFYo">-- returns 5</span> <span class="o" id="mwFYs">#</span><span class="s2" id="mwFYw">""</span><span class="w" id="mwFY0"> </span><span class="c1" id="mwFY4">-- returns 0</span>
locate
see #Find
Lowercase
<span id="mwFpw"></span><span class="c1" id="mwFp0">// Example in C#</span> <span class="s" id="mwFp4">"Wiki means fast?"</span><span class="p" id="mwFp8">.</span><span class="n" id="mwFqA">ToLower</span><span class="p" id="mwFqE">();</span><span class="w" id="mwFqI"> </span><span class="c1" id="mwFqM">// "wiki means fast?"</span>
<span id="mwFqY"></span><span class="c1" id="mwFqc">; Example in Scheme</span> <span class="p" id="mwFqg">(</span><span class="k" id="mwFqk">use-modules</span><span class="w" id="mwFqo"> </span><span class="p" id="mwFqs">(</span><span class="nf" id="mwFqw">srfi</span><span class="w" id="mwFq0"> </span><span class="nv" id="mwFq4">srfi-13</span><span class="p" id="mwFq8">))</span> <span class="p" id="mwFrA">(</span><span class="nb" id="mwFrE">string-downcase</span><span class="w" id="mwFrI"> </span><span class="s" id="mwFrM">"Wiki means fast?"</span><span class="p" id="mwFrQ">)</span><span class="w" id="mwFrU"> </span><span class="c1" id="mwFrY">; "wiki means fast?"</span>
<span id="mwFrk"></span><span class="cm" id="mwFro">/* Example in C */</span> <span class="cp" id="mwFrs">#include</span><span class="w" id="mwFrw"> </span><span class="cpf" id="mwFr0"><ctype.h></span> <span class="cp" id="mwFr4">#include</span><span class="w" id="mwFr8"> </span><span class="cpf" id="mwFsA"><stdio.h></span> <span class="kt" id="mwFsE">int</span><span class="w" id="mwFsI"> </span><span class="nf" id="mwFsM">main</span><span class="p" id="mwFsQ">(</span><span class="kt" id="mwFsU">void</span><span class="p" id="mwFsY">)</span><span class="w" id="mwFsc"> </span><span class="p" id="mwFsg">{</span> <span class="w" id="mwFsk"> </span><span class="kt" id="mwFso">char</span><span class="w" id="mwFss"> </span><span class="n" id="mwFsw">s</span><span class="p" id="mwFs0">[]</span><span class="w" id="mwFs4"> </span><span class="o" id="mwFs8">=</span><span class="w" id="mwFtA"> </span><span class="s" id="mwFtE">"Wiki means fast?"</span><span class="p" id="mwFtI">;</span> <span class="w" id="mwFtM"> </span><span class="k" id="mwFtQ">for</span><span class="w" id="mwFtU"> </span><span class="p" id="mwFtY">(</span><span class="kt" id="mwFtc">int</span><span class="w" id="mwFtg"> </span><span class="n" id="mwFtk">i</span><span class="w" id="mwFto"> </span><span class="o" id="mwFts">=</span><span class="w" id="mwFtw"> </span><span class="mi" id="mwFt0">0</span><span class="p" id="mwFt4">;</span><span class="w" id="mwFt8"> </span><span class="n" id="mwFuA">i</span><span class="w" id="mwFuE"> </span><span class="o" id="mwFuI"><</span><span class="w" id="mwFuM"> </span><span class="k" id="mwFuQ">sizeof</span><span class="p" id="mwFuU">(</span><span class="n" id="mwFuY">s</span><span class="p" id="mwFuc">)</span><span class="w" id="mwFug"> </span><span class="o" id="mwFuk">-</span><span class="w" id="mwFuo"> </span><span class="mi" id="mwFus">1</span><span class="p" id="mwFuw">;</span><span class="w" id="mwFu0"> </span><span class="o" id="mwFu4">++</span><span class="n" id="mwFu8">i</span><span class="p" id="mwFvA">)</span><span class="w" id="mwFvE"> </span><span class="p" id="mwFvI">{</span> <span class="w" id="mwFvM"> </span><span class="c1" id="mwFvQ">// transform characters in place, one by one</span> <span class="w" id="mwFvU"> </span><span class="n" id="mwFvY">s</span><span class="p" id="mwFvc">[</span><span class="n" id="mwFvg">i</span><span class="p" id="mwFvk">]</span><span class="w" id="mwFvo"> </span><span class="o" id="mwFvs">=</span><span class="w" id="mwFvw"> </span><span class="n" id="mwFv0">tolower</span><span class="p" id="mwFv4">(</span><span class="n" id="mwFv8">s</span><span class="p" id="mwFwA">[</span><span class="n" id="mwFwE">i</span><span class="p" id="mwFwI">]);</span> <span class="w" id="mwFwM"> </span><span class="p" id="mwFwQ">}</span> <span class="w" id="mwFwU"> </span><span class="n" id="mwFwY">printf</span><span class="p" id="mwFwc">(</span><span class="n" id="mwFwg">string</span><span class="p" id="mwFwk">);</span><span class="w" id="mwFwo"> </span><span class="c1" id="mwFws">// "wiki means fast?"</span> <span class="w" id="mwFww"> </span><span class="k" id="mwFw0">return</span><span class="w" id="mwFw4"> </span><span class="mi" id="mwFw8">0</span><span class="p" id="mwFxA">;</span> <span class="p" id="mwFxE">}</span><span id="mwFxQ"></span><span class="c1" id="mwFxU"># Example in Raku</span> <span class="s" id="mwFxY">"Wiki means fast?"</span>.<span class="nb" id="mwFxc">lc</span>; <span class="c1" id="mwFxg"># "wiki means fast?"</span>
mid
see #substring
partition
<span id="mwF1g"></span><span class="c1" id="mwF1k"># Examples in Python</span> <span class="s2" id="mwF1o">"Spam eggs spam spam and ham"</span><span class="o" id="mwF1s">.</span><span class="n" id="mwF1w">partition</span><span class="p" id="mwF10">(</span><span class="s1" id="mwF14">'spam'</span><span class="p" id="mwF18">)</span> <span class="c1" id="mwF2A"># ('Spam eggs ', 'spam', ' spam and ham')</span> <span class="s2" id="mwF2E">"Spam eggs spam spam and ham"</span><span class="o" id="mwF2I">.</span><span class="n" id="mwF2M">partition</span><span class="p" id="mwF2Q">(</span><span class="s1" id="mwF2U">'X'</span><span class="p" id="mwF2Y">)</span> <span class="c1" id="mwF2c"># ('Spam eggs spam spam and ham', "", "")</span><span id="mwF2o"></span><span class="c1" id="mwF2s"># Examples in Perl 5 / Raku</span> <span class="nb" id="mwF2w">split</span><span class="w" id="mwF20"> </span><span class="sr" id="mwF24">/(spam)/</span><span class="p" id="mwF28">,</span><span class="w" id="mwF3A"> </span><span class="s" id="mwF3E">'Spam eggs spam spam and ham'</span><span class="w" id="mwF3I"> </span><span class="p" id="mwF3M">,</span><span class="mi" id="mwF3Q">2</span><span class="p" id="mwF3U">;</span><span class="w" id="mwF3Y"> </span><span class="c1" id="mwF3c"># ('Spam eggs ', 'spam', ' spam and ham');</span> <span class="nb" id="mwF3g">split</span><span class="w" id="mwF3k"> </span><span class="sr" id="mwF3o">/(X)/</span><span class="p" id="mwF3s">,</span><span class="w" id="mwF3w"> </span><span class="s" id="mwF30">'Spam eggs spam spam and ham'</span><span class="w" id="mwF34"> </span><span class="p" id="mwF38">,</span><span class="mi" id="mwF4A">2</span><span class="p" id="mwF4E">;</span><span class="w" id="mwF4I"> </span><span class="c1" id="mwF4M"># ('Spam eggs spam spam and ham');</span>replace
<span id="mwGKo"></span><span class="c1" id="mwGKs">// Examples in C#</span> <span class="s" id="mwGKw">"effffff"</span><span class="p" id="mwGK0">.</span><span class="n" id="mwGK4">Replace</span><span class="p" id="mwGK8">(</span><span class="s" id="mwGLA">"f"</span><span class="p" id="mwGLE">,</span><span class="w" id="mwGLI"> </span><span class="s" id="mwGLM">"jump"</span><span class="p" id="mwGLQ">);</span><span class="w" id="mwGLU"> </span><span class="c1" id="mwGLY">// returns "ejumpjumpjumpjumpjumpjump"</span> <span class="s" id="mwGLc">"blah"</span><span class="p" id="mwGLg">.</span><span class="n" id="mwGLk">Replace</span><span class="p" id="mwGLo">(</span><span class="s" id="mwGLs">"z"</span><span class="p" id="mwGLw">,</span><span class="w" id="mwGL0"> </span><span class="s" id="mwGL4">"y"</span><span class="p" id="mwGL8">);</span><span class="w" id="mwGMA"> </span><span class="c1" id="mwGME">// returns "blah"</span>
<span id="mwGMQ"></span><span class="c1" id="mwGMU">// Examples in Java</span> <span class="s" id="mwGMY">"effffff"</span><span class="p" id="mwGMc">.</span><span class="na" id="mwGMg">replace</span><span class="p" id="mwGMk">(</span><span class="s" id="mwGMo">"f"</span><span class="p" id="mwGMs">,</span><span class="w" id="mwGMw"> </span><span class="s" id="mwGM0">"jump"</span><span class="p" id="mwGM4">);</span><span class="w" id="mwGM8"> </span><span class="c1" id="mwGNA">// returns "ejumpjumpjumpjumpjumpjump"</span> <span class="s" id="mwGNE">"effffff"</span><span class="p" id="mwGNI">.</span><span class="na" id="mwGNM">replaceAll</span><span class="p" id="mwGNQ">(</span><span class="s" id="mwGNU">"f*"</span><span class="p" id="mwGNY">,</span><span class="w" id="mwGNc"> </span><span class="s" id="mwGNg">"jump"</span><span class="p" id="mwGNk">);</span><span class="w" id="mwGNo"> </span><span class="c1" id="mwGNs">// returns "ejump"</span>
<span id="mwGN4"></span>// <span class="n" id="mwGN8">Examples</span> <span class="nb" id="mwGOA">in</span> <span class="n" id="mwGOE">Raku</span> <span class="s" id="mwGOI">"effffff"</span>.<span class="nb" id="mwGOM">subst</span>(<span class="s" id="mwGOQ">"f"</span>, <span class="s" id="mwGOU">"jump"</span>, :<span class="n" id="mwGOY">g</span>); <span class="c1" id="mwGOc"># returns "ejumpjumpjumpjumpjumpjump"</span> <span class="s" id="mwGOg">"blah"</span>.<span class="nb" id="mwGOk">subst</span>(<span class="s" id="mwGOo">"z"</span>, <span class="s" id="mwGOs">"y"</span>, :<span class="n" id="mwGOw">g</span>); <span class="c1" id="mwGO0"># returns "blah"</span>
<span id="mwGPA"></span><span class="c" id="mwGPE">' Examples in Visual Basic</span> <span class="n" id="mwGPI">Replace</span><span class="p" id="mwGPM">(</span><span class="s" id="mwGPQ">"effffff"</span><span class="p" id="mwGPU">,</span><span class="w" id="mwGPY"> </span><span class="s" id="mwGPc">"f"</span><span class="p" id="mwGPg">,</span><span class="w" id="mwGPk"> </span><span class="s" id="mwGPo">"jump"</span><span class="p" id="mwGPs">)</span><span class="w" id="mwGPw"> </span><span class="c" id="mwGP0">' returns "ejumpjumpjumpjumpjumpjump"</span> <span class="n" id="mwGP4">Replace</span><span class="p" id="mwGP8">(</span><span class="s" id="mwGQA">"blah"</span><span class="p" id="mwGQE">,</span><span class="w" id="mwGQI"> </span><span class="s" id="mwGQM">"z"</span><span class="p" id="mwGQQ">,</span><span class="w" id="mwGQU"> </span><span class="s" id="mwGQY">"y"</span><span class="p" id="mwGQc">)</span><span class="w" id="mwGQg"> </span><span class="c" id="mwGQk">' returns "blah"</span>
<span id="mwGQw"></span><span class="c" id="mwGQ0"># Examples in Windows PowerShell</span> <span class="s2" id="mwGQ4">"effffff"</span> <span class="o" id="mwGQ8">-replace</span> <span class="s2" id="mwGRA">"f"</span><span class="p" id="mwGRE">,</span> <span class="s2" id="mwGRI">"jump"</span> <span class="c" id="mwGRM"># returns "ejumpjumpjumpjumpjumpjump"</span> <span class="s2" id="mwGRQ">"effffff"</span> <span class="o" id="mwGRU">-replace</span> <span class="s2" id="mwGRY">"f*"</span><span class="p" id="mwGRc">,</span> <span class="s2" id="mwGRg">"jump"</span> <span class="c" id="mwGRk"># returns "ejump"</span>
reverse
<span id="mwGfg"></span><span class="c" id="mwGfk">" Example in Smalltalk "</span> <span class="s" id="mwGfo">'hello'</span> <span class="nf" id="mwGfs">reversed</span> <span class="c" id="mwGfw">" returns 'olleh' "</span>
<span id="mwGf8"></span><span class="c1" id="mwGgA"># Example in Perl 5</span> <span class="nb" id="mwGgE">reverse</span><span class="w" id="mwGgI"> </span><span class="s" id="mwGgM">"hello"</span><span class="w" id="mwGgQ"> </span><span class="c1" id="mwGgU"># returns "olleh"</span>
<span id="mwGgg"></span><span class="c1" id="mwGgk"># Example in Raku</span> <span class="s" id="mwGgo">"hello"</span>.<span class="nb" id="mwGgs">flip</span> <span class="c1" id="mwGgw"># returns "olleh"</span>
<span id="mwGg8"></span><span class="c1" id="mwGhA"># Example in Python</span> <span class="s2" id="mwGhE">"hello"</span><span class="p" id="mwGhI">[::</span><span class="o" id="mwGhM">-</span><span class="mi" id="mwGhQ">1</span><span class="p" id="mwGhU">]</span> <span class="c1" id="mwGhY"># returns "olleh"</span>
<span id="mwGhk"></span><span class="c1" id="mwGho">; Example in Scheme</span> <span class="p" id="mwGhs">(</span><span class="k" id="mwGhw">use-modules</span><span class="w" id="mwGh0"> </span><span class="p" id="mwGh4">(</span><span class="nf" id="mwGh8">srfi</span><span class="w" id="mwGiA"> </span><span class="nv" id="mwGiE">srfi-13</span><span class="p" id="mwGiI">))</span> <span class="p" id="mwGiM">(</span><span class="nb" id="mwGiQ">string-reverse</span><span class="w" id="mwGiU"> </span><span class="s" id="mwGiY">"hello"</span><span class="p" id="mwGic">)</span><span class="w" id="mwGig"> </span><span class="c1" id="mwGik">; returns "olleh"</span>
rfind
<span id="mwG0o"></span><span class="c1" id="mwG0s">; Examples in Common Lisp</span> <span class="p" id="mwG0w">(</span><span class="nb" id="mwG00">search</span><span class="w" id="mwG04"> </span><span class="s" id="mwG08">"e"</span><span class="w" id="mwG1A"> </span><span class="s" id="mwG1E">"Hello mate"</span><span class="w" id="mwG1I"> </span><span class="ss" id="mwG1M">:from-end</span><span class="w" id="mwG1Q"> </span><span class="no" id="mwG1U">t</span><span class="p" id="mwG1Y">)</span><span class="w" id="mwG1c"> </span><span class="c1" id="mwG1g">; returns 9</span> <span class="p" id="mwG1k">(</span><span class="nb" id="mwG1o">search</span><span class="w" id="mwG1s"> </span><span class="s" id="mwG1w">"z"</span><span class="w" id="mwG10"> </span><span class="s" id="mwG14">"word"</span><span class="w" id="mwG18"> </span><span class="ss" id="mwG2A">:from-end</span><span class="w" id="mwG2E"> </span><span class="no" id="mwG2I">t</span><span class="p" id="mwG2M">)</span><span class="w" id="mwG2Q"> </span><span class="c1" id="mwG2U">; returns NIL</span>
<span id="mwG2g"></span><span class="c1" id="mwG2k">// Examples in C#</span> <span class="s" id="mwG2o">"Hello mate"</span><span class="p" id="mwG2s">.</span><span class="n" id="mwG2w">LastIndexOf</span><span class="p" id="mwG20">(</span><span class="s" id="mwG24">"e"</span><span class="p" id="mwG28">);</span><span class="w" id="mwG3A"> </span><span class="c1" id="mwG3E">// returns 9</span> <span class="s" id="mwG3I">"Hello mate"</span><span class="p" id="mwG3M">.</span><span class="n" id="mwG3Q">LastIndexOf</span><span class="p" id="mwG3U">(</span><span class="s" id="mwG3Y">"e"</span><span class="p" id="mwG3c">,</span><span class="w" id="mwG3g"> </span><span class="mi" id="mwG3k">4</span><span class="p" id="mwG3o">);</span><span class="w" id="mwG3s"> </span><span class="c1" id="mwG3w">// returns 1</span> <span class="s" id="mwG30">"word"</span><span class="p" id="mwG34">.</span><span class="n" id="mwG38">LastIndexOf</span><span class="p" id="mwG4A">(</span><span class="s" id="mwG4E">"z"</span><span class="p" id="mwG4I">);</span><span class="w" id="mwG4M"> </span><span class="c1" id="mwG4Q">// returns -1</span>
<span id="mwG4c"></span><span class="c1" id="mwG4g"># Examples in Perl 5</span> <span class="nb" id="mwG4k">rindex</span><span class="p" id="mwG4o">(</span><span class="s" id="mwG4s">"Hello mate"</span><span class="p" id="mwG4w">,</span><span class="w" id="mwG40"> </span><span class="s" id="mwG44">"e"</span><span class="p" id="mwG48">);</span><span class="w" id="mwG5A"> </span><span class="c1" id="mwG5E"># returns 9</span> <span class="nb" id="mwG5I">rindex</span><span class="p" id="mwG5M">(</span><span class="s" id="mwG5Q">"Hello mate"</span><span class="p" id="mwG5U">,</span><span class="w" id="mwG5Y"> </span><span class="s" id="mwG5c">"e"</span><span class="p" id="mwG5g">,</span><span class="w" id="mwG5k"> </span><span class="mi" id="mwG5o">4</span><span class="p" id="mwG5s">);</span><span class="w" id="mwG5w"> </span><span class="c1" id="mwG50"># returns 1</span> <span class="nb" id="mwG54">rindex</span><span class="p" id="mwG58">(</span><span class="s" id="mwG6A">"word"</span><span class="p" id="mwG6E">,</span><span class="w" id="mwG6I"> </span><span class="s" id="mwG6M">"z"</span><span class="p" id="mwG6Q">);</span><span class="w" id="mwG6U"> </span><span class="c1" id="mwG6Y"># returns -1</span>
<span id="mwG6k"></span><span class="c1" id="mwG6o"># Examples in Raku</span> <span class="s" id="mwG6s">"Hello mate"</span>.<span class="nb" id="mwG6w">rindex</span>(<span class="s" id="mwG60">"e"</span>); <span class="c1" id="mwG64"># returns 9</span> <span class="s" id="mwG68">"Hello mate"</span>.<span class="nb" id="mwG7A">rindex</span>(<span class="s" id="mwG7E">"e"</span>, <span class="mi" id="mwG7I">4</span>); <span class="c1" id="mwG7M"># returns 1</span> <span class="s" id="mwG7Q">"word"</span>.<span class="nb" id="mwG7U">rindex</span>(<span class="s" id="mwG7Y">'z'</span>); <span class="c1" id="mwG7c"># returns Nil</span>
<span id="mwG7o"></span><span class="c" id="mwG7s">' Examples in Visual Basic</span> <span class="n" id="mwG7w">InStrRev</span><span class="p" id="mwG70">(</span><span class="s" id="mwG74">"Hello mate"</span><span class="p" id="mwG78">,</span><span class="w" id="mwG8A"> </span><span class="s" id="mwG8E">"e"</span><span class="p" id="mwG8I">)</span><span class="w" id="mwG8M"> </span><span class="c" id="mwG8Q">' returns 10</span> <span class="n" id="mwG8U">InStrRev</span><span class="p" id="mwG8Y">(</span><span class="mi" id="mwG8c">5</span><span class="p" id="mwG8g">,</span><span class="w" id="mwG8k"> </span><span class="s" id="mwG8o">"Hello mate"</span><span class="p" id="mwG8s">,</span><span class="w" id="mwG8w"> </span><span class="s" id="mwG80">"e"</span><span class="p" id="mwG84">)</span><span class="w" id="mwG88"> </span><span class="c" id="mwG9A">' returns 2</span> <span class="n" id="mwG9E">InStrRev</span><span class="p" id="mwG9I">(</span><span class="s" id="mwG9M">"word"</span><span class="p" id="mwG9Q">,</span><span class="w" id="mwG9U"> </span><span class="s" id="mwG9Y">"z"</span><span class="p" id="mwG9c">)</span><span class="w" id="mwG9g"> </span><span class="c" id="mwG9k">' returns 0</span>
right
<span id="mwHN4"></span><span class="c1" id="mwHN8">// Examples in Java; extract rightmost 4 characters</span> <span class="n" id="mwHOA">String</span><span class="w" id="mwHOE"> </span><span class="n" id="mwHOI">str</span><span class="w" id="mwHOM"> </span><span class="o" id="mwHOQ">=</span><span class="w" id="mwHOU"> </span><span class="s" id="mwHOY">"CarDoor"</span><span class="p" id="mwHOc">;</span> <span class="n" id="mwHOg">str</span><span class="p" id="mwHOk">.</span><span class="na" id="mwHOo">substring</span><span class="p" id="mwHOs">(</span><span class="n" id="mwHOw">str</span><span class="p" id="mwHO0">.</span><span class="na" id="mwHO4">length</span><span class="p" id="mwHO8">()</span><span class="o" id="mwHPA">-</span><span class="mi" id="mwHPE">4</span><span class="p" id="mwHPI">);</span><span class="w" id="mwHPM"> </span><span class="c1" id="mwHPQ">// returns 'Door'</span>
<span id="mwHPc"></span><span class="c1" id="mwHPg"># Examples in Raku</span> <span class="s" id="mwHPk">"abcde"</span>.<span class="nb" id="mwHPo">substr</span>(*-<span class="mi" id="mwHPs">3</span>); <span class="c1" id="mwHPw"># returns "cde"</span> <span class="s" id="mwHP0">"abcde"</span>.<span class="nb" id="mwHP4">substr</span>(*-<span class="mi" id="mwHP8">8</span>); <span class="c1" id="mwHQA"># 'out of range' error</span>
<span id="mwHQM"></span><span class="cm" id="mwHQQ">/* Examples in Rexx */</span> <span class="nb" id="mwHQU">right</span><span class="o" id="mwHQY">(</span><span class="s" id="mwHQc">"abcde"</span><span class="o" id="mwHQg">,</span><span class="w" id="mwHQk"> </span><span class="m" id="mwHQo">3</span><span class="o" id="mwHQs">)</span><span class="w" id="mwHQw"> </span><span class="cm" id="mwHQ0">/* returns "cde" */</span> <span class="nb" id="mwHQ4">right</span><span class="o" id="mwHQ8">(</span><span class="s" id="mwHRA">"abcde"</span><span class="o" id="mwHRE">,</span><span class="w" id="mwHRI"> </span><span class="m" id="mwHRM">8</span><span class="o" id="mwHRQ">)</span><span class="w" id="mwHRU"> </span><span class="cm" id="mwHRY">/* returns " abcde" */</span> <span class="nb" id="mwHRc">right</span><span class="o" id="mwHRg">(</span><span class="s" id="mwHRk">"abcde"</span><span class="o" id="mwHRo">,</span><span class="w" id="mwHRs"> </span><span class="m" id="mwHRw">8</span><span class="o" id="mwHR0">,</span><span class="w" id="mwHR4"> </span><span class="s" id="mwHR8">"*"</span><span class="o" id="mwHSA">)</span><span class="w" id="mwHSE"> </span><span class="cm" id="mwHSI">/* returns "***abcde" */</span>
<span id="mwHSU"></span><span class="c1" id="mwHSY">; Examples in Scheme</span> <span class="p" id="mwHSc">(</span><span class="k" id="mwHSg">use-modules</span><span class="w" id="mwHSk"> </span><span class="p" id="mwHSo">(</span><span class="nf" id="mwHSs">srfi</span><span class="w" id="mwHSw"> </span><span class="nv" id="mwHS0">srfi-13</span><span class="p" id="mwHS4">))</span> <span class="p" id="mwHS8">(</span><span class="nb" id="mwHTA">string-take-right</span><span class="w" id="mwHTE"> </span><span class="s" id="mwHTI">"abcde"</span><span class="o" id="mwHTM">,</span><span class="w" id="mwHTQ"> </span><span class="mi" id="mwHTU">3</span><span class="p" id="mwHTY">)</span><span class="w" id="mwHTc"> </span><span class="c1" id="mwHTg">; returns "cde"</span> <span class="p" id="mwHTk">(</span><span class="nb" id="mwHTo">string-take-right</span><span class="w" id="mwHTs"> </span><span class="s" id="mwHTw">"abcde"</span><span class="o" id="mwHT0">,</span><span class="w" id="mwHT4"> </span><span class="mi" id="mwHT8">8</span><span class="p" id="mwHUA">)</span><span class="w" id="mwHUE"> </span><span class="c1" id="mwHUI">; error</span>
<span id="mwHUU"></span><span class="c" id="mwHUY">' Examples in Visual Basic</span> <span class="n" id="mwHUc">Right</span><span class="p" id="mwHUg">(</span><span class="s" id="mwHUk">"sandroguidi"</span><span class="p" id="mwHUo">,</span><span class="w" id="mwHUs"> </span><span class="mi" id="mwHUw">3</span><span class="p" id="mwHU0">)</span><span class="w" id="mwHU4"> </span><span class="c" id="mwHU8">' returns "idi"</span> <span class="n" id="mwHVA">Right</span><span class="p" id="mwHVE">(</span><span class="s" id="mwHVI">"sandroguidi"</span><span class="p" id="mwHVM">,</span><span class="w" id="mwHVQ"> </span><span class="mi" id="mwHVU">100</span><span class="p" id="mwHVY">)</span><span class="w" id="mwHVc"> </span><span class="c" id="mwHVg">' returns "sandroguidi"</span>
rpartition
<span id="mwHXQ"></span><span class="c1" id="mwHXU"># Examples in Python</span> <span class="s2" id="mwHXY">"Spam eggs spam spam and ham"</span><span class="o" id="mwHXc">.</span><span class="n" id="mwHXg">rpartition</span><span class="p" id="mwHXk">(</span><span class="s1" id="mwHXo">'spam'</span><span class="p" id="mwHXs">)</span> <span class="c1" id="mwHXw">### ('Spam eggs spam ', 'spam', ' and ham')</span> <span class="s2" id="mwHX0">"Spam eggs spam spam and ham"</span><span class="o" id="mwHX4">.</span><span class="n" id="mwHX8">rpartition</span><span class="p" id="mwHYA">(</span><span class="s1" id="mwHYE">'X'</span><span class="p" id="mwHYI">)</span> <span class="c1" id="mwHYM">### ("", "", 'Spam eggs spam spam and ham')</span>slice
see #substring
split
<span id="mwHl8"></span><span class="c1" id="mwHmA">// Example in C#</span> <span class="s" id="mwHmE">"abc,defgh,ijk"</span><span class="p" id="mwHmI">.</span><span class="n" id="mwHmM">Split</span><span class="p" id="mwHmQ">(</span><span class="sc" id="mwHmU">','</span><span class="p" id="mwHmY">);</span><span class="w" id="mwHmc"> </span><span class="c1" id="mwHmg">// {"abc", "defgh", "ijk"}</span> <span class="s" id="mwHmk">"abc,defgh;ijk"</span><span class="p" id="mwHmo">.</span><span class="n" id="mwHms">Split</span><span class="p" id="mwHmw">(</span><span class="sc" id="mwHm0">','</span><span class="p" id="mwHm4">,</span><span class="w" id="mwHm8"> </span><span class="sc" id="mwHnA">';'</span><span class="p" id="mwHnE">);</span><span class="w" id="mwHnI"> </span><span class="c1" id="mwHnM">// {"abc", "defgh", "ijk"}</span><span id="mwHnY"></span><span class="c" id="mwHnc">% Example in Erlang</span> <span class="nn" id="mwHng">string</span><span class="p" id="mwHnk">:</span><span class="nf" id="mwHno">tokens</span><span class="p" id="mwHns">(</span><span class="s" id="mwHnw">"abc;defgh;ijk"</span><span class="p" id="mwHn0">,</span><span class="w" id="mwHn4"> </span><span class="s" id="mwHn8">";"</span><span class="p" id="mwHoA">).</span><span class="w" id="mwHoE"> </span><span class="c" id="mwHoI">% ["abc", "defgh", "ijk"]</span>
<span id="mwHoU"></span><span class="c1" id="mwHoY">// Examples in Java</span> <span class="s" id="mwHoc">"abc,defgh,ijk"</span><span class="p" id="mwHog">.</span><span class="na" id="mwHok">split</span><span class="p" id="mwHoo">(</span><span class="s" id="mwHos">","</span><span class="p" id="mwHow">);</span><span class="w" id="mwHo0"> </span><span class="c1" id="mwHo4">// {"abc", "defgh", "ijk"}</span> <span class="s" id="mwHo8">"abc,defgh;ijk"</span><span class="p" id="mwHpA">.</span><span class="na" id="mwHpE">split</span><span class="p" id="mwHpI">(</span><span class="s" id="mwHpM">",|;"</span><span class="p" id="mwHpQ">);</span><span class="w" id="mwHpU"> </span><span class="c1" id="mwHpY">// {"abc", "defgh", "ijk"}</span><span id="mwHpk"></span><span class="cm" id="mwHpo">{ Example in Pascal }</span> <span class="k" id="mwHps">var</span> <span class="w" id="mwHpw"> </span><span class="n" id="mwHp0">lStrings</span><span class="o" id="mwHp4">:</span><span class="w" id="mwHp8"> </span><span class="n" id="mwHqA">TStringList</span><span class="o" id="mwHqE">;</span> <span class="w" id="mwHqI"> </span><span class="n" id="mwHqM">lStr</span><span class="o" id="mwHqQ">:</span><span class="w" id="mwHqU"> </span><span class="k" id="mwHqY">string</span><span class="o" id="mwHqc">;</span> <span class="k" id="mwHqg">begin</span> <span class="w" id="mwHqk"> </span><span class="n" id="mwHqo">lStrings</span><span class="w" id="mwHqs"> </span><span class="o" id="mwHqw">:=</span><span class="w" id="mwHq0"> </span><span class="n" id="mwHq4">TStringList</span><span class="o" id="mwHq8">.</span><span class="n" id="mwHrA">Create</span><span class="o" id="mwHrE">;</span> <span class="w" id="mwHrI"> </span><span class="n" id="mwHrM">lStrings</span><span class="o" id="mwHrQ">.</span><span class="n" id="mwHrU">Delimiter</span><span class="w" id="mwHrY"> </span><span class="o" id="mwHrc">:=</span><span class="w" id="mwHrg"> </span><span class="s" id="mwHrk">','</span><span class="o" id="mwHro">;</span> <span class="w" id="mwHrs"> </span><span class="n" id="mwHrw">lStrings</span><span class="o" id="mwHr0">.</span><span class="n" id="mwHr4">DelimitedText</span><span class="w" id="mwHr8"> </span><span class="o" id="mwHsA">:=</span><span class="w" id="mwHsE"> </span><span class="s" id="mwHsI">'abc,defgh,ijk'</span><span class="o" id="mwHsM">;</span> <span class="w" id="mwHsQ"> </span><span class="n" id="mwHsU">lStr</span><span class="w" id="mwHsY"> </span><span class="o" id="mwHsc">:=</span><span class="w" id="mwHsg"> </span><span class="n" id="mwHsk">lStrings</span><span class="o" id="mwHso">.</span><span class="n" id="mwHss">Strings</span><span class="p" id="mwHsw">[</span><span class="mi" id="mwHs0">0</span><span class="p" id="mwHs4">]</span><span class="o" id="mwHs8">;</span><span class="w" id="mwHtA"> </span><span class="c1" id="mwHtE">// 'abc'</span> <span class="w" id="mwHtI"> </span><span class="n" id="mwHtM">lStr</span><span class="w" id="mwHtQ"> </span><span class="o" id="mwHtU">:=</span><span class="w" id="mwHtY"> </span><span class="n" id="mwHtc">lStrings</span><span class="o" id="mwHtg">.</span><span class="n" id="mwHtk">Strings</span><span class="p" id="mwHto">[</span><span class="mi" id="mwHts">1</span><span class="p" id="mwHtw">]</span><span class="o" id="mwHt0">;</span><span class="w" id="mwHt4"> </span><span class="c1" id="mwHt8">// 'defgh'</span> <span class="w" id="mwHuA"> </span><span class="n" id="mwHuE">lStr</span><span class="w" id="mwHuI"> </span><span class="o" id="mwHuM">:=</span><span class="w" id="mwHuQ"> </span><span class="n" id="mwHuU">lStrings</span><span class="o" id="mwHuY">.</span><span class="n" id="mwHuc">Strings</span><span class="p" id="mwHug">[</span><span class="mi" id="mwHuk">2</span><span class="p" id="mwHuo">]</span><span class="o" id="mwHus">;</span><span class="w" id="mwHuw"> </span><span class="c1" id="mwHu0">// 'ijk'</span> <span class="k" id="mwHu4">end</span><span class="o" id="mwHu8">;</span><span id="mwHvI"></span><span class="c1" id="mwHvM"># Examples in Perl 5</span> <span class="nb" id="mwHvQ">split</span><span class="p" id="mwHvU">(</span><span class="sr" id="mwHvY">/spam/</span><span class="p" id="mwHvc">,</span><span class="w" id="mwHvg"> </span><span class="s" id="mwHvk">'Spam eggs spam spam and ham'</span><span class="p" id="mwHvo">);</span><span class="w" id="mwHvs"> </span><span class="c1" id="mwHvw"># ('Spam eggs ', ' ', ' and ham')</span> <span class="nb" id="mwHv0">split</span><span class="p" id="mwHv4">(</span><span class="sr" id="mwHv8">/X/</span><span class="p" id="mwHwA">,</span><span class="w" id="mwHwE"> </span><span class="s" id="mwHwI">'Spam eggs spam spam and ham'</span><span class="p" id="mwHwM">);</span><span class="w" id="mwHwQ"> </span><span class="c1" id="mwHwU"># ('Spam eggs spam spam and ham')</span><span id="mwHwg"></span><span class="c1" id="mwHwk"># Examples in Raku</span> <span class="s" id="mwHwo">'Spam eggs spam spam and ham'</span>.<span class="nb" id="mwHws">split</span>(<span class="sr" id="mwHww">/spam/</span>); <span class="c1" id="mwHw0"># (Spam eggs and ham)</span> <span class="nb" id="mwHw4">split</span>(<span class="sr" id="mwHw8">/X/</span>, <span class="s" id="mwHxA">'Spam eggs spam spam and ham'</span>); <span class="c1" id="mwHxE"># (Spam eggs spam spam and ham)</span>
sprintf
see #Format
strip
see #trim
strcmp
see #Compare (integer result)
substring
<span id="mwIPI"></span><span class="c1" id="mwIPM">// Examples in C#</span> <span class="s" id="mwIPQ">"abc"</span><span class="p" id="mwIPU">.</span><span class="n" id="mwIPY">Substring</span><span class="p" id="mwIPc">(</span><span class="mi" id="mwIPg">1</span><span class="p" id="mwIPk">,</span><span class="w" id="mwIPo"> </span><span class="mi" id="mwIPs">1</span><span class="p" id="mwIPw">):</span><span class="w" id="mwIP0"> </span><span class="c1" id="mwIP4">// returns "b"</span> <span class="s" id="mwIP8">"abc"</span><span class="p" id="mwIQA">.</span><span class="n" id="mwIQE">Substring</span><span class="p" id="mwIQI">(</span><span class="mi" id="mwIQM">1</span><span class="p" id="mwIQQ">,</span><span class="w" id="mwIQU"> </span><span class="mi" id="mwIQY">2</span><span class="p" id="mwIQc">);</span><span class="w" id="mwIQg"> </span><span class="c1" id="mwIQk">// returns "bc"</span> <span class="s" id="mwIQo">"abc"</span><span class="p" id="mwIQs">.</span><span class="n" id="mwIQw">Substring</span><span class="p" id="mwIQ0">(</span><span class="mi" id="mwIQ4">1</span><span class="p" id="mwIQ8">,</span><span class="w" id="mwIRA"> </span><span class="mi" id="mwIRE">6</span><span class="p" id="mwIRI">);</span><span class="w" id="mwIRM"> </span><span class="c1" id="mwIRQ">// error</span>
<span id="mwIRc"></span><span class="c1" id="mwIRg">;; Examples in Common Lisp</span> <span class="p" id="mwIRk">(</span><span class="nb" id="mwIRo">subseq</span><span class="w" id="mwIRs"> </span><span class="s" id="mwIRw">"abc"</span><span class="w" id="mwIR0"> </span><span class="mi" id="mwIR4">1</span><span class="w" id="mwIR8"> </span><span class="mi" id="mwISA">2</span><span class="p" id="mwISE">)</span><span class="w" id="mwISI"> </span><span class="c1" id="mwISM">; returns "b"</span> <span class="p" id="mwISQ">(</span><span class="nb" id="mwISU">subseq</span><span class="w" id="mwISY"> </span><span class="s" id="mwISc">"abc"</span><span class="w" id="mwISg"> </span><span class="mi" id="mwISk">2</span><span class="p" id="mwISo">)</span><span class="w" id="mwISs"> </span><span class="c1" id="mwISw">; returns "c"</span>
<span id="mwIS8"></span><span class="c" id="mwITA">% Examples in Erlang</span> <span class="nn" id="mwITE">string</span><span class="p" id="mwITI">:</span><span class="nf" id="mwITM">substr</span><span class="p" id="mwITQ">(</span><span class="s" id="mwITU">"abc"</span><span class="p" id="mwITY">,</span><span class="w" id="mwITc"> </span><span class="mi" id="mwITg">2</span><span class="p" id="mwITk">,</span><span class="w" id="mwITo"> </span><span class="mi" id="mwITs">1</span><span class="p" id="mwITw">).</span><span class="w" id="mwIT0"> </span><span class="c" id="mwIT4">% returns "b"</span> <span class="nn" id="mwIT8">string</span><span class="p" id="mwIUA">:</span><span class="nf" id="mwIUE">substr</span><span class="p" id="mwIUI">(</span><span class="s" id="mwIUM">"abc"</span><span class="p" id="mwIUQ">,</span><span class="w" id="mwIUU"> </span><span class="mi" id="mwIUY">2</span><span class="p" id="mwIUc">).</span><span class="w" id="mwIUg"> </span><span class="c" id="mwIUk">% returns "bc"</span>
<span id="mwIUw"></span><span class="c1" id="mwIU0"># Examples in Perl 5</span> <span class="nb" id="mwIU4">substr</span><span class="p" id="mwIU8">(</span><span class="s" id="mwIVA">"abc"</span><span class="p" id="mwIVE">,</span><span class="w" id="mwIVI"> </span><span class="mi" id="mwIVM">1</span><span class="p" id="mwIVQ">,</span><span class="w" id="mwIVU"> </span><span class="mi" id="mwIVY">1</span><span class="p" id="mwIVc">);</span><span class="w" id="mwIVg"> </span><span class="c1" id="mwIVk"># returns "b"</span> <span class="nb" id="mwIVo">substr</span><span class="p" id="mwIVs">(</span><span class="s" id="mwIVw">"abc"</span><span class="p" id="mwIV0">,</span><span class="w" id="mwIV4"> </span><span class="mi" id="mwIV8">1</span><span class="p" id="mwIWA">);</span><span class="w" id="mwIWE"> </span><span class="c1" id="mwIWI"># returns "bc"</span>
<span id="mwIWU"></span><span class="c1" id="mwIWY"># Examples in Raku</span> <span class="s" id="mwIWc">"abc"</span>.<span class="nb" id="mwIWg">substr</span>(<span class="mi" id="mwIWk">1</span>, <span class="mi" id="mwIWo">1</span>); <span class="c1" id="mwIWs"># returns "b"</span> <span class="s" id="mwIWw">"abc"</span>.<span class="nb" id="mwIW0">substr</span>(<span class="mi" id="mwIW4">1</span>); <span class="c1" id="mwIW8"># returns "bc"</span>
<span id="mwIXI"></span><span class="c1" id="mwIXM"># Examples in Python</span> <span class="s2" id="mwIXQ">"abc"</span><span class="p" id="mwIXU">[</span><span class="mi" id="mwIXY">1</span><span class="p" id="mwIXc">:</span><span class="mi" id="mwIXg">2</span><span class="p" id="mwIXk">]</span> <span class="c1" id="mwIXo"># returns "b"</span> <span class="s2" id="mwIXs">"abc"</span><span class="p" id="mwIXw">[</span><span class="mi" id="mwIX0">1</span><span class="p" id="mwIX4">:</span><span class="mi" id="mwIX8">3</span><span class="p" id="mwIYA">]</span> <span class="c1" id="mwIYE"># returns "bc"</span>
<span id="mwIYQ"></span><span class="cm" id="mwIYU">/* Examples in Rexx */</span> <span class="nb" id="mwIYY">substr</span><span class="o" id="mwIYc">(</span><span class="s" id="mwIYg">"abc"</span><span class="o" id="mwIYk">,</span><span class="w" id="mwIYo"> </span><span class="m" id="mwIYs">2</span><span class="o" id="mwIYw">,</span><span class="w" id="mwIY0"> </span><span class="m" id="mwIY4">1</span><span class="o" id="mwIY8">)</span><span class="w" id="mwIZA"> </span><span class="cm" id="mwIZE">/* returns "b" */</span> <span class="nb" id="mwIZI">substr</span><span class="o" id="mwIZM">(</span><span class="s" id="mwIZQ">"abc"</span><span class="o" id="mwIZU">,</span><span class="w" id="mwIZY"> </span><span class="m" id="mwIZc">2</span><span class="o" id="mwIZg">)</span><span class="w" id="mwIZk"> </span><span class="cm" id="mwIZo">/* returns "bc" */</span> <span class="nb" id="mwIZs">substr</span><span class="o" id="mwIZw">(</span><span class="s" id="mwIZ0">"abc"</span><span class="o" id="mwIZ4">,</span><span class="w" id="mwIZ8"> </span><span class="m" id="mwIaA">2</span><span class="o" id="mwIaE">,</span><span class="w" id="mwIaI"> </span><span class="m" id="mwIaM">6</span><span class="o" id="mwIaQ">)</span><span class="w" id="mwIaU"> </span><span class="cm" id="mwIaY">/* returns "bc " */</span> <span class="nb" id="mwIac">substr</span><span class="o" id="mwIag">(</span><span class="s" id="mwIak">"abc"</span><span class="o" id="mwIao">,</span><span class="w" id="mwIas"> </span><span class="m" id="mwIaw">2</span><span class="o" id="mwIa0">,</span><span class="w" id="mwIa4"> </span><span class="m" id="mwIa8">6</span><span class="o" id="mwIbA">,</span><span class="w" id="mwIbE"> </span><span class="s" id="mwIbI">"*"</span><span class="o" id="mwIbM">)</span><span class="w" id="mwIbQ"> </span><span class="cm" id="mwIbU">/* returns "bc****" */</span>
Uppercase
<span id="mwIxk"></span><span class="c1" id="mwIxo">// Example in C#</span> <span class="s" id="mwIxs">"Wiki means fast?"</span><span class="p" id="mwIxw">.</span><span class="n" id="mwIx0">ToUpper</span><span class="p" id="mwIx4">();</span><span class="w" id="mwIx8"> </span><span class="c1" id="mwIyA">// "WIKI MEANS FAST?"</span>
<span id="mwIyM"></span><span class="c1" id="mwIyQ"># Example in Perl 5</span> <span class="nb" id="mwIyU">uc</span><span class="p" id="mwIyY">(</span><span class="s" id="mwIyc">"Wiki means fast?"</span><span class="p" id="mwIyg">);</span><span class="w" id="mwIyk"> </span><span class="c1" id="mwIyo"># "WIKI MEANS FAST?"</span>
<span id="mwIy0"></span><span class="c1" id="mwIy4"># Example in Raku</span> <span class="nb" id="mwIy8">uc</span>(<span class="s" id="mwIzA">"Wiki means fast?"</span>); <span class="c1" id="mwIzE"># "WIKI MEANS FAST?"</span> <span class="s" id="mwIzI">"Wiki means fast?"</span>.<span class="nb" id="mwIzM">uc</span>; <span class="c1" id="mwIzQ"># "WIKI MEANS FAST?"</span>
<span id="mwIzc"></span><span class="cm" id="mwIzg">/* Example in Rexx */</span> <span class="nb" id="mwIzk">translate</span><span class="o" id="mwIzo">(</span><span class="s" id="mwIzs">"Wiki means fast?"</span><span class="o" id="mwIzw">)</span><span class="w" id="mwIz0"> </span><span class="cm" id="mwIz4">/* "WIKI MEANS FAST?" */</span> <span class="cm" id="mwIz8">/* Example #2 */</span> A<span class="o" id="mwI0A">=</span><span class="s" id="mwI0E">'This is an example.'</span> UPPER<span class="w" id="mwI0I"> </span>A<span class="w" id="mwI0M"> </span><span class="cm" id="mwI0Q">/* "THIS IS AN EXAMPLE." */</span> <span class="cm" id="mwI0U">/* Example #3 */</span> A<span class="o" id="mwI0Y">=</span><span class="s" id="mwI0c">'upper using Translate Function.'</span> Translate<span class="w" id="mwI0g"> </span>UPPER<span class="w" id="mwI0k"> </span>VAR<span class="w" id="mwI0o"> </span>A<span class="w" id="mwI0s"> </span>Z<span class="w" id="mwI0w"> </span><span class="cm" id="mwI00">/* Z="UPPER USING TRANSLATE FUNCTION." */</span>
<span id="mwI1A"></span><span class="c1" id="mwI1E">; Example in Scheme</span> <span class="p" id="mwI1I">(</span><span class="k" id="mwI1M">use-modules</span><span class="w" id="mwI1Q"> </span><span class="p" id="mwI1U">(</span><span class="nf" id="mwI1Y">srfi</span><span class="w" id="mwI1c"> </span><span class="nv" id="mwI1g">srfi-13</span><span class="p" id="mwI1k">))</span> <span class="p" id="mwI1o">(</span><span class="nb" id="mwI1s">string-upcase</span><span class="w" id="mwI1w"> </span><span class="s" id="mwI10">"Wiki means fast?"</span><span class="p" id="mwI14">)</span><span class="w" id="mwI18"> </span><span class="c1" id="mwI2A">; "WIKI MEANS FAST?"</span>
<span id="mwI2M"></span><span class="c" id="mwI2Q">' Example in Visual Basic</span> <span class="n" id="mwI2U">UCase</span><span class="p" id="mwI2Y">(</span><span class="s" id="mwI2c">"Wiki means fast?"</span><span class="p" id="mwI2g">)</span><span class="w" id="mwI2k"> </span><span class="c" id="mwI2o">' "WIKI MEANS FAST?"</span>
trim
trim or strip is used to remove whitespace from the beginning, end, or both beginning and end, of a string.
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:
<span id="mwJFQ"></span><span class="nv" id="mwJFU">Trim</span><span class="kd" id="mwJFY">←</span><span class="s1" id="mwJFc">'^ +| +$'</span><span class="nf" id="mwJFg">⎕R</span><span class="s1" id="mwJFk">''</span>
Alternatively, a functional approach combining Boolean masks that filter away leading and trailing spaces:
<span id="mwJF0"></span><span class="nv" id="mwJF4">Trim</span><span class="kd" id="mwJF8">←</span><span class="kt" id="mwJGA">{</span><span class="bp" id="mwJGE">⍵</span><span class="na" id="mwJGI">/⍨</span><span class="p" id="mwJGM">(</span><span class="o" id="mwJGQ">∨</span><span class="na" id="mwJGU">\</span><span class="o" id="mwJGY">∧</span><span class="na" id="mwJGc">∘</span><span class="o" id="mwJGg">⌽∨</span><span class="na" id="mwJGk">\∘</span><span class="o" id="mwJGo">⌽</span><span class="p" id="mwJGs">)</span><span class="s1" id="mwJGw">' '</span><span class="o" id="mwJG0">≠</span><span class="bp" id="mwJG4">⍵</span><span class="kt" id="mwJG8">}</span>Or reverse and remove leading spaces, twice:
<span id="mwJHM"></span><span class="nv" id="mwJHQ">Trim</span><span class="kd" id="mwJHU">←</span><span class="kt" id="mwJHY">{</span><span class="p" id="mwJHc">(</span><span class="o" id="mwJHg">∨</span><span class="na" id="mwJHk">\</span><span class="s1" id="mwJHo">' '</span><span class="o" id="mwJHs">≠</span><span class="bp" id="mwJHw">⍵</span><span class="p" id="mwJH0">)</span><span class="na" id="mwJH4">/</span><span class="bp" id="mwJH8">⍵</span><span class="kt" id="mwJIA">}</span><span class="na" id="mwJIE">∘</span><span class="o" id="mwJII">⌽</span><span class="na" id="mwJIM">⍣</span><span class="m" id="mwJIQ">2</span>AWK
In AWK, one can use regular expressions to trim:
<span id="mwJIo"></span> <span class="nx" id="mwJIs">ltrim</span><span class="p" id="mwJIw">(</span><span class="nx" id="mwJI0">v</span><span class="p" id="mwJI4">)</span> <span class="o" id="mwJI8">=</span> <span class="kr" id="mwJJA">gsub</span><span class="p" id="mwJJE">(</span><span class="sr" id="mwJJI">/^[ \t]+/</span><span class="p" id="mwJJM">,</span> <span class="s2" id="mwJJQ">""</span><span class="p" id="mwJJU">,</span> <span class="nx" id="mwJJY">v</span><span class="p" id="mwJJc">)</span> <span class="nx" id="mwJJg">rtrim</span><span class="p" id="mwJJk">(</span><span class="nx" id="mwJJo">v</span><span class="p" id="mwJJs">)</span> <span class="o" id="mwJJw">=</span> <span class="kr" id="mwJJ0">gsub</span><span class="p" id="mwJJ4">(</span><span class="sr" id="mwJJ8">/[ \t]+$/</span><span class="p" id="mwJKA">,</span> <span class="s2" id="mwJKE">""</span><span class="p" id="mwJKI">,</span> <span class="nx" id="mwJKM">v</span><span class="p" id="mwJKQ">)</span> <span class="nx" id="mwJKU">trim</span><span class="p" id="mwJKY">(</span><span class="nx" id="mwJKc">v</span><span class="p" id="mwJKg">)</span> <span class="o" id="mwJKk">=</span> <span class="nx" id="mwJKo">ltrim</span><span class="p" id="mwJKs">(</span><span class="nx" id="mwJKw">v</span><span class="p" id="mwJK0">);</span> <span class="nx" id="mwJK4">rtrim</span><span class="p" id="mwJK8">(</span><span class="nx" id="mwJLA">v</span><span class="p" id="mwJLE">)</span>
or:
<span id="mwJLU"></span> <span class="kd" id="mwJLY">function</span> <span class="nx" id="mwJLc">ltrim</span><span class="p" id="mwJLg">(</span><span class="nx" id="mwJLk">s</span><span class="p" id="mwJLo">)</span> <span class="p" id="mwJLs">{</span> <span class="kr" id="mwJLw">sub</span><span class="p" id="mwJL0">(</span><span class="sr" id="mwJL4">/^[ \t]+/</span><span class="p" id="mwJL8">,</span> <span class="s2" id="mwJMA">""</span><span class="p" id="mwJME">,</span> <span class="nx" id="mwJMI">s</span><span class="p" id="mwJMM">);</span> <span class="k" id="mwJMQ">return</span> <span class="nx" id="mwJMU">s</span> <span class="p" id="mwJMY">}</span> <span class="kd" id="mwJMc">function</span> <span class="nx" id="mwJMg">rtrim</span><span class="p" id="mwJMk">(</span><span class="nx" id="mwJMo">s</span><span class="p" id="mwJMs">)</span> <span class="p" id="mwJMw">{</span> <span class="kr" id="mwJM0">sub</span><span class="p" id="mwJM4">(</span><span class="sr" id="mwJM8">/[ \t]+$/</span><span class="p" id="mwJNA">,</span> <span class="s2" id="mwJNE">""</span><span class="p" id="mwJNI">,</span> <span class="nx" id="mwJNM">s</span><span class="p" id="mwJNQ">);</span> <span class="k" id="mwJNU">return</span> <span class="nx" id="mwJNY">s</span> <span class="p" id="mwJNc">}</span> <span class="kd" id="mwJNg">function</span> <span class="nx" id="mwJNk">trim</span><span class="p" id="mwJNo">(</span><span class="nx" id="mwJNs">s</span><span class="p" id="mwJNw">)</span> <span class="p" id="mwJN0">{</span> <span class="k" id="mwJN4">return</span> <span class="nx" id="mwJN8">rtrim</span><span class="p" id="mwJOA">(</span><span class="nx" id="mwJOE">ltrim</span><span class="p" id="mwJOI">(</span><span class="nx" id="mwJOM">s</span><span class="p" id="mwJOQ">));</span> <span class="p" id="mwJOU">}</span>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:
<span id="mwJPA"></span><span class="cp" id="mwJPE">#include</span><span class="w" id="mwJPI"> </span><span class="cpf" id="mwJPM"><ctype.h></span> <span class="cp" id="mwJPQ">#include</span><span class="w" id="mwJPU"> </span><span class="cpf" id="mwJPY"><string.h></span> <span class="kt" id="mwJPc">void</span><span class="w" id="mwJPg"> </span><span class="nf" id="mwJPk">rtrim</span><span class="p" id="mwJPo">(</span><span class="kt" id="mwJPs">char</span><span class="o" id="mwJPw">*</span><span class="w" id="mwJP0"> </span><span class="n" id="mwJP4">str</span><span class="p" id="mwJP8">)</span><span class="w" id="mwJQA"> </span><span class="p" id="mwJQE">{</span> <span class="w" id="mwJQI"> </span><span class="kt" id="mwJQM">char</span><span class="o" id="mwJQQ">*</span><span class="w" id="mwJQU"> </span><span class="n" id="mwJQY">s</span><span class="p" id="mwJQc">;</span> <span class="w" id="mwJQg"> </span><span class="n" id="mwJQk">s</span><span class="w" id="mwJQo"> </span><span class="o" id="mwJQs">=</span><span class="w" id="mwJQw"> </span><span class="n" id="mwJQ0">str</span><span class="w" id="mwJQ4"> </span><span class="o" id="mwJQ8">+</span><span class="w" id="mwJRA"> </span><span class="n" id="mwJRE">strlen</span><span class="p" id="mwJRI">(</span><span class="n" id="mwJRM">str</span><span class="p" id="mwJRQ">);</span> <span class="w" id="mwJRU"> </span><span class="k" id="mwJRY">while</span><span class="w" id="mwJRc"> </span><span class="p" id="mwJRg">(</span><span class="o" id="mwJRk">--</span><span class="n" id="mwJRo">s</span><span class="w" id="mwJRs"> </span><span class="o" id="mwJRw">>=</span><span class="w" id="mwJR0"> </span><span class="n" id="mwJR4">str</span><span class="p" id="mwJR8">)</span><span class="w" id="mwJSA"> </span><span class="p" id="mwJSE">{</span> <span class="w" id="mwJSI"> </span><span class="k" id="mwJSM">if</span><span class="w" id="mwJSQ"> </span><span class="p" id="mwJSU">(</span><span class="o" id="mwJSY">!</span><span class="n" id="mwJSc">isspace</span><span class="p" id="mwJSg">(</span><span class="o" id="mwJSk">*</span><span class="n" id="mwJSo">s</span><span class="p" id="mwJSs">))</span><span class="w" id="mwJSw"> </span><span class="p" id="mwJS0">{</span> <span class="w" id="mwJS4"> </span><span class="k" id="mwJS8">break</span><span class="p" id="mwJTA">;</span> <span class="w" id="mwJTE"> </span><span class="p" id="mwJTI">}</span> <span class="w" id="mwJTM"> </span><span class="o" id="mwJTQ">*</span><span class="n" id="mwJTU">s</span><span class="w" id="mwJTY"> </span><span class="o" id="mwJTc">=</span><span class="w" id="mwJTg"> </span><span class="mi" id="mwJTk">0</span><span class="p" id="mwJTo">;</span> <span class="w" id="mwJTs"> </span><span class="p" id="mwJTw">}</span> <span class="p" id="mwJT0">}</span> <span class="kt" id="mwJT4">void</span><span class="w" id="mwJT8"> </span><span class="nf" id="mwJUA">ltrim</span><span class="p" id="mwJUE">(</span><span class="kt" id="mwJUI">char</span><span class="o" id="mwJUM">*</span><span class="w" id="mwJUQ"> </span><span class="n" id="mwJUU">str</span><span class="p" id="mwJUY">)</span><span class="w" id="mwJUc"> </span><span class="p" id="mwJUg">{</span> <span class="w" id="mwJUk"> </span><span class="kt" id="mwJUo">size_t</span><span class="w" id="mwJUs"> </span><span class="n" id="mwJUw">n</span><span class="p" id="mwJU0">;</span> <span class="w" id="mwJU4"> </span><span class="n" id="mwJU8">n</span><span class="w" id="mwJVA"> </span><span class="o" id="mwJVE">=</span><span class="w" id="mwJVI"> </span><span class="mi" id="mwJVM">0</span><span class="p" id="mwJVQ">;</span> <span class="w" id="mwJVU"> </span><span class="k" id="mwJVY">while</span><span class="w" id="mwJVc"> </span><span class="p" id="mwJVg">(</span><span class="n" id="mwJVk">str</span><span class="p" id="mwJVo">[</span><span class="n" id="mwJVs">n</span><span class="p" id="mwJVw">]</span><span class="w" id="mwJV0"> </span><span class="o" id="mwJV4">&&</span><span class="w" id="mwJV8"> </span><span class="n" id="mwJWA">isspace</span><span class="p" id="mwJWE">((</span><span class="kt" id="mwJWI">unsigned</span><span class="w" id="mwJWM"> </span><span class="kt" id="mwJWQ">char</span><span class="p" id="mwJWU">)</span><span class="w" id="mwJWY"> </span><span class="n" id="mwJWc">str</span><span class="p" id="mwJWg">[</span><span class="n" id="mwJWk">n</span><span class="p" id="mwJWo">]))</span><span class="w" id="mwJWs"> </span><span class="p" id="mwJWw">{</span> <span class="w" id="mwJW0"> </span><span class="n" id="mwJW4">n</span><span class="o" id="mwJW8">++</span><span class="p" id="mwJXA">;</span> <span class="w" id="mwJXE"> </span><span class="p" id="mwJXI">}</span> <span class="w" id="mwJXM"> </span><span class="n" id="mwJXQ">memmove</span><span class="p" id="mwJXU">(</span><span class="n" id="mwJXY">str</span><span class="p" id="mwJXc">,</span><span class="w" id="mwJXg"> </span><span class="n" id="mwJXk">str</span><span class="w" id="mwJXo"> </span><span class="o" id="mwJXs">+</span><span class="w" id="mwJXw"> </span><span class="n" id="mwJX0">n</span><span class="p" id="mwJX4">,</span><span class="w" id="mwJX8"> </span><span class="n" id="mwJYA">strlen</span><span class="p" id="mwJYE">(</span><span class="n" id="mwJYI">str</span><span class="p" id="mwJYM">)</span><span class="w" id="mwJYQ"> </span><span class="o" id="mwJYU">-</span><span class="w" id="mwJYY"> </span><span class="n" id="mwJYc">n</span><span class="w" id="mwJYg"> </span><span class="o" id="mwJYk">+</span><span class="w" id="mwJYo"> </span><span class="mi" id="mwJYs">1</span><span class="p" id="mwJYw">);</span> <span class="p" id="mwJY0">}</span> <span class="kt" id="mwJY4">void</span><span class="w" id="mwJY8"> </span><span class="nf" id="mwJZA">trim</span><span class="p" id="mwJZE">(</span><span class="kt" id="mwJZI">char</span><span class="o" id="mwJZM">*</span><span class="w" id="mwJZQ"> </span><span class="n" id="mwJZU">str</span><span class="p" id="mwJZY">)</span><span class="w" id="mwJZc"> </span><span class="p" id="mwJZg">{</span> <span class="w" id="mwJZk"> </span><span class="n" id="mwJZo">rtrim</span><span class="p" id="mwJZs">(</span><span class="n" id="mwJZw">str</span><span class="p" id="mwJZ0">);</span> <span class="w" id="mwJZ4"> </span><span class="n" id="mwJZ8">ltrim</span><span class="p" id="mwJaA">(</span><span class="n" id="mwJaE">str</span><span class="p" id="mwJaI">);</span> <span class="p" id="mwJaM">}</span>The open source C++ library Boost has several trim variants, including a standard one:
<span id="mwJa0"></span><span class="cp" id="mwJa4">#include</span><span class="w" id="mwJa8"> </span><span class="cpf" id="mwJbA"><boost/algorithm/string/trim.hpp></span> <span class="n" id="mwJbE">trimmed</span><span class="w" id="mwJbI"> </span><span class="o" id="mwJbM">=</span><span class="w" id="mwJbQ"> </span><span class="n" id="mwJbU">boost</span><span class="o" id="mwJbY">::</span><span class="n" id="mwJbc">algorithm</span><span class="o" id="mwJbg">::</span><span class="n" id="mwJbk">trim_copy</span><span class="p" id="mwJbo">(</span><span class="s" id="mwJbs">"string"</span><span class="p" id="mwJbw">);</span>
With boost's function named simply trim the input sequence is modified in-place, and returns no result.
Another open source C++ library Qt, has several trim variants, including a standard one:
<span id="mwJcg"></span><span class="cp" id="mwJck">#include</span><span class="w" id="mwJco"> </span><span class="cpf" id="mwJcs"><QString></span> <span class="n" id="mwJcw">trimmed</span><span class="w" id="mwJc0"> </span><span class="o" id="mwJc4">=</span><span class="w" id="mwJc8"> </span><span class="n" id="mwJdA">s</span><span class="p" id="mwJdE">.</span><span class="n" id="mwJdI">trimmed</span><span class="p" id="mwJdM">();</span>
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:
<span id="mwJeI"></span><span class="w" id="mwJeM"> </span><span class="kr" id="mwJeQ">import</span><span class="w" id="mwJeU"> </span><span class="nn" id="mwJeY">Data.Char</span><span class="w" id="mwJec"> </span><span class="p" id="mwJeg">(</span><span class="nf" id="mwJek">isSpace</span><span class="p" id="mwJeo">)</span> <span class="w" id="mwJes"> </span><span class="n" id="mwJew">trim</span><span class="w" id="mwJe0"> </span><span class="ow" id="mwJe4">::</span><span class="w" id="mwJe8"> </span><span class="kt" id="mwJfA">String</span><span class="w" id="mwJfE"> </span><span class="ow" id="mwJfI">-></span><span class="w" id="mwJfM"> </span><span class="kt" id="mwJfQ">String</span> <span class="w" id="mwJfU"> </span><span class="n" id="mwJfY">trim</span><span class="w" id="mwJfc"> </span><span class="ow" id="mwJfg">=</span><span class="w" id="mwJfk"> </span><span class="n" id="mwJfo">f</span><span class="w" id="mwJfs"> </span><span class="o" id="mwJfw">.</span><span class="w" id="mwJf0"> </span><span class="n" id="mwJf4">f</span> <span class="w" id="mwJf8"> </span><span class="kr" id="mwJgA">where</span><span class="w" id="mwJgE"> </span><span class="n" id="mwJgI">f</span><span class="w" id="mwJgM"> </span><span class="ow" id="mwJgQ">=</span><span class="w" id="mwJgU"> </span><span class="n" id="mwJgY">reverse</span><span class="w" id="mwJgc"> </span><span class="o" id="mwJgg">.</span><span class="w" id="mwJgk"> </span><span class="n" id="mwJgo">dropWhile</span><span class="w" id="mwJgs"> </span><span class="n" id="mwJgw">isSpace</span>
may be interpreted as follows: f drops the preceding whitespace, and reverses the string. f is then again applied to its own output. The type signature (the second line) is optional.
J
The trim algorithm in J is a functional description:
<span id="mwJhY"></span><span class="w" id="mwJhc"> </span><span class="nv" id="mwJhg">trim</span><span class="w" id="mwJhk"> </span><span class="o" id="mwJho">=.</span><span class="w" id="mwJhs"> </span><span class="o" id="mwJhw">#~</span><span class="w" id="mwJh0"> </span><span class="o" id="mwJh4">[:</span><span class="w" id="mwJh8"> </span><span class="p" id="mwJiA">(</span><span class="o" id="mwJiE">+./\</span><span class="w" id="mwJiI"> </span><span class="o" id="mwJiM">*.</span><span class="w" id="mwJiQ"> </span><span class="o" id="mwJiU">+./\.</span><span class="p" id="mwJiY">)</span><span class="w" id="mwJic"> </span><span class="s" id="mwJig">' '</span><span class="o" id="mwJik">&~:</span>
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:
<span id="mwJjQ"></span><span class="nb" id="mwJjU">String</span><span class="p" id="mwJjY">.</span><span class="nx" id="mwJjc">prototype</span><span class="p" id="mwJjg">.</span><span class="nx" id="mwJjk">trim</span><span class="w" id="mwJjo"> </span><span class="o" id="mwJjs">=</span><span class="w" id="mwJjw"> </span><span class="kd" id="mwJj0">function</span><span class="p" id="mwJj4">()</span><span class="w" id="mwJj8"> </span><span class="p" id="mwJkA">{</span> <span class="w" id="mwJkE"> </span><span class="k" id="mwJkI">return</span><span class="w" id="mwJkM"> </span><span class="k" id="mwJkQ">this</span><span class="p" id="mwJkU">.</span><span class="nx" id="mwJkY">replace</span><span class="p" id="mwJkc">(</span><span class="sr" id="mwJkg">/^\s+/g</span><span class="p" id="mwJkk">,</span><span class="w" id="mwJko"> </span><span class="s2" id="mwJks">""</span><span class="p" id="mwJkw">).</span><span class="nx" id="mwJk0">replace</span><span class="p" id="mwJk4">(</span><span class="sr" id="mwJk8">/\s+$/g</span><span class="p" id="mwJlA">,</span><span class="w" id="mwJlE"> </span><span class="s2" id="mwJlI">""</span><span class="p" id="mwJlM">);</span> <span class="p" id="mwJlQ">};</span>Perl
Perl 5 has no built-in trim function. However, the functionality is commonly achieved using regular expressions.
Example:
<span id="mwJls"></span><span class="nv" id="mwJlw">$string</span><span class="w" id="mwJl0"> </span><span class="o" id="mwJl4">=~</span><span class="w" id="mwJl8"> </span><span class="sr" id="mwJmA">s/^\s+//</span><span class="p" id="mwJmE">;</span><span class="w" id="mwJmI"> </span><span class="c1" id="mwJmM"># remove leading whitespace</span> <span class="nv" id="mwJmQ">$string</span><span class="w" id="mwJmU"> </span><span class="o" id="mwJmY">=~</span><span class="w" id="mwJmc"> </span><span class="sr" id="mwJmg">s/\s+$//</span><span class="p" id="mwJmk">;</span><span class="w" id="mwJmo"> </span><span class="c1" id="mwJms"># remove trailing whitespace</span>
or:
<span id="mwJm8"></span><span class="nv" id="mwJnA">$string</span><span class="w" id="mwJnE"> </span><span class="o" id="mwJnI">=~</span><span class="w" id="mwJnM"> </span><span class="sr" id="mwJnQ">s/^\s+|\s+$//g</span><span class="w" id="mwJnU"> </span><span class="p" id="mwJnY">;</span><span class="w" id="mwJnc"> </span><span class="c1" id="mwJng"># remove both leading and trailing whitespace</span>
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:
chopremoves the last character from a string and returns it.chompremoves the trailing newline character(s) from a string if present. (What constitutes a newline is $INPUT_RECORD_SEPARATOR dependent).
In Raku, the upcoming sister language of Perl, strings have a trim method.
Example:
<span id="mwJpA"></span><span class="nv" id="mwJpE">$string</span> = <span class="nv" id="mwJpI">$string</span>.<span class="nb" id="mwJpM">trim</span>; <span class="c1" id="mwJpQ"># remove leading and trailing whitespace</span> <span class="nv" id="mwJpU">$string</span> .= <span class="nb" id="mwJpY">trim</span>; <span class="c1" id="mwJpc"># same thing</span>
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:
<span id="mwJqI"></span><span class="k" id="mwJqM">set</span><span class="w" id="mwJqQ"> </span>string<span class="w" id="mwJqU"> </span>onomatopoeia <span class="k" id="mwJqY">set</span><span class="w" id="mwJqc"> </span>trimmed<span class="w" id="mwJqg"> </span><span class="k" id="mwJqk">[</span><span class="nb" id="mwJqo">string</span><span class="w" id="mwJqs"> </span>trim<span class="w" id="mwJqw"> </span><span class="nv" id="mwJq0">$string</span><span class="w" id="mwJq4"> </span>aeiou<span class="k" id="mwJq8">]</span><span class="w" id="mwJrA"> </span><span class="k" id="mwJrE">;</span><span class="c" id="mwJrI"># result is nomatop</span> <span class="k" id="mwJrM">set</span><span class="w" id="mwJrQ"> </span>r_trimmed<span class="w" id="mwJrU"> </span><span class="k" id="mwJrY">[</span><span class="nb" id="mwJrc">string</span><span class="w" id="mwJrg"> </span>trimright<span class="w" id="mwJrk"> </span><span class="nv" id="mwJro">$string</span><span class="w" id="mwJrs"> </span>aeiou<span class="k" id="mwJrw">]</span><span class="w" id="mwJr0"> </span><span class="k" id="mwJr4">;</span><span class="c" id="mwJr8"># result is onomatop</span> <span class="k" id="mwJsA">set</span><span class="w" id="mwJsE"> </span>l_trimmed<span class="w" id="mwJsI"> </span><span class="k" id="mwJsM">[</span><span class="nb" id="mwJsQ">string</span><span class="w" id="mwJsU"> </span>trimleft<span class="w" id="mwJsY"> </span><span class="nv" id="mwJsc">$string</span><span class="w" id="mwJsg"> </span>aeiou<span class="k" id="mwJsk">]</span><span class="w" id="mwJso"> </span><span class="k" id="mwJss">;</span><span class="c" id="mwJsw"># result is nomatopoeia</span>
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 one space.
Example:
<span id="mwJtU"></span><span class="nt" id="mwJtY"><xsl:variable</span><span class="w" id="mwJtc"> </span><span class="na" id="mwJtg">name=</span><span class="s" id="mwJtk">'trimmed'</span><span class="nt" id="mwJto">></span> <span class="w" id="mwJts"> </span><span class="nt" id="mwJtw"><xsl:value-of</span><span class="w" id="mwJt0"> </span><span class="na" id="mwJt4">select=</span><span class="s" id="mwJt8">'normalize-space(string)'</span><span class="nt" id="mwJuA">/></span> <span class="nt" id="mwJuE"></xsl:variable></span>
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.