178 lines
3.6 KiB
Markdown
178 lines
3.6 KiB
Markdown
## 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'
|
|
}
|
|
```
|
|
|
|
|