R-Strings im Überblick

Strings sind eine grund­le­gen­de Da­ten­struk­tur in R, die zum Dar­stel­len von Zei­chen­ket­ten und einzelner Buch­sta­ben genutzt wird. Anders als in anderen Pro­gram­mier­spra­chen gibt es in R keinen Datentyp namens String: Strings gehören dem R-Datentyp character an.

Was sind R-Strings?

Ob Sie gerade erst das Pro­gram­mie­ren lernen oder schon lange mit diversen Pro­gram­mier­spra­chen zu tun haben: An Strings kommen selbst erfahrene Pro­gram­mie­re­rin­nen und Pro­gram­mie­rer nicht vorbei.

Bei Strings handelt es sich um eine Da­ten­struk­tur innerhalb der Pro­gram­mier­spra­che R. Im Grunde genommen sind Strings nichts anderes als Zei­chen­ket­ten, die in den al­ler­meis­ten Sprachen – so auch in der R-Pro­gram­mie­rung – mit einfachen oder doppelten An­füh­rungs­zei­chen ge­kenn­zeich­net werden. Sie werden im Nor­mal­fall genutzt, um nicht­nu­me­ri­sche In­for­ma­tio­nen in Pro­gram­men zu speichern und zu ver­ar­bei­ten.

Wie erstellt man einen R-String?

Ein String kann in R ganz einfach in nur einer Zeile Code erstellt werden. Sie können sich hierbei aussuchen, ob Sie bei der In­itia­li­sie­rung Ihres R-Strings auf einfache oder doppelte An­füh­rungs­zei­chen zu­rück­grei­fen:

# String mit doppelten Anführungszeichen
string1 <- "Hallo Welt!"
# String mit einfachen Anführungszeichen
string2 <- 'Hello world!'

R-Strings be­ar­bei­ten: R-String-Functions in der Übersicht

Um mit Strings effizient zu arbeiten, stellt R Pro­gram­mie­ren­den eine Reihe von Ba­sis­funk­tio­nen bereit. Diese können genutzt werden, um ver­schie­de­ne Ope­ra­tio­nen mit und auf den Zei­chen­ket­ten durch­zu­füh­ren. Die wich­tigs­ten R-String-Ope­ra­ti­ons haben wir für Sie zu­sam­men­ge­stellt:

• substr(): Ex­tra­hiert eine Teil­zei­chen­ket­te aus einem R-String
• paste(): Kon­ka­te­niert Strings
• tolower() / toupper(): Kon­ver­tiert alle Zeichen eines Strings in Klein- oder Groß­buch­sta­ben
• strsplit(): Teilt einen R-String anhand eines vor­ge­ge­be­nen Trenn­zei­chens
• trimws(): Entfernt Leer­zei­chen am Anfang und Ende eines Strings
• gsub(): Ersetzt Muster in einem String durch eine über­ge­be­ne Zei­chen­ket­te
• nchar(): Ermittelt die Länge eines R-Strings

Wenn Sie bereits mit anderen Pro­gram­mier­spra­chen vertraut sind, dürfte Ihnen der Großteil der Funk­tio­nen bekannt vorkommen. So finden sich viele Pendants bei­spiels­wei­se für den Umgang mit Python-Strings.

substr()

Mit der Funktion substr() können Sie Teil­zei­chen­ket­ten aus Ihren R-Strings ex­tra­hie­ren. Hierfür übergeben Sie der Funktion als ersten Parameter Ihren String und als zweiten und dritten Parameter den Start- und Endindex Ihres ge­wünsch­ten Teil­strings. Beachten Sie, dass die In­di­zie­rung von R-Strings anders als in vielen anderen Sprachen bei 1 beginnt.

string <- "Hallo Welt"
print(substr(string, start=7, stop=10))

Das obige Code­bei­spiel gibt "Welt" auf dem Bild­schirm aus.

paste()

Die Funktion paste() wird in R dazu verwendet, zwei oder mehr Zei­chen­ket­ten zu kon­ka­te­nie­ren. Beachten Sie, dass + kein R-Operator für die Kon­ka­te­na­ti­on von Strings ist, da die Addition nur auf nu­me­ri­schen Da­ten­ty­pen definiert ist.

string <- "Hallo"
string2 <- "Welt"
print(paste(string+ string2))

Durch den Aufruf von paste() werden beide R-Strings kon­ka­te­niert, und folgende Ausgabe erscheint: "Hallo Welt".

tolower() / toupper()

Mithilfe der beiden R-String-Functions tolower() und toupper() können Sie alle Zeichen Ihrer Zei­chen­ket­te in Lower- bzw. Uppercase umwandeln. Beide Funk­tio­nen erwarten als Über­ga­be­pa­ra­me­ter den String, mit dem sie arbeiten sollen, und liefern Ihnen einen neuen String zurück.

