Zeichenketten in R: paste, sprintf, gsub, substr & mehr

Zeichenketten in R erzeugen

Eine Zeichenkette ist in R Text zwischen Anführungszeichen. Doppelte und einfache Anführungszeichen funktionieren beide und bedeuten exakt dasselbe; die Konvention sind doppelte, mit Wechsel auf einfache, wenn der Text selbst ein doppeltes Anführungszeichen enthält:

name <- "Ada"
motto <- 'said "make it work" twice'
escaped <- "or escape \"quotes\" with a backslash"

cat(motto, "\n")
cat(escaped, "\n")

Backslash-Escapes funktionieren wie in den meisten Sprachen: \" für ein wörtliches Anführungszeichen, \n für einen Zeilenumbruch, \t für einen Tabulator, \\ für einen Backslash selbst.

Nun der Fehler, den jeder R-Einsteiger genau einmal macht: eine Zeichenkette mit length() nach ihrer Länge zu fragen.

s <- "hello"
cat(nchar(s), "\n")
cat(length(s), "\n")

nchar() zählt Zeichen - 5. length() zählt Vektorelemente, und eine einzelne Zeichenkette ist ein Vektor mit einem Element - also sagt es 1. In R ist alles ein Vektor, auch Text, und alle Funktionen auf dieser Seite arbeiten stillschweigend elementweise über ganze Zeichenvektoren. Das ist ein Feature, sobald du aufhörst, dich darüber zu wundern.

Zeichenketten verbinden: paste() und paste0()

R hat kein + für Zeichenketten. Verkettung erledigen paste(), das seine Argumente standardmäßig mit einem Leerzeichen verbindet, und paste0(), das ohne Trenner verbindet:

cat(paste("data", "science"), "\n")
cat(paste("data", "science", sep = "-"), "\n")
cat(paste0("file_", "2026"), "\n")

Weil paste vektorisiert ist, erzeugt die Übergabe eines Vektors viele Zeichenketten auf einmal - so generierst du Dateinamen, Beschriftungen und IDs in einer Zeile:

print(paste0("file_", 1:3))

Und das Argument collapse macht das Gegenteil: Es verschmilzt einen ganzen Vektor mit einem gewählten Trennzeichen zu einer einzigen Zeichenkette:

words <- c("ready", "set", "go")
cat(paste(words, collapse = "... "), "\n")

Merke dir die Trennung: sep steuert den Kleber zwischen Argumenten, collapse den Kleber zwischen den Elementen eines Vektors. Du kannst beides in einem Aufruf nutzen.

Formatieren mit sprintf()

Wenn du Zahlen formatiert in Text brauchst - feste Nachkommastellen, aufgefüllte Breiten -, geht paste() die Puste aus und sprintf() übernimmt. Es nutzt Formatcodes im C-Stil: %s für Zeichenketten, %d für ganze Zahlen, %f für Dezimalzahlen:

cat(sprintf("%s scored %d points (%.1f%%)\n", "Rosa", 87, 92.5))
cat(sprintf("%.3f\n", pi))
cat(sprintf("invoice %05d\n", 42))

%.1f heißt "eine Nachkommastelle", %.3f drei, und %05d füllt mit Nullen auf fünf Stellen auf. Ein verdoppeltes %% erzeugt ein wörtliches Prozentzeichen. sprintf() ist ebenfalls vektorisiert und kann daher eine ganze Wertespalte in einem Aufruf formatieren - siehe Ein- und Ausgabe für das Reporting-Muster sprintf() + cat().

Groß-/Kleinschreibung und Ausschnitte: toupper(), tolower(), substr()

Die Umwandlung der Schreibweise tut genau, was der Name sagt:

s <- "Programming in R"
cat(toupper(s), "\n")
cat(tolower(s), "\n")

tolower() verdient sich sein Geld beim Normalisieren unsauberer Daten vor Vergleichen - "Yes", "YES" und "yes" werden alle zum selben Wert.

substr(x, start, stop) extrahiert einen Ausschnitt nach Zeichenposition, gezählt ab 1 (R ist überall 1-basiert):

s <- "Programming in R"
cat(substr(s, 1, 11), "\n")
cat(substr(s, 16, 16), "\n")

