This is documentation for Mathematica 4, which was
based on an earlier version of the Wolfram Language.
View current documentation (Version 11.1)

 Documentation /  Mathematica /  Das Mathematica Buch /  Die Prinzipien von Mathematica /  Zeichenketten und Zeichen /

Eigenschaften von ZeichenkettenZeichenkettenmuster

2.7.2 Operationen auf Zeichenketten

Mathematica bietet verschiedene Funktionen zur Manipulation von Zeichenketten. Die meisten dieser Funktionen behandeln Zeichenketten als Zeichenfolgen, und viele der Funktionen entsprechen den Funktionen zur Listenmanipulation.

Operationen auf vollständigen Zeichenketten

Sie können eine beliebige Anzahl von Zeichenketten mittels <> miteinander verbinden.

In[1]:= "aaaaaaa" <> "bbb" <> "cccccccccc"

Out[1]=

StringLength liefert die Anzahl von Zeichen in einer Zeichenkette.

In[2]:= StringLength[%]

Out[2]=

StringReverse kehrt die Reihenfolge der Zeichen in einer Zeichenkette um.

In[3]:= StringReverse["Eine Zeichenkette."]

Out[3]=

Teilzeichenketten herausnehmen und auslassen

StringTake und StringDrop für Zeichenketten entsprechen Take und Drop für Listen. Sie benutzen Mathematicas Standard-Folgen-Spezifikationen. So können Sie beispielsweise mit negativen Zahlen eine Zeichenposition vom Ende einer Zeichenkette aus bestimmen. Dabei ist das erste Zeichen einer Zeichenkette an Position 1.

Hier ist eine Beispiel-Zeichenkette.

In[4]:= alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Out[4]=

Dies zieht die ersten fünf Zeichen aus alpha heraus.

In[5]:= StringTake[alpha, 5]

Out[5]=

Hier ist das fünfte Zeichen in alpha.

In[6]:= StringTake[alpha, {5}]

Out[6]=

Dies entfernt die Zeichen 10 bis 2, gezählt vom Ende der Zeichenkette.

In[7]:= StringDrop[alpha, {-10, -2}]

Out[7]=

Einfügen in eine Zeichenkette

StringInsert[s, sneu, n] ist so konstruiert, daß es eine Zeichenkette produziert, deren n-tes Zeichen das erste Zeichen von sneu ist.

Dies erzeugt eine neue Zeichenkette, deren viertes Zeichen das erste der Zeichenkette "XX" ist.

In[8]:= StringInsert["abcdefgh", "XX", 4]

Out[8]=

Negative Positionen werden vom Ende der Zeichenkette aus gezählt.

In[9]:= StringInsert["abcdefgh", "XXX", -1]

Out[9]=

Jede Kopie von "XXX" wird an der angegebenen Position in der ursprünglichen Zeichenkette eingefügt.

In[10]:= StringInsert["abcdefgh", "XXX", {2, 4, -1}]

Out[10]=

Teile einer Zeichenkette ersetzen

Dies ersetzt die Zeichen 2 bis 6 durch die Zeichenkette "XXX".

In[11]:= StringReplacePart["abcdefgh", "XXX", {2, 6}]

Out[11]=

Dies ersetzt zwei Zeichenfolgen durch die Zeichenkette "XXX".

In[12]:= StringReplacePart["abcdefgh", "XXX", {{2, 3}, {5, -1}}]

Out[12]=

Nun sind die zwei Zeichenfolgen durch verschiedene Zeichenketten ersetzt.

In[13]:= StringReplacePart["abcdefgh", {"XXX", "YYYY"},
{{2, 3}, {5, -1}}]

Out[13]=

Positionen von Teilzeichenketten finden

Mit StringPosition können Sie herausfinden, wo eine bestimmte Teilzeichenkette innerhalb einer gegebenen Zeichenkette erscheint. StringPosition liefert eine Liste, deren Elemente jeweils einem Vorkommen der Teilzeichenkette entsprechen. Die Elemente bestehen aus Listen, die die Anfangs- und End-Zeichenpositionen der Teilzeichenkette liefert. Diese Listen liegen in der Form vor, die als Folgen- Spezifikationen in StringTake, StringDrop und StringReplacePart benutzt wird.

Dies liefert eine Liste der Positionen der Teilzeichenkette "abc".

In[14]:= StringPosition["abcdabcdaabcabcd", "abc"]

Out[14]=

Dies liefert lediglich das erste Vorkommen von "abc".

In[15]:= StringPosition["abcdabcdaabcabcd", "abc", 1]

Out[15]=

Dies zeigt, wo sowohl "abc" als auch "cd" erscheinen. Überlappungen zwischen diesen Zeichenketten werden berücksichtigt.

In[16]:= StringPosition["abcdabcdaabcabcd", {"abc", "cd"}]

Out[16]=

Teilzeichenketten nach Regeln ersetzen

Mit StringReplace lassen sich Teilzeichenketten in einer Zeichenkette ersetzen. StringReplace geht sequentiell durch eine Zeichenkette und testet Teilzeichenketten, die an aufeinanderfolgenden Zeichenpositionen beginnen. Bei jeder Teilzeichenkette werden die von Ihnen spezifizierten Transformationsregeln der Reihe nach versucht. Wenn irgendeine der Regeln anwendbar ist, wird die Teilzeichenkette ersetzt, und an der dahinterliegenden Position wird der Durchgang durch die Zeichenkette fortgesetzt.

Dies ersetzt alle Vorkommen des Zeichen a durch die Zeichenkette XX.

In[17]:= StringReplace["abcdabcdaabcabcd", "a" -> "XX"]

Out[17]=

Dies ersetzt abc durch Y und d durch XXX.

In[18]:= StringReplace["abcdabcdaabcabcd",
{"abc" -> "Y", "d" -> "XXX"}]

Out[18]=

Das erste Vorkommen von cde wird nicht ersetzt, weil es sich mit abc überlappt.

In[19]:= StringReplace["abcde abacde",
{"abc" -> "X", "cde" -> "Y"}]

Out[19]=

Von Groß-/Kleinschreibung unabhängige Operationen

Dies ersetzt alle Vorkommen von "die", unabhängig von der Groß-/Kleinschreibung.

In[20]:= StringReplace["Die Katze hat die Maus.",
"die" -> "eine", IgnoreCase -> True]

Out[20]=

Zeichenketten sortieren

Sort sortiert Zeichenketten in die „lexikografische" Reihenfolge.

In[21]:= Sort[{"Katze", "Fisch", "Katzenfisch", "katze"}]

Out[21]=

Eigenschaften von ZeichenkettenZeichenkettenmuster