Vergleich von Programmiersprachen (Stringfunktionen)

Zeichenfolgenfunktionen werden in Computerprogrammiersprachen verwendet, um eine Zeichenfolge zu bearbeiten oder Informationen über eine Zeichenfolge abzufragen (einige tun beides).

Die meisten Programmiersprachen, die einen String-Datentyp haben, haben einige String-Funktionen, obwohl es innerhalb jeder Sprache andere Low-Level-Möglichkeiten geben kann, Strings direkt zu handhaben. In objektorientierten Sprachen werden String-Funktionen oft als Eigenschaften und Methoden von String-Objekten implementiert. In funktionalen und listenbasierten Sprachen wird eine Zeichenfolge als Liste (von Zeichencodes) dargestellt, daher könnten alle Listenmanipulationsverfahren als Zeichenfolgenfunktionen betrachtet werden. Solche Sprachen können jedoch auch eine Teilmenge expliziter string-spezifischer Funktionen implementieren.

Für Funktionen, die Strings manipulieren, haben moderne objektorientierte Sprachen wie C# und Java unveränderliche Strings und geben eine Kopie zurück (in neu zugewiesenen dynamischen Speicher), während andere, wie C, den ursprünglichen String manipulieren, es sei denn, der Programmierer kopiert Daten in einen neuen String. Siehe zum Beispiel Verkettung unten.

Das einfachste Beispiel für eine String-Funktion ist die length(string) Funktion. Diese Funktion gibt die Länge eines String-Literals zurück.

z.B length("hello world") würde zurückkehren 11.

Andere Sprachen können Zeichenfolgenfunktionen mit ähnlicher oder genau derselben Syntax oder Parametern oder Ergebnissen haben. Zum Beispiel wird die Längenfunktion in vielen Sprachen normalerweise dargestellt als len(string). Die folgende Liste der allgemeinen Funktionen soll dazu beitragen, diese Verwirrung einzudämmen.

Allgemeine Zeichenfolgenfunktionen (mehrsprachige Referenz)[edit]

String-Funktionen, die in vielen Sprachen gebräuchlich sind, sind unten aufgeführt, einschließlich der verschiedenen verwendeten Namen. Die folgende Liste allgemeiner Funktionen soll Programmierern helfen, die äquivalente Funktion in einer Sprache zu finden. Beachten Sie, dass die Verkettung von Zeichenfolgen und reguläre Ausdrücke auf separaten Seiten behandelt werden. Angaben in Guillemets (« … ») sind optional.

CharAt[edit]

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

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

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

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

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

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

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

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

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

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

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

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

Vergleichen (Ganzzahlergebnis)[edit]

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

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

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

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

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

Vergleichen (relationaler Operator-basiert, boolesches Ergebnis)[edit]

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

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

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

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

Verkettung[edit]

{ 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 Perl 5
"abc" . "def";      # returns "abcdef"
"Perl " . 5;        # returns "Perl 5"

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

Enthält[edit]

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

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

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

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

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

Gleichberechtigung[edit]

Testet, ob zwei Zeichenfolgen gleich sind. Siehe auch #Vergleichen und #Vergleichen. Beachten Sie, dass die Durchführung von Gleichheitsprüfungen über einen generischen Vergleich mit einem ganzzahligen Ergebnis nicht nur für den Programmierer verwirrend ist, sondern oft auch eine wesentlich teurere Operation ist; dies gilt insbesondere bei der Verwendung von "C-Strings".

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

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

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

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

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

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

Finden[edit]

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

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

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

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

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

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

Charakter finden[edit]

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

^a Bei gegebenem Zeichensatz gibt SCAN die Position des ersten gefundenen Zeichens zurück,^[19] während VERIFY die Position des ersten Zeichens zurückgibt, das nicht zur Menge gehört.^[20]

Format[edit]

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

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

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

#Example in Python 3.6+
pen = "pen"
f"My {pen} costs {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 PL/I */
put string(some_string) edit('My ', 'pen', ' costs', 19.99)(a,a,a,p'$$$V.99')
/* returns "My pen costs $19.99" */

Ungleichheit[edit]

Testet, ob zwei Zeichenfolgen ungleich sind. Siehe auch #Gleichstellung.

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

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

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

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

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

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

Index[edit]

sehen #Finden

Index von[edit]

sehen #Finden

anweisung[edit]

sehen #Finden

instrrev[edit]

sehen #rfind

beitreten[edit]

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

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

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

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

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

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

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

letzterindexvon[edit]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# 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 5
split(/spam/, 'Spam eggs spam spam and ham'); # ('Spam eggs ', ' ', ' and ham')
split(/X/, 'Spam eggs spam spam and ham');    # ('Spam eggs spam spam and ham')

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

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

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

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

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

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

# Examples in Python
"abc"[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 Perl 5
uc("Wiki means fast?");             # "WIKI MEANS FAST?"

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

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

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

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

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

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

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

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

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

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

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

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

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

#include 
trimmed = s.trimmed();

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

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

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

• chop entfernt das letzte Zeichen aus einem String und gibt es zurück.
• chomp entfernt das (die) nachgestellte(n) Newline-Zeichen aus einer Zeichenfolge, falls vorhanden. (Was einen Zeilenumbruch ausmacht, ist $INPUT_RECORD_SEPARATOR abhängig).

In Raku, der kommenden Schwestersprache von Perl, haben Strings eine trim Methode.

Beispiel:

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

Tcl[edit]

Die Tcl string Befehl hat drei relevante Unterbefehle: trim, trimright und trimleft. Für jeden dieser Befehle kann ein zusätzliches Argument angegeben werden: eine Zeichenfolge, die einen zu entfernenden Zeichensatz darstellt – der Standardwert ist Leerraum (Leerzeichen, Tabulator, Zeilenumbruch, Wagenrücklauf).

Beispiel für das Trimmen von Vokalen:

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

XSLT[edit]

XSLT beinhaltet die Funktion normalize-space(string) wodurch führende und nachgestellte Leerzeichen entfernt werden, zusätzlich zum Ersetzen jeglicher Leerzeichenfolgen (einschließlich Zeilenumbrüche) durch ein einzelnes Leerzeichen.

Beispiel:

 name='trimmed'>
    select='normalize-space(string)'/>

XSLT 2.0 enthält reguläre Ausdrücke, die einen weiteren Mechanismus zum Trimmen von Zeichenfolgen bieten.

Eine andere XSLT-Technik zum Trimmen ist die Verwendung des XPath 2.0 substring() Funktion.

Verweise[edit]