groovy-lecture/skript/Bedingungen.md

## Groovy-Truth
Groovy entscheidet nach folgenden Regeln, ob ein Ausdruck true oder false ist:

##### Boolean
True wenn entsprechender boolean Wert true ist
``` Groovy 
assert true
assert !false
```

##### Collections und Arrays
Non-Empty Collections und arrays sind true
``` Groovy
assert [1,2,3]
assert ![]
```

##### Matchers
True wenn mind. ein "match" 
``` Groovy
assert 'a' =~ /a/
assert !('a' =~ /b/)
```

##### Iterators und Enumerations
Iteratoren und Enumerationen mit weiteren Elementen sind true
```Groovy
assert [0].iterator()
assert ![].iterator.hasNext()
Vector v = [0] as Vector
Enumeration enumeration = v.elements()
assert Enumeration
enumeration.nextElement()
assert !enumeration.hasMoreElements()
```

##### Maps
Non-Empty Maps sind true
``` Groovy
assert ['one' : 1]
assert ![:]
```

##### Strings
Non-Empty Strings, GStrings, CharSequences sind true
``` Groovy
assert 'a'
assert !''
def nonEmpty = a
assert "$nonEmpty"
def empty = ''
assert !"$empty"
```

##### Numbers
Non-zero Nummern sind true
``` Groovy
assert 1
assert 3.5
assert !0
```

##### Object References
Non-null Objekt-Referenzen sind true
``` Groovy 
assert new Object()
assert !null
```

##### Truth verändern mit asBoolean()-Methode
Man kann das Verhalten von Groovy auf boolean verändern, indem man eine asBoolean()-Methode implementiert

```Groovy
class Color{

	String name

	boolean asBoolean(){
		name == 'green' ? true : false
	}
}

// ...

assert new Color(name: 'green')
assert !new Color(name: 'red')
```




## Bedingte Operatoren
### Not Operator
Der "Nicht"-Operator wird mit einem "!" dargestellt. 
```Groovy
def wasbinIch = true
println !wasBinIch // Ausgabe "false"
```

### Ternärer Operator
Der ternäre Operator ist ein Shortcut, der einem if/else Bedingung entspricht und einer Variablen einen Wert zuweist. 

Statt:

```Groovy 
if(string!=null && string.length()>0){
	result = 'Found'
} else {
	result = 'Not Found'
}
```

Kann man:

```Groovy

result = (string!=null && string.length()>0) ? 'Found' : 'Not Found'
```

schreiben.

Auch ist der ternäre Operator kompatibel mit dem "Groovy Truth", sodass man den Ausdruck noch kürzer Verfassen kann:
```Groovy

result = string ? 'Found' : 'Not Found'
```

### Elvis-Operator
Der "Elvis-Operator" ist eine Kurzform des ternären Operators. Dieser wird verwendet, um einen Standardwert anzugeben, wenn eine Variable "null" oder falsly ist. 

```Groovy
def result = ausdruck1 ?: ausdruck2
```
- ausdruck1: Dies ist der Ausdruck der ausgewertet wird, wenn dieser einen "truthy" Wert hat.
- ausdruck2: Dies ist der Ausdruck, wenn ausdruck1 "null" oder "falsly" ist


### If-Else Bedingungen
```Groovy
def zahl = 8

if(zahl > 10){
	println "Zahl größer 10"
}else if(zahl < 10){
	println "Zahl ist kleiner 10"
}else{
	println "Zahl ist gleich 10"
}
```

### Switch Case
```Groovy
def x = 3 
switch (x) { 
	case 1: 
		println "x is one" 
		break 
	case 2: 
		println "x is two" 
		break 
	case 3..5: // Bereich 
		println "x is between 3 and 5" 
		break 
	case Integer: 
		println "x is an integer" 
		break 
	case ~/^\\d+$/: // Regex als Case erlaubt
		println "x is a number" 
		break 
	default: 
		println "x is something else" 
}
```


Switch Unterstützt folgende Arten des Vergleichs:
- Case-Values stimmen überein, wenn Switch-Value ein Instanz der selben Klasse ist
- "Regulärer Ausdruck Case"-Value stimmt überein, wenn `toString()` Repräsentation vom Switch-Value dem Regex gleicht
- "Collection Case"-Values matchen mit dem Switch-Value, wenn Switch-Value in der Collection vorkommt
- Closure Case-Values match, wenn der Call auf dem Clojure ein Return basierend auf Groovy-Truth zurück gibt

Groovy unterstützt auch folgende Schreibweise: 
```Groovy
def partner = switch(person){
	case 'Romeo' -> 'Juliet'
	case 'Adam' -> 'Eve'
	case 'Eins' -> 'Zwei'
}
```