Bedingungen update

Bedingungen.md

@@ -3,55 +3,69 @@ Groovy entscheidet nach folgenden Regeln, ob ein Ausdruck true oder false ist:
 
 ##### Boolean
 True wenn entsprechender boolean Wert true ist
-``assert true
+``` Groovy 
-``assert !false
+assert true
+assert !false
+```
 
 ##### Collections und Arrays
 Non-Empty Collections und arrays sind true
-``assert [1,2,3]
+``` Groovy
-``assert ![]
+assert [1,2,3]
+assert ![]
+```
 
 ##### Matchers
 True wenn mind. ein "match" 
-``assert = 'a' =~ /a/
+``` Groovy
-``assert = !('a' =~ /b/)
+assert 'a' =~ /a/
+assert !('a' =~ /b/)
+```
 
 ##### Iterators und Enumerations
 Iteratoren und Enumerationen mit weiteren Elementen sind true
 ```Groovy
 assert [0].iterator()
-assert ![].iterator()
+assert ![].iterator.hasNext()
 Vector v = [0] as Vector
 Enumeration enumeration = v.elements()
-assert enumeration
+assert Enumeration
 enumeration.nextElement()
-assert !enumeration
+assert !enumeration.hasMoreElements()
 ```
 
 ##### Maps
 Non-Empty Maps sind true
-``assert ['one' : 1]
+``` Groovy
-``assert ![:]
+assert ['one' : 1]
+assert ![:]
+```
 
 ##### Strings
 Non-Empty Strings, GStrings, CharSequences sind true
-``assert 'a'
+``` Groovy
-``assert !''
+assert 'a'
-``def nonEmpty = a
+assert !''
-``assert "$nonEmpty"
+def nonEmpty = a
-``def empty = ''
+assert "$nonEmpty"
-``assert !"$empty"
+def empty = ''
+assert !"$empty"
+```
 
 ##### Numbers
 Non-zero Nummern sind true
-``assert 1
+``` Groovy
-``assert 3.5
+assert 1
-``assert !0
+assert 3.5
+assert !0
+```
 
 ##### Object References
 Non-null Objekt-Referenzen sind true
-``assert new Object()
+``` Groovy 
-``assert !null
+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
@@ -66,7 +80,7 @@ class Color{
 	}
 }
 
-...
+// ...
 
 assert new Color(name: 'green')
 assert !new Color(name: 'red')
@@ -112,13 +126,13 @@ 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. 
+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 Asudruck, wenn ausdruck1 "null" oder "falsly" ist
+- ausdruck2: Dies ist der Ausdruck, wenn ausdruck1 "null" oder "falsly" ist
 
 
 ### If-Else Bedingungen
@@ -161,9 +175,9 @@ switch (x) {
 
 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
+- "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
+- "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
+- 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