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

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

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

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

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

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

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

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

##### Object References
Non-null Objekt-Referenzen sind true
``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 leer ist. 

```Groovy
def result = ausdruck1 ?: ausdruck2
```
- ausdruck1: Dies ist der Ausdruck der ausgewertet wird, wenn dieser einen "truthy" Wert hat.
- ausdruck2: Dies ist der Asudruck, 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" 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 matcht, 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'
}
```