# R Data Types im Überblick: Diese R-Datentypen sollten Sie kennen

Wie in jeder anderen Programmiersprache existieren auch in der [R-Programmierung](https://www.ionos.at/digitalguide/websites/web-entwicklung/r-programmierung/ "Programmieren mit R") verschiedene Datentypen, die Programmierenden dabei helfen, ihre Daten zu strukturieren. Neben den Basic Data Types gibt es in R auch komplexere Datentypen.

## Wofür werden Datentypen in R benutzt?

Beim Programmieren geht es oftmals um die Verarbeitung von Daten. Damit diese Daten in sinnvoller Weise im Speicher abgelegt werden können, haben Entwicklerinnen und Entwickler in den allermeisten Sprachen die Wahl zwischen verschiedenen Datentypen. Beispiele für Datentypen sind Zahlen oder Zeichenketten.

Auf verschiedenen Datentypen sind in der Regel unterschiedliche [R-Operatoren](https://www.ionos.at/digitalguide/websites/web-entwicklung/r-operators/) definiert. Daher helfen Datentypen den Programmierenden auch dabei, ihre **Daten in angemessener Form zu verarbeiten** und somit die Effizienz von Programmen zu steigern.

## Die verschiedenen Datentypen in R

In R gibt es eine Reihe verschiedener Datentypen. Einige R-Datentypen dürften Ihnen, sofern Sie nicht gerade erst das [Programmieren lernen](https://www.ionos.at/digitalguide/websites/web-entwicklung/programmieren-lernen-einstieg-grundlagen/ "Programmieren lernen"), aus anderen **Programmiersprachen bekannt vorkommen**. Für einen Check des Data Types in R gibt es das R-Command *class()*, das eine beliebige Variable als Übergabeparameter entgegennimmt und den Datentyp dieser Variable zurückliefert.

### Numerische Datentypen

Numerische Datentypen gehören zu den **Basic Data Types in R** und werden genutzt, um Zahlenwerte abzubilden. Innerhalb der numerischen Datentypen wird zwischen *numeric* für reelle Zahlen, *integer* für Ganzzahlen und *complex* für komplexe Zahlen mit imaginärem Anteil unterschieden.

```R
x <- 3.14
y <- 42
z <- 3 + 2i
print(class(x))
print(class(y))
print(class(z))
```

Die Ausgabe dieses Codes sieht wie folgt aus:

```none
"numeric"
"numeric"
"complex"
```

An dieser Stelle wundern Sie sich vielleicht, wieso zwei Mal der Datentyp *numeric* ausgegeben wurde, obwohl es sich bei der Variable *y* um einen Integer bzw. eine Ganzzahl handelt. Das ist einfach erklärt: **Integer sind in R immer gleichzeitig *numeric***. Um dem Interpreter mitzuteilen, dass es sich tatsächlich um einen Integer handelt, müssen Sie Ihren Ganzzahlen das Suffix*L* anhängen:

```R
y <- 42L
print(class (y))
```

Nun liefert der obige Funktionsaufruf das erwartete Ergebnis:

```none
"integer"
```

### Zeichenketten

Um Text bzw. Zeichen darzustellen, können Sie auf einen Datentyp namens *character* zurückgreifen. Daten dieses Datentyps, die in [R Strings](https://www.ionos.at/digitalguide/websites/web-entwicklung/r-strings/) genannt werden, können Sie in R durch **einfache oder doppelte Anführungszeichen** kennzeichnen:

```R
x <- "Hallo Welt!"
y <- 'Hello world!'
print(class(x))
print(class(y))
```

Auch hier kann die `class()`-Funktion genutzt werden, um sich den Datentyp Ihrer Variablen anzeigen zu lassen:

```none
"character"
"character"
```

### Logische Datentypen

Variablen des logischen Datentyps, der in R unter der Bezeichnung *logical* bekannt ist, werden vom Interpreter zu `TRUE` oder `FALSE` ausgewertet. Auf diese Weise können **Bedingungen oder logische Ausdrücke** formalisiert werden. Dies ist oft nötig, um den Kontrollfluss des Programms zu steuern.

```R
x <- TRUE
y <- FALSE
print(class(x))
print(class(y))
```

Wenn Sie den Datentyp beider Variablen betrachten, sehen Sie, dass ihnen der R Data Type *logical* zugewiesen wurde:

```none
"logical"
"logical"
```

### Rohdaten

In R gibt es einen eigenen Datentyp, um sich Ihre **Variablen als Folge von Bytes** anzusehen. Dieser R Data Type trägt den Namen *raw*. Um Ihre Daten in Rohdaten zu konvertieren, können Sie die Funktion `charToRaw()` nutzen. Für den umgekehrten Anwendungsfall existiert die Funktion `rawToChar()`.

Folgender Code zeigt, wie ein String in eine Bytefolge konvertiert wird, die den Datentyp *raw* hat:

```R
x <- "Hallo Welt!"
y <- charToRaw(x)
print(y)
print(class(y))
```

Der obige Code gibt zunächst die Bytefolge in Hexadezimalzahlen auf dem Bildschirm aus. Im Anschluss sorgt der Aufruf von `class()` dafür, dass der Datentyp der Variable *y* angezeigt wird:

```none
48 61 6c 6c 6f 20 57 65 6c 74 21
"raw"
```

Hinweis In R können Sie Daten auch in einen anderen Datentyp konvertieren. Ein solcher Change von Data Types in R ist häufig sogar ausgesprochen einfach: Wenn Sie einen String haben, der aus einer Zahl besteht (z. B. “42”), können Sie durch einfache Addition von 0 dafür sorgen, dass der String in den Datentyp *numeric* umgewandelt wird.

## Datenstrukturen in R

Neben den R-Basic Data Types gibt es eine ganze Reihe verschiedener Datenstrukturen, die Programmierenden dabei helfen, Daten besser zu strukturieren. Diese **Datenstrukturen sind komplexer als die einfachen Datentypen** und, wie beispielsweise R Data Frames, anders als Data Types oft auch mehrdimensional.

Tipp Sie haben Lust bekommen auf die Programmierung in R? Bringen Sie Ihr nächstes R-Projekt mit individuell anpassbarem [Webspace-Hosting](https://www.ionos.at/hosting/webspace "Webspace Hosting") online!


This is a markdown version of: [https://www.ionos.at/digitalguide/websites/web-entwicklung/r-data-types/](https://www.ionos.at/digitalguide/websites/web-entwicklung/r-data-types/) for AI/LLM consumption.