diff --git a/Bedingungen.md b/Bedingungen.md new file mode 100644 index 0000000..87d8172 --- /dev/null +++ b/Bedingungen.md @@ -0,0 +1,177 @@ +## 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' +} +``` + + diff --git a/Datenstrukturen.md b/Datenstrukturen.md new file mode 100644 index 0000000..7377d28 --- /dev/null +++ b/Datenstrukturen.md @@ -0,0 +1,111 @@ +### Ranges +Ähnlich wie in Ruby, jedoch nicht gleich +```Groovy +1..10 // Inklusive 10 +1..<10 // Exklusive 10 +'a'..'x' // Kann auch aus Character bestehen +10..1 // Kann auch absteigende Reihenfolge haben +'x'..'a' // Character können auch absteigende Reihenfolge haben +``` + +Nützliche Methoden auf Ranges: +- contains() +- get() +- getFrom() +- getTo() +- isReverse() +- size() +- subList() + +### Arrays +- von allen Typen können Arrays erstellt werden +- Größe muss angegeben werden, sind nicht dynamisch + +```Groovy +int[] intArray = new int[4]; +intArray[2] = 2 +println intArray // [0,0,2,0] +``` + + + +### Lists +Listen sind geordnete Sammlungen von Elementen. + +```Groovy +def list = [0,1,2,3] +println list // [0,1,2,3] +println list[0] // [0] + +list << 4 // Hinzufügen eins Elements am Ende der Liste +println list // [0,1,2,3,4] + +list.add(0,20) // [Index, Wert] +println list // [20,0,1,2,3,4] +``` + + +### Maps +Eine Map ist eine ungeordnete Collection von Objekt-Referenzen. + +```Groovy +def map = [name: "Peter", alter: 81] +``` + +Zugriff auf Map: + +```Groovy +println map.name // "Peter" +println map["alter"] // 81 +``` + +Hinzufügen von Schlüssel-Wert + +```Groovy +map["Auto"] = "Bugatti" +println map["Auto"] // "Bugatti" +``` + +Entfernen von Elementen + +```Groovy +def map [hello: "World", erde: "Rund", eins: "Zwei"] +println map // [hello: "World", erde: "Rund", eins: "Zwei"] +def newMap = map.minus([hello: "World"]) +println newMap // [erde: "Rund", eins: "Zwei"] +``` +Die `minus()`Methode nimmt eine Map als Argument und gibt eine neue Map, mit den entfernten Schlüssel-Wert Paaren zurück + +-----Man kann auch Closure* benutzen---- + + +Eine leere Map wird wie folgt definiert: +```Groovy +def emptyMap = [:] +``` + + +\* Clojure ist ein Codeblock, der lokal erstellt wird und Zugriff auf umgebende Variablen hat + + +### Sets +Ungeordnete Sammlung von eindeutigen Elementen. +(Keine Dubletten) + +```Groovy +def mySet = [1,1,1,2,3,3,4,5,5,5,5] as Set +println mySet //[1,2,3,4,5] +``` +Hinzufügen eines Elements: +```Groovy +mySet << 6 +println mySet // [1,2,3,4,5,6] +// oder +mySet.add(7) +println mySet // [1,2,3,4,5,6,7] +``` + +Entfernen eines Elements: +```Groovy +mySet.remove(1) +println mySet // [2,3,4,5,6,7]