summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
Diffstat (limited to 'de-de')
-rw-r--r--de-de/scala-de.html.markdown64
1 files changed, 32 insertions, 32 deletions
diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index eb3770e9..a8344e6a 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -40,22 +40,22 @@ Als nächstes beschäftigen wir uns mit ein paar Scala-Grundlagen.
// 1. Grundlagen
/////////////////////////////////////////////////
-// Einzeilige Kommentare beginnen mit zwei Slashes.
+// Einzeilige Kommentare beginnen mit zwei Schrägstrichen.
/*
- Mehrzeilige Kommentare starten mit einem Slash-Stern
- und enden mit einem Stern-Slash.
+ Mehrzeilige Kommentare starten mit Schrägstrich und Stern
+ und enden mit Stern und Schrägstrich.
*/
// Einen Wert und eine zusätzliche neue Zeile ausgeben:
-println("Hello world!")
+println("Hallo Welt!")
println(10)
// Einen Wert ohne eine zusätzliche neue Zeile ausgeben:
-print("Hello world")
+print("Hallo Welt")
/*
Variablen werden entweder mit var oder val deklariert.
@@ -128,16 +128,16 @@ Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
// Für Strings gibt es die üblichen Java-Methoden:
-"hello world".length
-"hello world".substring(2, 6)
-"hello world".replace("C", "3")
+"Hallo Welt".length
+"Hallo Welt".substring(2, 6)
+"Hallo Welt".replace("C", "3")
// Zusätzlich gibt es noch extra Scala-Methoden
// siehe: scala.collection.immutable.StringOps
-"hello world".take(5)
-"hello world".drop(5)
+"Hallo Welt".take(5)
+"Hallo Welt".drop(5)
// String-Interpolation: prefix "s":
@@ -296,7 +296,7 @@ i // i ausgeben, res3: Int = 10
// Sie läuft sequentiell ab und verändert die loop-Variable.
// "while" in Scala läuft schneller ab als in Java und die o.g.
// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen
-// und zu parellelisieren.
+// und zu parallelisieren.
// Ein do while Schleife
@@ -331,7 +331,7 @@ val text = if (x == 10) "yeah" else "nope"
/////////////////////////////////////////////////
-// 4. Datenstrukturen (Array, Map, Set, Tuples)
+// 4. Datenstrukturen (Array, Map, Set, Tupel)
/////////////////////////////////////////////////
// Array
@@ -359,8 +359,8 @@ s(1) //true
val s = Set(1,1,3,3,7)
s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
-// Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
-// Ein Tuple ist keine Collection.
+// Tupel - Speichert beliebige Daten und "verbindet" sie miteinander
+// Ein Tupel ist keine Collection.
(1, 2)
(4, 3, 2)
@@ -368,14 +368,14 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
(a, 2, "three")
-// Hier ist der Rückgabewert der Funktion ein Tuple
+// Hier ist der Rückgabewert der Funktion ein Tupel
// Die Funktion gibt das Ergebnis sowie den Rest zurück.
val divideInts = (x: Int, y: Int) => (x / y, x % y)
divideInts(10, 3)
-// Um die Elemente eines Tuples anzusprechen, benutzt man diese
+// Um die Elemente eines Tupels anzusprechen, benutzt man diese
// Notation: _._n wobei n der index des Elements ist (Index startet bei 1)
val d = divideInts(10, 3)
@@ -603,21 +603,21 @@ def matchPerson(person: Person): String = person match {
val email = "(.*)@(.*)".r // regex
def matchEverything(obj: Any): String = obj match {
// Werte:
- case "Hello world" => "Got the string Hello world"
+ case "Hallo Welt" => "string Hallo Welt gefunden"
// Typen:
- case x: Double => "Got a Double: " + x
- // Conditions:
- case x: Int if x > 10000 => "Got a pretty big number!"
- // Case Classes:
- case Person(name, number) => s"Got contact info for $name!"
+ case x: Double => "Double gefunden: " + x
+ // Bedingungen:
+ case x: Int if x > 10000 => "Ziemlich große Zahl gefunden!"
+ // Case-Klassen:
+ case Person(name, number) => s"Kontaktinformationen für $name gefunden!"
// RegEx:
- case email(name, domain) => s"Got email address $name@$domain"
- // Tuples:
- case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+ case email(name, domain) => s"E-Mail-Adresse $name@$domain gefunden"
+ // Tupel:
+ case (a: Int, b: Double, c: String) => s"Tupel gefunden: $a, $b, $c"
// Strukturen:
- case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
- // Patterns kann man ineinander schachteln:
- case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+ case List(1, b, c) => s"Liste aus drei Elementen gefunden, startend mit 1: 1, $b, $c"
+ // Pattern kann man ineinander schachteln:
+ case List(List((1, 2, "YAY"))) => "Liste von Tupeln gefunden"
}
@@ -747,12 +747,12 @@ myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
// Diese Funktion hat zwei Parameter: einen normalen und einen implicit
def sendGreetings(toWhom: String)(implicit howMany: Int) =
- s"Hello $toWhom, $howMany blessings to you and yours!"
+ s"Hallo $toWhom, $howMany Segenswünsche für Sie und Ihre Angehörigen!"
// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet
-sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!"
+sendGreetings("John")(1000) // => "Hallo John, 1000 Segenswünsche für Sie und Ihre Angehörigen!"
// Wird der implicit-Parameter jedoch weggelassen, wird ein anderer
@@ -763,7 +763,7 @@ sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!
// Hier also: "myImplicitInt", da ein Int gesucht wird
-sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!"
+sendGreetings("Jane") // => "Hallo Jane, 100 Segenswünsche für Sie und Ihre Angehörigen!"
// bzw. "myImplicitFunction"
@@ -774,7 +774,7 @@ sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!"
/////////////////////////////////////////////////
-// 9. Misc
+// 9. Sonstiges
/////////////////////////////////////////////////
// Importe