Beide Endpunkte sind inklusiv: Positionen 1 bis 11 ergeben "Programming".

Suchen und Ersetzen: sub(), gsub() und grepl()

sub() ersetzt das erste Vorkommen eines Musters; gsub() ("global substitute") ersetzt alle:

s <- "good code, good tests, good docs"
cat(sub("good", "great", s), "\n")
cat(gsub("good", "great", s), "\n")

Ein kritisches Detail: Das Muster ist standardmäßig ein regulärer Ausdruck, kein wörtlicher Text. Regex-Zeichen wie ., *, ( und ? haben Sonderbedeutungen - ein nacktes . trifft jedes Zeichen. Wenn du den wörtlichen Text meinst, übergib fixed = TRUE:

cat(gsub(".", "-", "a.b.c", fixed = TRUE), "\n")
cat(gsub(".", "-", "a.b.c"), "\n")

Die erste Zeile ergibt a-b-c; die zweite ergibt -----, weil . als Regex jedes einzelne Zeichen getroffen hat. Bis du Regex gelernt hast, mach fixed = TRUE zu deinem Standard, dann erwischt es dich nie.

grepl() ersetzt nicht - es prüft, ob jedes Element passt, und gibt einen logischen Vektor zurück. Das macht es zum Standardwerkzeug für das Filtern von Text:

files <- c("report.csv", "notes.txt", "data.csv")
print(grepl(".csv", files, fixed = TRUE))
print(files[grepl(".csv", files, fixed = TRUE)])

Das erste Ergebnis markiert, welche Dateinamen .csv enthalten; das zweite nutzt diesen logischen Vektor, um nur die Treffer zu behalten.

Teilen und Trimmen: strsplit() und trimws()

strsplit() zerschneidet eine Zeichenkette an einem Trennzeichen. Seine eine Eigenheit: Es gibt eine Liste zurück, weil es viele Zeichenketten auf einmal teilen kann. Bei einer einzelnen Zeichenkette nimmst du mit [[1]] das erste Element:

parts <- strsplit("2026-08-07", "-")[[1]]
print(parts)
cat("year:", parts[1], "\n")

Und trimws() entfernt die Leerzeichen, in die reale Daten immer eingepackt ankommen:

raw <- "   padded input   "
cat("[", trimws(raw), "]\n", sep = "")

Standardmäßig trimmt es beide Enden; which = "left" oder "right" trimmt nur eine Seite (die Namen beziehen sich auf Anfang und Ende der Zeichenkette).

Die stringr-Alternative

Alles oben ist Base R - immer verfügbar, keine Installation. Das stringr-Paket des Tidyverse verpackt dieselben Operationen in ein konsistentes str_*-Namensschema, bei dem die Zeichenkette stets das erste Argument ist, was viele Leute leichter merkbar finden (siehe Pakete zur Installation):

library(stringr)

str_detect(files, "csv")            # like grepl(), data first
str_replace_all(s, "good", "great") # like gsub(), arguments reordered
str_length("hello")                 # like nchar()

Die Base-R-Zeichenkettenfunktionen lohnen sich trotzdem - du triffst sie in jedem Skript, jeder Stack-Overflow-Antwort und jeder je geschriebenen Fehlermeldung. Lerne zuerst die Base-Namen; greif zu stringr, wenn dich die uneinheitlichen Argumentreihenfolgen zu nerven beginnen.

Was du mitnimmst

• Zeichenketten nutzen konventionell doppelte Anführungszeichen; nchar() zählt Zeichen, length() zählt Vektorelemente.
• Verketten mit paste() / paste0(); sep klebt Argumente, collapse klebt einen Vektor zu einer Zeichenkette zusammen.
• sprintf() erledigt formatierte Ausgabe: %s, %d, %.2f.
• sub() ersetzt den ersten Treffer, gsub() alle Treffer, grepl() prüft auf Treffer - alle standardmäßig mit Regex, also fixed = TRUE für wörtlichen Text übergeben.
• strsplit() gibt eine Liste zurück (nimm [[1]]); trimws() säubert aufgefüllte Eingaben.

Als Nächstes: Text in deine Programme hinein- und wieder herausbekommen - Ausgabe mit print() und cat() sowie das Einlesen von Benutzereingaben.