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

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

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

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

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.

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:

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

Kann man:

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:

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.

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

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

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:

def partner = switch(person){
	case 'Romeo' -> 'Juliet'
	case 'Adam' -> 'Eve'
	case 'Eins' -> 'Zwei'
}