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
-``assert !false
+``` Groovy 
+assert true
+assert !false
+```
 
 ##### Collections und Arrays
 Non-Empty Collections und arrays sind true
-``assert [1,2,3]
-``assert ![]
+``` Groovy
+assert [1,2,3]
+assert ![]
+```
 
 ##### Matchers
 True wenn mind. ein "match" 
-``assert = 'a' =~ /a/
-``assert = !('a' =~ /b/)
+``` Groovy
+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]
-``assert ![:]
+``` Groovy
+assert ['one' : 1]
+assert ![:]
+```
 
 ##### Strings
 Non-Empty Strings, GStrings, CharSequences sind true
-``assert 'a'
-``assert !''
-``def nonEmpty = a
-``assert "$nonEmpty"
-``def empty = ''
-``assert !"$empty"
+``` Groovy
+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
+``` Groovy
+assert 1
+assert 3.5
+assert !0
+```
 
 ##### Object References
 Non-null Objekt-Referenzen sind true
-``assert new Object()
-``assert !null
+``` 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
@@ -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
-- 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
+- "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