Comparison of programming languages (string functions)

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

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

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

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

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

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

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

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

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

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

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

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

{ Example in Pascal }
'abc' + 'def';      // returns "abcdef"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Example in C#
String.Format("My {0} costs {1:C2}", "pen", 19.99); // returns "My pen costs $19.99"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Examples in Ya
"abcde"[0..3] // returns "abc"
"abcde"[0..8] // returns "abcde"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <string.h>
#include <ctype.h>

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

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

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

#include <boost/algorithm/string/trim.hpp>
trimmed = boost::algorithm::trim_copy("string");

#include <QString>
trimmed = s.trimmed();

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

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

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

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

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

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

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

<xsl:variable name='trimmed'>
   <xsl:value-of select='normalize-space(string)'/>
</xsl:variable>