# R-Operators: Überblick zu R-Operatoren

Operatoren sind grundlegende Bausteine jeder Programmiersprache, einschließlich R. Mithilfe von R-Operatoren können Sie Zuweisungen ausführen, arithmetische Berechnungen durchführen sowie Vergleiche und sogar logische Ausdrücke evaluieren.

## Was genau sind R-Operatoren?

R-Operators sind **spezielle Symbole oder Zeichenfolgen**, die dazu verwendet werden, Operationen auf Werten und Variablen durchzuführen. Diese Operationen können arithmetische Berechnungen, Vergleiche, Zuweisungen oder eine Reihe weiterer Aktionen umfassen. Operatoren spielen eine entscheidende Rolle in der Datentransformation, -manipulation und -analyse in R und bilden einen Grundpfeiler der [R-Programmierung](https://www.ionos.at/digitalguide/websites/web-entwicklung/r-programmierung/).

Tipp R eignet sich für eine Vielzahl verschiedener Projekte. Wenn Sie eines Ihrer Projekte online bringen möchten, kann ein eigener Webspace die Lösung sein. Bei IONOS können Sie einen [Webspace mieten](https://www.ionos.at/hosting/webspace "Webspace mieten") und so professionelle Webprojekte hosten.

## Typen von R-Operatoren

R-Operators können **abhängig von ihrer Funktionalität** in verschiedene Typen unterteilt werden. Beachten Sie, dass diese Aufzählung nicht abschließend ist, aber die wichtigsten Arten von Operatoren in R enthält.

- **Arithmetische Operatoren**: Sie werden für arithmetische Berechnungen verwendet.
- **Logische Operatoren**: Logical Operators in R bzw. logische Operatoren werden verwendet, um Wahrheitswerte zu vergleichen und logische Ausdrücke zu evaluieren. Sie liefern einen Wahrheitswert zurück.
- **Bitweise Operatoren**: Sie ermöglichen die Manipulation von Bits in einer Zahl.
- **Zuweisungsoperatoren**: Zuweisungsoperatoren werden verwendet, um Werte Variablen zuzuweisen.
- **Vergleichsoperatoren**: Diese Art von R-Operators wird verwendet, um Werte zu vergleichen und logische Ausdrücke zu erstellen.

Anders als in vielen anderen Programmiersprachen gibt es in R **keinen expliziten Inkrement- oder Dekrementoperator**. Wenn Sie eine derartige Funktionalität beispielsweise in For- oder [While-Loops in R](https://www.ionos.at/digitalguide/websites/web-entwicklung/r-while-loop/) benötigen, können Sie eine Addition bzw. Subtraktion mit 1 vornehmen.

## R: Arithmetische Operatoren

Arithmetische Operatoren werden verwendet, um **mathematische Berechnungen** wie beispielsweise die Grundrechenarten durchzuführen.

<table>
  <thead>
    <tr>
      <th><strong>Operator</strong></th>
      <th><strong>Beschreibung</strong></th>
      <th><strong>Beispiel</strong></th>
      <th><strong>Ergebnis</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`+`</td>
      <td>Addition von Zahlen</td>
      <td>`5 + 3`</td>
      <td>`8`</td>
    </tr>
    <tr>
      <td>`-`</td>
      <td>Subtraktion vom Zahlen</td>
      <td>`10 – 5`</td>
      <td>`5`</td>
    </tr>
    <tr>
      <td>`*`</td>
      <td>Multiplikation von Zahlen</td>
      <td>`3* 5`</td>
      <td>`15`</td>
    </tr>
    <tr>
      <td>`/`</td>
      <td>Division von Zahlen</td>
      <td>`10 / 2`</td>
      <td>`5`</td>
    </tr>
    <tr>
      <td>`%%`</td>
      <td>Modulo; liefert den Rest nach einer Division</td>
      <td>`10%% 4`</td>
      <td>`2`</td>
    </tr>
    <tr>
      <td>`%/%`</td>
      <td>Ganzzahldivision</td>
      <td>`11 %/% 3`</td>
      <td>`3`</td>
    </tr>
    <tr>
      <td>`^`</td>
      <td>Exponentiation</td>
      <td>`2 ^ 3`</td>
      <td>`8`</td>
    </tr>
  </tbody>
</table>

### Arithmetische R-Operators im Code

```R
a <- 7
b <- 3
addition <- a + b
subtraktion <- a - b
multiplikation <- a * b
division <- a / b
modulo <- a %% b
ganzzahldivision <- a %/% b
exponentiation <- 2^3
```

## R: Logische Operatoren

Logical Operators werden in R verwendet, um **Wahrheitswerte zu vergleichen** und logische Ausdrücke zu evaluieren. Sie liefern als Ergebnis immer einen Wahrheitswert, der entweder *TRUE* oder *FALSE* sein kann.

<table>
  <thead>
    <tr>
      <th><strong>Operator</strong></th>
      <th><strong>Beschreibung</strong></th>
      <th><strong>Beispiel</strong></th>
      <th><strong>Ergebnis</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`&`</td>
      <td>Logisches UND; liefert *TRUE*, wenn beide Werte *TRUE* sind</td>
      <td>`TRUE & FALSE`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`</td><td>`</td>
      <td>Pipe-Operator in R für logisches ODER; liefert *TRUE*, wenn einer der beiden Werte *TRUE* ist</td>
      <td>`TRUE </td></tr><tr><td>`!`</td><td>Logisches NICHT; invertiert Wahrheitswert </td><td>`!TRUE`</td><td>`FALSE`</td>
    </tr>
  </tbody>
</table>

### Codebeispiele für Logical Operators in R

```R
x <- TRUE
y <- FALSE
und_operator <- x & y
oder_operator <- x | y
nicht_operator <- !x
```

## Bitweise Operatoren

Bitweise Operatoren ermöglichen die Manipulation von Bits in einer Zahl. Um zu verstehen, wie diese Operatoren genau funktionieren, benötigen Sie ein fundiertes Wissen über das [Binärsystem](https://www.ionos.at/digitalguide/websites/web-entwicklung/binaercode/), das Zahlensystem zur Basis 2.

<table>
  <thead>
    <tr>
      <th><strong>Operator</strong></th>
      <th><strong>Beschreibung</strong></th>
      <th><strong>Beispiel</strong></th>
      <th><strong>Ergebnis</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`bitwAnd`</td>
      <td>Bitweises UND</td>
      <td>`bitwAnd(5,3)`</td>
      <td>`1`</td>
    </tr>
    <tr>
      <td>`bitwOr`</td>
      <td>Bitweises ODER</td>
      <td>`bitwOr(5,3)`</td>
      <td>`7`</td>
    </tr>
    <tr>
      <td>`bitwXor`</td>
      <td>Bitweises XOR (Exklusives Oder)</td>
      <td>`bitwXor(5,3)`</td>
      <td>`6`</td>
    </tr>
    <tr>
      <td>`bitwNot`</td>
      <td>Bitweises NOT</td>
      <td>`bitwNot(5)`</td>
      <td>`-6`</td>
    </tr>
    <tr>
      <td>`bitwShiftL`</td>
      <td>Bitweiser Linksshift -&gt; Bitshift um die Anzahl der Bits, die im zweiten Parameter angegeben werden, nach links</td>
      <td>`bitwShiftL(5, 1)`</td>
      <td>`10`</td>
    </tr>
    <tr>
      <td>`bitwShiftR`</td>
      <td>Bitweiser Rechtsshift -&gt; Bitshift um die Anzahl der Bits, die im ersten Parameter angegeben werden, nach rechts</td>
      <td>`bitwShiftR(5, 1)`</td>
      <td>`2`</td>
    </tr>
  </tbody>
</table>

### Bitweise R-Operatoren im Code

```R
a <- 5
b <- 3
bitweises_und <- bitwAnd(a, b)
bitweises_oder <- bitwOr(a, b)
bitweises_xor <- bitwXor(a, b)
bitweises_nicht <- bitwNot(a)
linksschieben <- bitwShiftL(a, 1)
rechtsschieben <- bitwShiftR(a, 1)
```

## R: Vergleichsoperatoren

Vergleichsoperatoren werden verwendet, um Werte zu vergleichen. Als Ergebnis liefern Sie einen Booleschen Wert, also entweder *TRUE* oder *FALSE*.

<table>
  <thead>
    <tr>
      <th><strong>Operator</strong></th>
      <th><strong>Beschreibung</strong></th>
      <th><strong>Beispiel</strong></th>
      <th><strong>Ergebnis</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`==`</td>
      <td>Vergleicht zwei Werte auf Gleichheit</td>
      <td>`5 == 3`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`!=`</td>
      <td>Vergleicht zwei Werte auf Ungleichheit</td>
      <td>`5 != 3`</td>
      <td>`TRUE`</td>
    </tr>
    <tr>
      <td>`<`</td>
      <td>Vergleicht, ob der linke Wert kleiner ist als der rechte</td>
      <td>`5 < 3`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`>`</td>
      <td>Vergleicht, ob der linke Wert größer ist als der rechte</td>
      <td>`5 &gt; 3`</td>
      <td>`TRUE`</td>
    </tr>
    <tr>
      <td>`<=`</td>
      <td>Vergleicht, ob der linke Wert kleiner als der rechte oder genauso groß ist</td>
      <td>`5 <= 3`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`>=`</td>
      <td>Vergleicht, ob der linke Wert größer als der rechte oder genauso groß ist</td>
      <td>`5 &gt;= 3`</td>
      <td>`TRUE`</td>
    </tr>
  </tbody>
</table>

### Vergleichsoperatoren im Code

```R
x <- 5
y <- 3
gleich <- x == y
ungleich <- x != y
kleiner_als <- x < y
groesser_als <- x > y
kleiner_oder_gleich <- x <= y
groesser_oder_gleich <- x >= y
```

## R: Zuweisungsoperatoren

Zuweisungsoperatoren werden verwendet, um **Variablen bestimmte Werte zuzuweisen**. Sie sind ein essenzieller Bestandteil jeder Programmiersprache. In R gibt es verschiedene Zuweisungsoperatoren, meistens wird jedoch der `<-`-Operator genutzt.

<table>
  <thead>
    <tr>
      <th><strong>Operator</strong></th>
      <th><strong>Beschreibung</strong></th>
      <th><strong>Beispiel</strong></th>
      <th><strong>Ergebnis</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`=`</td>
      <td>Zuweisungsoperator auf Top-Level-Ebene, der vor allem in Funktionen genutzt wird, um Argumente zuzuweisen</td>
      <td>`matrix(1, nrow = 2)`</td>
      <td>Nach Ausführung gibt es keine Variable namens *nrow*.</td>
    </tr>
    <tr>
      <td>`<-`</td>
      <td>Pfeilzuweisungsoperator, der genutzt wird, um Variablen einfache numerische Werte oder komplexe Werte wie [R-Listen](https://www.ionos.at/digitalguide/websites/web-entwicklung/r-lists/) zuzuweisen und neue Objekte zu erstellen</td>
      <td>`matrix(1, nrow <- 2)`</td>
      <td>Nach Ausführung gibt es eine Variable namens *nrow*.</td>
    </tr>
    <tr>
      <td>`<<-`</td>
      <td>Zuweisungsoperator in Funktionen, der die Umgebung nach existierender Variablendefinition durchsucht und ansonsten eine neue Variable erstellt</td>
      <td>`a <<- 1`</td>
      <td>Wenn *a* bereits vorhanden ist, hat *a* nun den Wert 1, ansonsten wird *a* mit Wert 1 neu erstellt.</td>
    </tr>
  </tbody>
</table>

### Codebeispiele für die R-Zuweisungsoperatoren

```R
matrix(1, nrow=2)
b <- 3
test <- function() {
    a <<- 1
}
```


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