string <- "Hallo Welt"
print(tolower(string))
print(toupper(string))

Das obige Programm gibt wie erwartet "hallo welt" und "HALLO WELT" auf dem Bild­schirm aus. Die Anwendung von Funk­tio­nen wie tolower() oder toupper() ist vor allem dann praktisch, wenn Eingaben case-sensitive ver­ar­bei­tet werden sollen.

strsplit()

Auch die strsplit()-Funktion in R ist er­fah­re­nen Pro­gram­mie­re­rin­nen und Pro­gram­mie­rern sicher schon einmal in einer anderen Sprache begegnet. So kennt auch Python eine Funktion namens split(). strsplit() erwartet als Über­ga­be­pa­ra­me­ter den String, den Sie anhand eines Trenn­zei­chens in Sub­strings aufteilen möchten, sowie das Trenn­zei­chen, das zur Trennung verwendet werden soll. Der Funk­ti­ons­auf­ruf liefert Ihnen selbst dann, wenn es nur einen Teil­string gibt, eine Liste der nun ent­stan­de­nen Sub­strings zurück.

string <- "Hallo Welt"
print(strsplit(string, " "))

Die Ausgabe des obigen Codes sieht wie folgt aus:

[[1]]
[1] "Hallo" "Welt"

Sie erhalten also eine Liste mit zwei Strings, da das Leer­zei­chen im ur­sprüng­li­chen String als Trenn­zei­chen genutzt wurde.

trimws()

Mit der Funktion trimws() können Sie Leer­zei­chen vor und hinter Ihrem R-String entfernen, was vor allem bei der Be­ar­bei­tung von Eingaben durch Nut­ze­rin­nen und Nutzer hilfreich sein kann, um un­er­wünsch­te und aus Versehen ein­ge­ge­be­ne Leer­zei­chen zu entfernen.

string <- "   Hallo Welt   "
print(trimws(string))

Der Code­ab­schnitt liefert den String "Hallo Welt" ohne Leer­zei­chen zu Beginn und Ende der Zei­chen­ket­te zurück.

gsub()

Eine weitere String-Operation in R lässt sich mit der Funktion gsub() umsetzen, die als ersten Über­ga­be­pa­ra­me­ter zunächst den zu er­set­zen­den Substring erwartet. Als zweiter Parameter wird die Zei­chen­ket­te angegeben, mit der die Vor­komm­nis­se des Sub­strings ersetzt werden sollen. Der dritte Über­ga­be­pa­ra­me­ter ist der String, auf den sich die Ersetzung bezieht.

string <- "Hallo Welt"
print(gsub("Welt", "User", string))

Nun wird durch die Ausgabe des im Code de­fi­nier­ten Strings nicht mehr die gesamte Welt, sondern nur ein User begrüßt, denn die Ausgabe des Programms lautet "Hallo User".

nchar()

Eine der wich­tigs­ten Stan­dard­funk­tio­na­li­tä­ten auf Strings stellt die Funktion nchar() bereit, die Ihnen die R-String-Length zu­rück­gibt.

string <- "Hallo Welt"
print(nchar(string))

Lassen Sie sich nicht von dem intuitiv viel­leicht sinn­vol­ler er­schei­nen­den R-Command length() verwirren: length() wird in R dazu genutzt, die Anzahl von Elementen in einem Objekt zu bestimmen, und liefert Ihnen somit nicht die R-String-Length zurück!

Steu­er­zei­chen und Escape-Sequenzen

Wenn Sie den Textfluss innerhalb Ihrer R-Strings zum Beispiel durch Zei­len­um­brü­che oder Ta­bu­la­to­ren be­ein­flus­sen möchten, müssen Sie von den so­ge­nann­ten Steu­er­zei­chen Gebrauch machen. Hierbei handelt es sich um eine vor­de­fi­nier­te Form von Escape-Sequenzen, die für die Ge­stal­tung von Text­aus­ga­ben häufig genutzt werden.

Auch besondere Zeichen wie die An­füh­rungs­zei­chen, die in der R-Syntax nor­ma­ler­wei­se als Anfang bzw. Ende eines Strings in­ter­pre­tiert würden, lassen sich mithilfe von Escape-Sequenzen innerhalb von Zei­chen­ket­ten ausgeben. Escape-Sequenzen sind durch einen führenden Backslash ge­kenn­zeich­net. Hier finden Sie die wichtigen Steu­er­zei­chen und Escape-Sequenzen in R:

• \n: Newline/Zei­len­um­bruch
• \t: Tabulator
• \: Backslash
• ": doppeltes An­füh­rungs­zei­chen
• ': einfaches An­füh­rungs­zei­chen