groovy-lecture/skript/operatoren.md

# Operatoren
## Grundlegende Operatoren
Grundsätzlich bietet Groovy dieselben Operatoren an, die es auch in Java gibt. Groovy erweiteret die Menge an Operatoren, die Java einem zur Verfügung stellt jedoch nochmal um einige mehr, auf hier eingegangen wird. Zu den grundlegenden Operatoren gehören:

- Arithmetische Operatoren (-, +, *, **,…)
- Relationale Operatoren (==, !=, <, >,…)
- Logische Operatoren (&&, ||, !)
- Bitweise Operatoren (&, |, ^, ~)
- Bitweise Verschiebung (<<, >>,>>>)
- Konditionale Operatoren (!, ? :, ?: )

Wie bereits erwähnt, gibt es die meisten dieser Operatoren schon in Java. Deshalb setzen wir diese an dieser Stelle als bereits bekannt voraus. Auf die bisher unbekannten Operatoren wollen wir jedoch etwas genauer eingehen.

---
### 1. Exponentialoperator (**)
Dies ist ein relativ simpler Operator. Er wird verwendet, um eine gegebene Zahl auf eine bestimmte Potenz zu erhöhen:
````Groovy
def a = 2
def b = 3
println a**b // Ausgabe: 8 (Weil 2^3 = 8)
````

### 2. SicherheitsnavigationsOperator (?.):
Der Sicherheitsnavigationsoperator wird verwendet, um null-sichere Zugriff auf Objekteigenschaften, Methoden oder Array-Elemente zu ermöglichen. Ein bestimmter Ausdruck wird also nur ausgeführt, wenn das Objekt, auf das gerade zugegriffen wird nicht null ist. Somit wird eine NullPointerException vermieden. Ist das Objekt nämlich null, wird einfach null zurückgegeben und keine Exception geworfen. 
- Verwendung: **< Objekt >?.< Eigenschaft >**

````Groovy
class Person {
    String name
}
Person person = null
def name = person?.name
println name  // Ausgabe: null
````

### 3. Methodenreferenzoperator (.&):
Der Methodenreferenzoperator wird verwendet, um eine Methode als Closure zu referenzieren. Auf Closures wird später im Skript nochmal eingegangen. Dieser Operator ermöglicht es dem Programmierer Methoden als Objekte zu behandeln, die später wieder aufgerufen werden können. Dieses Feature ist mit Lambdas in Java vergleichbar.
Verwendung: **< Methode > { < Objekt >.&< Methode >()}**

````Groovy
class Person {
    def name
}

def getName(){
    name
}

def personen = [new Person(name: "Tom"), new Person(name: "Max"), new Person(name: "Tim")]
def names = personen.collect {it.&getName()} //Ausgabe: [Tom, Max, Tim]
````

### 4. Spread-Operator(*.):
Der Spread Operator wird verwendet, um eine Methode auf alle Elemente einer Colletion anzuwenden.
- Verwendung:
**< Collection >*.< Methode >**

````Groovy
class Person {
    def name
}

def getName(){
    name
}

def personen = [new Person(name: "Tom"), new Person(name: "Max"), new Person(name: "Tim")]
def names = personen*.getName()
println names //Ausgabe: [Tom, Max, Tim]
````

### 5. Spread-Map-Operator(*: )
Ermöglicht es die Inhalte einer Map in eine andere zu kopieren. Gibt es in der Map, in die hineinkopiert werden soll einen bestimmten Key schon, dann wird der Wert an der Stelle einfach ersetzt. 
 Verwendung: **def map2 = [< Element1 >, < Element2 >,… \*:< map1 >]**

 ````Groovy
 def map1: = [a: 1, b:3]
 def map2= [c: 4, b: 2, *:map1]
 println map2 //Ausgabe: [c:4, b:3, a:1]
 ````

### 6. Raumschiff-Operator (<=>):
Der Raumschiffoperator ist ähnlich zur compare() Methode in Java und wird verwendet, um zwei Werte miteinander zu vergleichen. 
Verwendung: **< Wert1 > <=> < Wert2 >**

- Gilt Wert1 < Wert2: Rückgabewert: -1
- Gilt Wert1 > Wert2: Rückgabewert: 1
- Gilt Wert1 == Wert2: Rückgabewert: 0

````Groovy
println 3 <=> 5 // Ausgabe: -1
println 5 <=> 5 // Ausgabe: 0
println 7 <=> 5 // Ausgabe: 1
````

### 7. Range-Operator(..)
Der Range Operator wird in Groovy verwendet, um eine Sequenz von Werten (Ganzzahlen/Chars) innerhalb eines bestimmten Bereiches zu erstellen. Hierbei gilt: Beide Werte sind inklusiv. Will man jedoch den rechten Wert ausschließen, muss man den Range-Exclusive-Operator (..<) verwenden. Es ist auch möglich innerhalb einer Range Sprünge in einem bestimmten Intervall zu machen. Dies erreicht man mit der **(< range >).step(n)**-Methode. 
- Verwendung **< Wert1 >..< Wert2 >**

````Groovy
def range = 1..5
println range.collect() // Ausgabe: [1, 2, 3, 4, 5]

def range2 = 1..<5
println range2.collect() // Ausgabe: [1, 2, 3, 4]

def range3 = (1..10).step 2
println range3.collect() // Ausgabe: [1, 3, 5, 7, 9]
````

### 8. Regex-Operatoren (=\~) / (==\~):
Die Regex-Operatoren werden verwendet, um zu prüfen, ob ein String mit einem Regulären Ausdruck (*kurz regex*) übereinstimmt. 
- **(\=~)**: Prüft, ob ein Teil des Strings mit dem regulären Ausdruck übereinstimmt.
- **(==\~)**: Prüft, ob der gesamte String mit dem regulären Ausdruck übereinstimmt.
- **(\~/String/)**: Wird zum definieren ddes regulären Ausdrucks verwendet

- Verwendung: **< String > ~= < Muster >**

````Groovy
def text = "Groovy ist toll!"
def pattern = ~/Groovy/

if (text =~ pattern) {
    println "Der Text entält das Muster."
}
else {
    println "Der Text enthält das Muster nicht."
} 
// Ausgabe: Der Text enthält das Muster.
````

Würde man jedoch den **(==\~)**-Operator benutzen, würde die Ausgabe wie folgt aussehen:

````Groovy
def text = "Groovy ist toll!"
def pattern = ~/Groovy/

if (text ==~ pattern) {
    println "Der Text entält das Muster."
}
else {
    println "Der Text enthält das Muster nicht."
} 
// Ausgabe: Der Text enthält das Muster nicht.
````