summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
Diffstat (limited to 'de-de')
-rw-r--r--de-de/LOLCODE-de.html.markdown188
-rw-r--r--de-de/asciidoc-de.html.markdown4
-rw-r--r--de-de/bash-de.html.markdown2
-rw-r--r--de-de/dynamic-programming-de.html.markdown77
-rw-r--r--de-de/edn-de.html.markdown112
-rw-r--r--de-de/git-de.html.markdown16
-rw-r--r--de-de/go-de.html.markdown2
-rw-r--r--de-de/hq9+-de.html.markdown43
-rw-r--r--de-de/html-de.html.markdown4
-rw-r--r--de-de/java-de.html.markdown2
-rw-r--r--de-de/make-de.html.markdown7
-rw-r--r--de-de/markdown-de.html.markdown4
-rw-r--r--de-de/nix-de.html.markdown358
-rw-r--r--de-de/opencv-de.html.markdown153
-rw-r--r--de-de/paren-de.html.markdown200
-rw-r--r--de-de/pyqt-de.html.markdown89
-rw-r--r--de-de/python3-de.html.markdown42
-rw-r--r--de-de/qt-de.html.markdown175
-rw-r--r--de-de/rst-de.html.markdown119
-rw-r--r--de-de/scala-de.html.markdown582
-rw-r--r--de-de/shutit-de.html.markdown330
-rw-r--r--de-de/swift-de.html.markdown32
22 files changed, 2195 insertions, 346 deletions
diff --git a/de-de/LOLCODE-de.html.markdown b/de-de/LOLCODE-de.html.markdown
new file mode 100644
index 00000000..57eb0ff8
--- /dev/null
+++ b/de-de/LOLCODE-de.html.markdown
@@ -0,0 +1,188 @@
+---
+language: LOLCODE
+filename: learnLOLCODE-de.lol
+contributors:
+ - ["abactel", "https://github.com/abactel"]
+translators:
+ - ["Henrik Jürges", "http://github.com/santifa"]
+lang: de-de
+---
+
+LOLCODE ist eine esoterische Programmiersprache die die Sprache der [lolcats](https://upload.wikimedia.org/wikipedia/commons/a/ab/Lolcat_in_folder.jpg?1493656347257) nachahmt.
+
+```
+BTW Das ist ein Kommentar
+BTW Das Programm muss mit `HAI <language version>` beginnen und mit `KTHXBYE` enden.
+
+HAI 1.3
+CAN HAS STDIO? BTW Standard Header importieren
+
+OBTW
+ ==========================================================================
+ ============================== Grundlegendes =============================
+ ==========================================================================
+TLDR
+
+BTW Texte anzeigen:
+VISIBLE "HELLO WORLD"
+
+BTW Variablen deklarieren:
+I HAS A MESSAGE ITZ "CATZ ARE GOOD"
+VISIBLE MESSAGE
+
+OBTW
+ Variablen sind dynamisch typisiert und der Typ muss nicht explizit
+ angegeben werden. Die möglichen Typen sind:
+TLDR
+
+I HAS A STRING ITZ "DOGZ ARE GOOOD" BTW Typ ist YARN
+I HAS A INTEGER ITZ 42 BTW Typ ist NUMBR
+I HAS A FLOAT ITZ 3.1415 BTW Typ ist NUMBAR
+I HAS A BOOLEAN ITZ WIN BTW Typ ist TROOF
+I HAS A UNTYPED BTW Typ ist NOOB
+
+BTW Eingaben von Nutzern:
+I HAS A AGE
+GIMMEH AGE
+BTW Die Variable wird als YARN gespeichert und kann in eine
+BTW NUMBR konvertiert werden:
+AGE IS NOW A NUMBR
+
+OBTW
+ ==========================================================================
+ ================================== MATHE =================================
+ ==========================================================================
+TLDR
+
+BTW LOLCODE benutzt polnische Notation für Mathe.
+
+BTW grundlegende mathematische Notationen:
+
+SUM OF 21 AN 33 BTW 21 + 33
+DIFF OF 90 AN 10 BTW 90 - 10
+PRODUKT OF 12 AN 13 BTW 12 * 13
+QUOSHUNT OF 32 AN 43 BTW 32 / 43
+MOD OF 43 AN 64 BTW 43 modulo 64
+BIGGR OF 23 AN 53 BTW max(23, 53)
+SMALLR OF 53 AN 45 BTW min(53, 45)
+
+BTW binäre Notation:
+
+BOTH OF WIN AN WIN BTW und: WIN if x=WIN, y=WIN
+EITHER OF FAIL AN WIN BTW oder: FAIL if x=FAIL, y=FAIL
+WON OF WIN AN FAIL BTW exklusives oder: FAIL if x=y
+NOT FAIL BTW unäre Negation: WIN if x=FAIL
+ALL OF WIN AN WIN MKAY BTW beliebige Stelligkeit bei AND
+ANY OF WIN AN FAIL MKAY BTW beliebige Stelligkeit bei OR
+
+BTW Vergleiche:
+
+BOTH SAEM "CAT" AN "DOG" BTW WIN wenn x == y
+DIFFRINT 732 AN 184 BTW WIN wenn x != y
+BOTH SAEM 12 AN BIGGR OF 12 AN 4 BTW x >= y
+BOTH SAEM 43 AN SMALLR OF 43 AN 56 BTW x <= y
+DIFFRINT 64 AN SMALLR OF 64 AN 2 BTW x > y
+DIFFRINT 75 AN BIGGR OF 75 AN 643 BTW x < y
+
+OBTW
+ ==========================================================================
+ ============================= Flusskontrolle =============================
+ ==========================================================================
+TLDR
+
+BTW If/then Statement:
+I HAS A ANIMAL
+GIMMEH ANIMAL
+BOTH SAEM ANIMAL AN "CAT", O RLY?
+ YA RLY
+ VISIBLE "YOU HAV A CAT"
+ MEBBE BOTH SAEM ANIMAL AN "MAUS"
+ VISIBLE "NOM NOM NOM. I EATED IT."
+ NO WAI
+ VISIBLE "AHHH IS A WOOF WOOF"
+OIC
+
+BTW Case Statement:
+I HAS A COLOR
+GIMMEH COLOR
+COLOR, WTF?
+ OMG "R"
+ VISIBLE "RED FISH"
+ GTFO
+ OMG "Y"
+ VISIBLE "YELLOW FISH"
+ BTW Weil hier kein `GTFO` ist wird auch das nächste Statement überprüft
+ OMG "G"
+ OMG "B"
+ VISIBLE "FISH HAS A FLAVOR"
+ GTFO
+ OMGWTF
+ VISIBLE "FISH IS TRANSPARENT OHNO WAT"
+OIC
+
+BTW For Schleife:
+I HAS A TEMPERATURE
+GIMMEH TEMPERATURE
+TEMPERATURE IS NOW A NUMBR
+IM IN YR LOOP UPPIN YR ITERATOR TIL BOTH SAEM ITERATOR AN TEMPERATURE
+ VISIBLE ITERATOR
+IM OUTTA YR LOOP
+
+BTW While Schleife:
+IM IN YR LOOP NERFIN YR ITERATOR WILE DIFFRINT ITERATOR AN -10
+ VISIBLE ITERATOR
+IM OUTTA YR LOOP
+
+OBTW
+ =========================================================================
+ ================================ Strings ================================
+ =========================================================================
+TLDR
+
+BTW Zeilenumbrüche:
+VISIBLE "FIRST LINE :) SECOND LINE"
+
+BTW Tabulatoren:
+VISIBLE ":>SPACES ARE SUPERIOR"
+
+BTW Bell (macht beep):
+VISIBLE "NXT CUSTOMER PLS :o"
+
+BTW Anführungszeichen in Strings:
+VISIBLE "HE SAID :"I LIKE CAKE:""
+
+BTW Doppelpunkte in Strings :
+VISIBLE "WHERE I LIVE:: CYBERSPACE"
+
+OBTW
+ =========================================================================
+ =============================== Funktionen ==============================
+ =========================================================================
+TLDR
+
+BTW Definieren einer neuen Funktion:
+HOW IZ I SELECTMOVE YR MOVE BTW `MOVE` ist ein Argument
+ BOTH SAEM MOVE AN "ROCK", O RLY?
+ YA RLY
+ VISIBLE "YOU HAV A ROCK"
+ NO WAI
+ VISIBLE "OH NO IS A SNIP-SNIP"
+ OIC
+ GTFO BTW Gibt NOOB zurück
+IF U SAY SO
+
+BTW Eine Funktion deklarieren und einen Wert zurückgeben:
+HOW IZ I IZYELLOW
+ FOUND YR "YELLOW"
+IF U SAY SO
+
+BTW Eine Funktion aufrufen:
+I IZ IZYELLOW MKAY
+
+KTHXBYE
+```
+
+## Weiterführende Informationen:
+
+- [LCI compiler](https://github.com/justinmeza/lci)
+- [Official spec](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md)
diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown
index 1a8cdd5a..60f8fa61 100644
--- a/de-de/asciidoc-de.html.markdown
+++ b/de-de/asciidoc-de.html.markdown
@@ -84,10 +84,6 @@ Abteilungstitel
===== Level 4 <h5>
-====== Level 5 <h6>
-
-======= Level 6 <h7>
-
```
Listen
diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index 7928b136..7a0db157 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -180,7 +180,7 @@ esac
# 'for' Schleifen iterieren über die angegebene Zahl von Argumenten:
# Der Inhalt von $Variable wird dreimal ausgedruckt.
-for $Variable in {1..3}
+for Variable in {1..3}
do
echo "$Variable"
done
diff --git a/de-de/dynamic-programming-de.html.markdown b/de-de/dynamic-programming-de.html.markdown
new file mode 100644
index 00000000..afa9a17c
--- /dev/null
+++ b/de-de/dynamic-programming-de.html.markdown
@@ -0,0 +1,77 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+ - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+ - ["Henrik Jürges", "http://github.com/santifa"]
+lang: de-de
+---
+
+# Dynamische Programmierung
+
+## Einführung
+Dynamische Programmierung ist eine leistungsfähige Technik, die zur Lösung
+einer bestimmten Klasse von Problemen verwendet wird.
+Die Idee ist sehr einfach, wenn Sie ein Problem mit der gegebenen Eingabe
+gelöst haben, dann speichern Sie das Ergebnis für die spätere Referenz, um zu
+vermeiden, das gleiche Problem noch einmal zu lösen.
+
+Denken Sie immer daran!
+"Diejenigen, die sich nicht an die Vergangenheit erinnern können,
+sind dazu verdammt, sie zu wiederholen."
+
+## Wege zur Lösung solcher Probleme
+
+1. *Top-Down*: Lösen Sie das gegebene Problem, indem Sie es aufteilen.
+Wenn Sie sehen, dass das Problem bereits gelöst ist, geben Sie einfach die
+gespeicherte Antwort zurück. Wenn es nicht gelöst wurde, lösen Sie es und
+speichern Sie die Antwort. Dieser Ansatz ist leicht zu verfolgen und sehr
+intuitiv. Er wird als Memoization bezeichnet.
+
+2. *Bottom-Up*: Analysieren Sie das Problem und beobachten Sie, in welcher
+Reihenfolge die Teilprobleme gelöst werden können. Beginnen Sie mit der
+Lösung vom trivialen Teilproblem bis zum gegebenen Problem. Dabei wird
+sichergestellt, dass die Teilprobleme vor der Problemlösung gelöst werden.
+Dies wird als Dynamische Programmierung bezeichnet.
+
+## Ein Beispiel für Dynamische Programmierung
+
+Das Problem mit der längsten ansteigenden Subsequenz besteht darin,
+die längste ansteigende Subsequenz einer gegebenen Sequenz zu finden.
+Gegeben die Sequenz `S= {a1, a2, a3, a3, a4,..............., an-1, an }`,
+müssen wir die größte Teilmenge finden, so daß für alle `j` und `i`, `j<i`
+in der Teilmenge `aj<ai` gilt.
+Zuerst müssen wir bei jedem Index i den Wert der längsten Subsequenzen (LSi)
+finden, wobei das letzte Element der Sequenz ai ist. Dann wäre die größte LSi
+die längste Subsequenz in der gegebenen Sequenz. Am Anfang wird der LSi mit
+eins belegt, da ai ein Element der Sequenz (Letztes Element) ist.
+Dann ist für alle `j` mit `j<i` und `aj<ai`, so dass wir den größten LSj finden
+und zum LSi hinzufügen. Der Algorithmus hat eine Laufzeit von *O(n2)*.
+
+Pseudocode zur Bestimmung der Länge der am längsten ansteigenden Subsequenz:
+Die Komplexität des Algorithmus könnte durch eine bessere Datenstruktur anstelle
+von Arrays reduziert werden. Das Speichern von Vorgänger-Array's und Variablen
+wie `largest_sequences_so_far` und dessen Index würde eine Menge Zeit sparen.
+
+Ein ähnliches Konzept könnte auch bei der Suche nach dem längsten Weg
+in gerichteten azyklischen Graphen angewandt werden.
+```python
+for i=0 to n-1
+ LS[i]=1
+ for j=0 to i-1
+ if (a[i] > a[j] and LS[i]<LS[j])
+ LS[i] = LS[j]+1
+for i=0 to n-1
+ if (largest < LS[i])
+```
+
+### Einige bekannte DP Probleme
+
+- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
+## Online Ressourcen
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/de-de/edn-de.html.markdown b/de-de/edn-de.html.markdown
new file mode 100644
index 00000000..2434d1bd
--- /dev/null
+++ b/de-de/edn-de.html.markdown
@@ -0,0 +1,112 @@
+---
+language: edn
+filename: learnedn-de.edn
+contributors:
+ - ["Jason Yeo", "https://github.com/jsyeo"]
+ - ["Jonathan D Johnston", "https://github.com/jdjohnston"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+Extensible Data Notation (EDN) ist ein Format für serialisierte Daten.
+
+EDN ist ein Subset der von Clojure verwendeten Syntax. Das Lesen von Daten, die durch EDN definiert werden, ist
+sicherer als das, was durch die vollständige Clojure-Syntax definiert wird, insbesondere von nicht
+vertrauenswürdigen Quellen. EDN ist beschränkt auf Daten, kein Code. Es ist ähnlich in seinen Zielen zu JSON.
+Obwohl es mehr in Clojure verwendet wird, gibt es verschiedene Implementationen von EDN in vielen
+verschiedenen anderen Sprachen.
+
+Der Hauptvorteil von EDN im Gegensatz zu JSON und YAML ist, dass es erweiterbar ist.
+Wir werden später sehen wie es erweitert werden kann.
+
+```clojure
+; Kommentare starten mit einem Semikolon.
+; Alles nach dem Semikolon wird ignoriert.
+
+;;;;;;;;;;;;;;;;;;;
+;;; Basistypen ;;;
+;;;;;;;;;;;;;;;;;;;
+
+nil ; auch bekannt in anderen Sprachen als null
+
+; Booleans
+true
+false
+
+; Strings werden in Gänsefüßchen eingeschlossen.
+"hungarian breakfast"
+"farmer's cheesy omelette"
+
+; Charaktere werden einem Backslash vorangestellt
+\g \r \a \c \e
+
+; Schlüsselwörter beginnen mit einem Doppelpunkt. Sie verhalten sich wie Enums.
+; Ähnlich, wie Symbole in Ruby.
+:eggs
+:cheese
+:olives
+
+; Symbole werden verwendet um Identifier zu repräsentieren. Sie beginnen mit einem #.
+; Du kannst einen Namespace für Symbole nutzen, wenn du / verwendest. Egal was / vorangestellt wird
+; ist der Namespace dieses Namens.
+#spoon
+#kitchen/spoon ; nicht das selbe, wie #spoon
+#kitchen/fork
+#github/fork ; damit kannst du nicht essen
+
+; Integers und Floats
+42
+3.14159
+
+; Listen sind Sequenzen von Werten
+(:bun :beef-patty 9 "yum!")
+
+; Vektoren erlauben zufälligen Zugriff
+[:gelato 1 2 -2]
+
+; Maps sind assoziative Datenstrukturen, die einen Schlüssel mit einem Wert verbinden.
+{:eggs 2
+ :lemon-juice 3.5
+ :butter 1}
+
+; Du bist nicht beschränkt ausschließlich Schlüsselwörter als Schlüssel zu verwenden.
+{[1 2 3 4] "tell the people what she wore",
+ [5 6 7 8] "the more you see the more you hate"}
+
+; Du kannst Kommas für eine bessere Lesbarkeit verwenden. Sie werden wie Leerraum behandelt.
+; Sets sind Sammlungen, die eindeutige Elemente enthalten.
+#{:a :b 88 "huat"}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; markierte Elemente ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; EDN kann erweitert werden, indem Elemente mit # Symbolen makiert werden.
+
+#MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10}
+
+; Lass mich das mit einem Clojure Beispiel erklären.
+; Angenommen ich möchte dieses Stück EDM in einen MenuItem record umwandeln.
+(defrecord MenuItem [name rating])
+
+; Um EDN in clojure Werte umzuwandeln, muss ich den eingebauten EDN Leser
+; edn/read-string verwenden
+
+(edn/read-string "{:eggs 2 :butter 1 :flour 5}")
+; -> {:eggs 2 :butter 1 :flour 5}
+
+; Definiere die Leserfunktion, um markierte Elemente zu transformieren
+; und übergebe eine Map, die Tags den Lesefunktionen als edn / read-string zuweisen
+
+(edn/read-string {:readers {'MyYelpClone/MenuItem map->menu-item}}
+ "#MyYelpClone/MenuItem {:name \"eggs-benedict\" :rating 10}")
+; -> #user.MenuItem{:name "eggs-benedict", :rating 10}
+
+```
+
+# Referenzen
+
+- [EDN spec](https://github.com/edn-format/edn)
+- [Implementationen](https://github.com/edn-format/edn/wiki/Implementations)
+- [makierte Elemente](http://www.compoundtheory.com/clojure-edn-walkthrough/)
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index 61f7bb67..d2222d2c 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -10,7 +10,7 @@ lang: de-de
Git ist eine verteilte Versions- und Quellcodeverwaltung.
-Es nimmt Schnappschüsse der Projekte, um mit diesen Schnappschüssen verschiedene Versionen unterscheiden und den Quellcode verwalten zu können.
+Es nimmt Schnappschüsse der Projekte auf, um mit diesen Schnappschüssen verschiedene Versionen unterscheiden und den Quellcode verwalten zu können.
Anmerkung des Übersetzers: Einige englische Begriffe wie *Repository*, *Commit* oder *Head* sind idiomatische Bestandteile im Umgang mit Git. Sie wurden nicht übersetzt.
@@ -43,7 +43,7 @@ Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichn
### Repository (Repo)
-Ein Satz von Dateien, Verzeichnisen, Historieneinträgen, Commits und Heads. Stell es dir wie eine Quellcode-Datenstruktur vor, unter anderem mit der Eigenschaft, dass alle *Elemente* dir Zugriff auf die Revisionshistorie geben.
+Ein Satz von Dateien, Verzeichnissen, Historieneinträgen, Commits und Heads. Stell es dir wie eine Quellcode-Datenstruktur vor, unter anderem mit der Eigenschaft, dass alle *Elemente* dir Zugriff auf die Revisionshistorie geben.
Ein Repository besteht in Git aus dem .git-Verzeichnis und dem Arbeitsverzeichnis.
@@ -66,7 +66,7 @@ Ein Commit ist ein Schnappschuss von Änderungen in deinem Arbeitsverzeichnis. W
### Branch
-Ein Branch, ein Ast oder Zweig, ist im Kern ein Pointer auf den letzten Commit, den du gemacht hast. Während des Commits wird der Pointer automatisch auf Stand gebracht und zeigt dann auf den neuen letzten Commit.
+Ein Branch, ein Ast oder Zweig, ist im Kern ein Pointer auf den letzten Commit, den du gemacht hast. Während des Commits wird der Pointer automatisch auf diesen Stand gebracht und zeigt dann auf den neuen letzten Commit.
### HEAD und head (Teil des .git-Verzeichnisses)
@@ -205,11 +205,17 @@ Speichert die aktuellen Inhalte des Index in einen neuen *Commit*. Dieser Commit
```bash
# Commit mit Beschreibung erstellen.
$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+
+# Alle veränderten oder gelöschten Dateien außer neue Dateien werden gestaged und dann wird ein Commit erstellt.
+$ git commit -a -m "Modified foo.php and removed bar.php"
+
+# Ändert den letzten Commit (der letzte Commit wird mit einem neuen Commit ersetzt)
+$ git commit --amend -m "Correct message"
```
### diff
-Zeigt die Unterschiede zwischen Dateien von Arbeitsverzeichnisse, dem Index und Commits an.
+Zeigt die Unterschiede zwischen Dateien vom Arbeitsverzeichnis, dem Index und Commits an.
```bash
# Unterschiede zwischen deinem Arbeitsverzeichnis und dem Index anzeigen
@@ -324,7 +330,7 @@ $ git push origin master
### rebase (mit Vorsicht einsetzen)
-Nimm alle Änderungen, die in einem Branch durch Commits vorgenommen wurden, und übertrage sie auf einen anderen Branch. Achtung: Führe keinen Rebase von Commits durch, die auf ein öffentliches Repo gepusht wurden.
+Nimm alle Änderungen, die in einem Branch durch Commits vorgenommen wurden, und übertrage sie auf einen anderen Branch. Achtung: Führe keinen Rebase von Commits durch, die auf ein öffentliches Repo gepusht wurden!
```bash
# Rebase "experimentBranch" in den "master"-Branch
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 817cb4ae..9409e181 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -94,7 +94,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
// Arrays haben bei Kompile-Zeit festgelegte Größen
var a4 [4]int // Ein Array mit 4 ints, alle mit Initialwert 0
- a3 := [...]int{3, 1, 5} // Ein Array mit 4 ints, Initialwerte wie angezeigt
+ a3 := [...]int{3, 1, 5} // Ein Array mit 3 ints, Initialwerte wie angezeigt
// "slices" haben eine dynamische Größe. Arrays und Slices haben beide ihre
// Vorzüge, aber slices werden viel häufiger verwendet
diff --git a/de-de/hq9+-de.html.markdown b/de-de/hq9+-de.html.markdown
new file mode 100644
index 00000000..b343201a
--- /dev/null
+++ b/de-de/hq9+-de.html.markdown
@@ -0,0 +1,43 @@
+---
+language: HQ9+
+filename: hq9+.html
+contributors:
+ - ["Alexey Nazaroff", "https://github.com/rogaven"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+HQ9+ ist eine Parodie auf esoterische Programmiersprachen und wurde von Cliff Biffle kreiert.
+Die Sprache hat nur vier Befehle und ist nicht Turing-vollständig.
+
+```
+Es gibt nur vier Befehle, die durch die folgenden vier Zeichen dargestellt werden
+H: druckt "Hello, world!"
+Q: druckt den Quellcode des Programms (ein Quine)
+9: druckt den Liedtext von "99 Bottles of Beer"
++: erhöhe den Akkumulator um Eins (Der Wert des Akkumulators kann nicht gelesen werden)
+Jedes andere Zeichen wird ignoriert.
+
+Ok. Lass uns ein Programm schreiben:
+ HQ
+
+Ergebnis:
+ Hello world!
+ HQ
+
+HQ9+ ist zwar sehr simpel, es erlaubt aber dir Sachen zu machen, die in
+anderen Sprachen sehr schwierig sind. Zum Beispiel druckt das folgende Programm
+drei Mal Kopien von sich selbst auf den Bildschirm:
+ QQQ
+Dies druckt:
+ QQQ
+ QQQ
+ QQQ
+```
+
+Und das ist alles. Es gibt sehr viele Interpreter für HQ9+.
+Unten findest du einen von ihnen.
+
++ [One of online interpreters](https://almnet.de/esolang/hq9plus.php)
++ [HQ9+ official website](http://cliffle.com/esoterica/hq9plus.html)
diff --git a/de-de/html-de.html.markdown b/de-de/html-de.html.markdown
index 2ee18129..0bf58f9c 100644
--- a/de-de/html-de.html.markdown
+++ b/de-de/html-de.html.markdown
@@ -9,7 +9,7 @@ lang: de-de
---
HTML steht für HyperText Markup Language (Hypertext-Auszeichnungssprache).
-Sie ist eine Sprache, um Seiten für das World Wide Web zu schreiben..
+Sie ist eine Sprache, um Seiten für das World Wide Web zu schreiben.
Es ist eine Auszeichnugssprache, die es uns ermöglicht Webseiten mithilfe des Codes zu schreiben, der kennzeichnet wie Text und Daten angezeigt werden sollen. Eigentlich sind HTML Dateien nur einfache Textdateien.
Was sind das für Auszeichnungen? Es ist eine Methode, um die Daten der Website zu organisieren mithilfe von Start- und Endtags.
Diese Auszeichnung dient dazu dem Text Bedeutung zu geben, welchen sie umschließt.
@@ -111,7 +111,7 @@ Dieser Artikel ist bedacht darauf, nur HTML Syntax und nützliche Tipps zu geben
## Verwendung
-HTML Dateien enden mit `.html`.
+HTML Dateien enden mit `.html` oder mit `.htm`. Der Mime Typ ist meist `text/html`.
## Um mehr zu lernen
diff --git a/de-de/java-de.html.markdown b/de-de/java-de.html.markdown
index 934819f9..e8ac5bda 100644
--- a/de-de/java-de.html.markdown
+++ b/de-de/java-de.html.markdown
@@ -1,6 +1,6 @@
---
language: java
-filename: LearnJavaDe.java
+filename: LearnJavaDe-de.java
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
- ["Jakukyo Friel", "http://weakish.github.io"]
diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
index 22c14a69..bc5c7bcb 100644
--- a/de-de/make-de.html.markdown
+++ b/de-de/make-de.html.markdown
@@ -2,6 +2,7 @@
language: make
contributors:
- ["Robert Steed", "https://github.com/robochat"]
+ - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
translators:
- ["Martin Schimandl", "https://github.com/Git-Jiro"]
filename: Makefile-de
@@ -58,7 +59,7 @@ file2.txt file3.txt: file0.txt file1.txt
touch file3.txt
# Make wird sich beschweren wenn es mehrere Rezepte für die gleiche Regel gibt.
-# Leere Rezepte zählen nicht und können dazu verwendet werden weitere
+# Leere Rezepte zählen nicht und können dazu verwendet werden weitere
# Voraussetzungen hinzuzufügen.
#-----------------------------------------------------------------------
@@ -182,9 +183,9 @@ echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb
# Ein paar Variablen die von Make automatisch definiert werden.
echo_inbuilt:
echo $(CC)
- echo ${CXX)}
+ echo ${CXX}
echo $(FC)
- echo ${CFLAGS)}
+ echo ${CFLAGS}
echo $(CPPFLAGS)
echo ${CXXFLAGS}
echo $(LDFLAGS)
diff --git a/de-de/markdown-de.html.markdown b/de-de/markdown-de.html.markdown
index 2c838660..cccf5e68 100644
--- a/de-de/markdown-de.html.markdown
+++ b/de-de/markdown-de.html.markdown
@@ -14,7 +14,7 @@ Syntax, in der sich Dokumente leicht schreiben *und* lesen lassen. Außerdem
sollte Markdown sich leicht nach HTML (und in andere Formate) konvertieren
lassen.
-```markdown
+```md
<!-- Markdown ist eine Obermenge von HTML - jede valide HTML-Datei ist also
automatisch valides Markdown - was heisst dass wir jedes HTML-Element (also auch
Kommentare) in Markdown benutzen können, ohne dass der Parser sie verändert.
@@ -253,4 +253,4 @@ Ganz schön hässlich | vielleicht doch lieber | wieder aufhören
Mehr Informationen gibt es in [John Gruber's offiziellem Blog-Post](http://daringfireball.net/projects/markdown/syntax)
und bei Adam Pritchards [grandiosem Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-Infos zu GitHub Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown). \ No newline at end of file
+Infos zu GitHub Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).
diff --git a/de-de/nix-de.html.markdown b/de-de/nix-de.html.markdown
new file mode 100644
index 00000000..79b60d20
--- /dev/null
+++ b/de-de/nix-de.html.markdown
@@ -0,0 +1,358 @@
+---
+language: nix
+filename: learnnix-de.nix
+contributors:
+ - ["Chris Martin", "http://chris-martin.org/"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+Nix ist eine simple funktionale Programmiersprache, die für den
+[Nix package manager](https://nixos.org/nix/) und
+[NixOS](https://nixos.org/) entwickelt wurde.
+
+Du kannst Nix Ausdrücke evaluieren mithilfe von
+[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
+oder [`nix-repl`](https://github.com/edolstra/nix-repl).
+
+```
+with builtins; [
+
+ # Kommentare
+ #=========================================
+
+ # Inline Kommentare sehen so aus.
+
+ /* Multizeilen Kommentare
+ sehen so aus. */
+
+
+ # Booleans
+ #=========================================
+
+ (true && false) # Und
+ #=> false
+
+ (true || false) # Oder
+ #=> true
+
+ (if 3 < 4 then "a" else "b") # Bedingungen
+ #=> "a"
+
+
+ # Integers
+ #=========================================
+
+ # Integers sind die einzigen numerischen Typen.
+
+ 1 0 42 (-3) # Einige integers
+
+ (4 + 6 + 12 - 2) # Addition
+ #=> 20
+
+ (7 / 2) # Division
+ #=> 3
+
+
+ # Strings
+ #=========================================
+
+ "String Literale sind in Anführungszeichen."
+
+ "
+ String Literale können mehrere
+ Zeilen umspannen.
+ "
+
+ ''
+ Dies wird als Literal mit eingerückten String bezeichnet.
+ Es entfernt intelligent führende Leerzeichen.
+ ''
+
+ ''
+ a
+ b
+ ''
+ #=> "a\n b"
+
+ ("ab" + "cd") # String Konkatenation
+ #=> "abcd"
+
+ # Mit Antiquotation kannst du Werte in Strings einbetten.
+ ("Dein Homeverzeichnis ist ${getEnv "HOME"}")
+ #=> "Dein Homeverzeichnis ist /home/alice"
+
+
+ # Paths
+ #=========================================
+
+ # Nix besitzt einen primitiven Datentyp für Pfade
+ /tmp/tutorials/learn.nix
+
+ # Ein relativer Pfad wird beim Parsing zu einem absoluten Pfad aufgelöst,
+ # relativ zu der Datei in der es auftritt.
+ tutorials/learn.nix
+ #=> /the-base-path/tutorials/learn.nix
+
+ # Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine
+ # Datei im selben Verzeichnis benötigt ein ./ Präfix.
+ ./learn.nix
+ #=> /the-base-path/learn.nix
+
+ # Der / Operator muss von Leerraum umgeben sein wenn du dividieren möchtest.
+ 7/2 # Das ist ein Pfadliteral
+ (7 / 2) # Das ist ein Integerliteral
+
+
+ # Importe
+ #=========================================
+
+ # Eine nix Datei besitzt einen einzelnen top-level Ausdruck mit keinen freien Variablen.
+ # Ein Import-Ausdruck wird zum Wert der Datei, die importiert wird, ausgewertet.
+ (import /tmp/foo.nix)
+
+ # Importe können ebenso mit Strings spezifiziert werden.
+ (import "/tmp/foo.nix")
+
+ # Import Pfade müssen absolut sein. Pfadliterale
+ # sind automatisch aufgelöst, das ist ein Ordnung.
+ (import ./foo.nix)
+
+ # Jedoch passiert dies nicht mit Strings.
+ (import "./foo.nix")
+ #=> error: string ‘foo.nix’ doesn't represent an absolute path
+
+
+ # Let
+ #=========================================
+
+ # `let` Blöcke erlauben es uns Werte zu Variablen zu binden.
+ (let x = "a"; in
+ x + x + x)
+ #=> "aaa"
+
+ # Bindungen können auf sich gegenseitig verweisen. Die Reihenfolge spielt
+ # keine Rolle.
+ (let y = x + "b";
+ x = "a"; in
+ y + "c")
+ #=> "abc"
+
+ # Innere Bindungen überschatten Äußere.
+ (let a = 1; in
+ let a = 2; in
+ a)
+ #=> 2
+
+
+ # Funktionen
+ #=========================================
+
+ (n: n + 1) # Funktion, die 1 addiert
+
+ ((n: n + 1) 5) # Dieselbe Funktion angewendet auf 5.
+ #=> 6
+
+ # Es gibt keine spezielle Syntax für benannte Funktionen, aber sie
+ # können mit `let` Blöcken, wie jeder andere Wert auch, gebunden werden.
+ (let succ = (n: n + 1); in succ 5)
+ #=> 6
+
+ # Eine Funktion hat genau ein Argument.
+ # Mehrere Argumente können erreicht werden mithilfe von Currying.
+ ((x: y: x + "-" + y) "a" "b")
+ #=> "a-b"
+
+ # Benannte Funktionsargumente gibt es auch. Diese werden wir einführen, nachdem wir uns Sets
+ # angeschaut haben.
+
+ # Listen
+ #=========================================
+
+ # Listen werden durch eckige Klammern gekennzeichnet.
+
+ (length [1 2 3 "x"])
+ #=> 4
+
+ ([1 2 3] ++ [4 5])
+ #=> [1 2 3 4 5]
+
+ (concatLists [[1 2] [3 4] [5]])
+ #=> [1 2 3 4 5]
+
+ (head [1 2 3])
+ #=> 1
+ (tail [1 2 3])
+ #=> [2 3]
+
+ (elemAt ["a" "b" "c" "d"] 2)
+ #=> "c"
+
+ (elem 2 [1 2 3])
+ #=> true
+ (elem 5 [1 2 3])
+ #=> false
+
+ (filter (n: n < 3) [1 2 3 4])
+ #=> [ 1 2 ]
+
+
+ # Sets
+ #=========================================
+
+ # Ein "Set" ist eine ungeordnete Zuordnung mit Stringschlüsseln.
+ { foo = [1 2]; bar = "x"; }
+
+ # Der . Operator nimmt einen Wert aus dem Set.
+ { a = 1; b = 2; }.a
+ #=> 1
+
+ # Der ? Operator testet, ob der Schlüssel in dem Set vorhanden ist.
+ ({ a = 1; b = 2; } ? a)
+ #=> true
+ ({ a = 1; b = 2; } ? c)
+ #=> false
+
+ # Der // Operator mergt zwei Sets.
+ ({ a = 1; } // { b = 2; })
+ #=> { a = 1; b = 2; }
+
+ # Werte auf der rechten Seite überschreiben die Werte auf der linken Seite.
+ ({ a = 1; b = 2; } // { a = 3; c = 4; })
+ #=> { a = 3; b = 2; c = 4; }
+
+ # Das Schlüsselwort rec bezeichenet ein "rekursives Set", in dem sich Attribute
+ # aufeinander beziehen können.
+ (let a = 1; in { a = 2; b = a; }.b)
+ #=> 1
+ (let a = 1; in rec { a = 2; b = a; }.b)
+ #=> 2
+
+ # Verschachtelte Sets können stückweise definiert werden.
+ {
+ a.b = 1;
+ a.c.d = 2;
+ a.c.e = 3;
+ }.a.c
+ #=> { d = 2; e = 3; }
+
+ # Die Nachkommen eines Attributs können in diesem Feld nicht zugeordnet werden, wenn
+ # das Attribut selbst nicht zugewiesen wurde.
+ {
+ a = { b = 1; };
+ a.c = 2;
+ }
+ #=> error: attribute ‘a’ already defined
+
+
+ # With
+ #=========================================
+
+ # Der Körper eines Sets Blocks wird mit der Zuordnung eines Satzes an die Variablen gebunden.
+ (with { a = 1; b = 2; };
+ a + b)
+ # => 3
+
+ # Innere Bindungen überschatten äußere Bindungen.
+ (with { a = 1; b = 2; };
+ (with { a = 5; };
+ a + b))
+ #=> 7
+
+ # Die erste Linie diese Tutorials startet mit "with builtins;",
+ # weil builtins ein Set mit allen eingebauten
+ # Funktionen (length, head, tail, filter, etc.) umfasst.
+ # Das erspart uns beispielsweise "builtins.length" zu schreiben,
+ # anstatt nur "length".
+
+
+ # Set patterns
+ #=========================================
+
+ # Sets sind nützlich, wenn du mehrere Werte einer Funktion
+ # übergeben musst.
+ (args: args.x + "-" + args.y) { x = "a"; y = "b"; }
+ #=> "a-b"
+
+ # Dies kann mit Hilfe von Set patterns deutlicher geschrieben werden.
+ ({x, y}: x + "-" + y) { x = "a"; y = "b"; }
+ #=> "a-b"
+
+ # Standardmäßig schlägt das Muster bei Sets mit zusätzlichen Schlüsseln fehl.
+ ({x, y}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+ #=> error: anonymous function called with unexpected argument ‘z’
+
+ # Durch Hinzufügen von ", ..." können zusätzliche Schlüssel ignoriert werden.
+ ({x, y, ...}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+ #=> "a-b"
+
+
+ # Errors
+ #=========================================
+
+ # `throw` bewirkt, dass die Auswertung mit einer Fehlermeldung abgebrochen wird.
+ (2 + (throw "foo"))
+ #=> error: foo
+
+ # `tryEval` fängt geworfene Fehler.
+ (tryEval 42)
+ #=> { success = true; value = 42; }
+ (tryEval (2 + (throw "foo")))
+ #=> { success = false; value = false; }
+
+ # `abort` ist ähnlich wie throw, aber es ist fatal. Es kann nicht gefangen werden.
+ (tryEval (abort "foo"))
+ #=> error: evaluation aborted with the following error message: ‘foo’
+
+ # `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst
+ # löst es eine abfangbare Exception aus.
+ (assert 1 < 2; 42)
+ #=> 42
+ (assert 1 > 2; 42)
+ #=> error: assertion failed at (string):1:1
+ (tryEval (assert 1 > 2; 42))
+ #=> { success = false; value = false; }
+
+
+ # Impurity
+ #=========================================
+
+ # Da die Wiederholbarkeit von Builds für den Nix Packetmanager entscheidend ist,
+ # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar
+ # unreine Elemente.
+ # Du kannst auf Umgebungsvariablen verweisen.
+ (getEnv "HOME")
+ #=> "/home/alice"
+
+ # Die trace Funktion wird zum Debugging verwendet. Sie gibt das erste Argument zu stderr aus
+ # und evaluiert das zweite Argument.
+ (trace 1 2)
+ #=> trace: 1
+ #=> 2
+
+ # Du kannst Dateien in den Nix Store schreiben. Obwohl unrein, kannst du dir relativ sicher sein,
+ # dass es sicher ist, da der Dateiname aus dem Hash des Inhalts abgeleitet wird.
+ # Du kannst Dateien von überall lesen. In diesem Beispiel schreiben wir Dateien in den Store
+ # und lesen wieder davon.
+ (let filename = toFile "foo.txt" "hello!"; in
+ [filename (builtins.readFile filename)])
+ #=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ]
+
+ # Außerdem können wir Dateien in den Nix Store herunterladen.
+ (fetchurl "https://example.com/package-1.2.3.tgz")
+ #=> "/nix/store/2drvlh8r57f19s9il42zg89rdr33m2rm-package-1.2.3.tgz"
+
+]
+```
+
+### Weitere Ressourcen
+
+* [Nix Manual - Nix expression language]
+ (https://nixos.org/nix/manual/#ch-expression-language)
+
+* [James Fisher - Nix by example - Part 1: The Nix expression language]
+ (https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55)
+
+* [Susan Potter - Nix Cookbook - Nix By Example]
+ (http://funops.co/nix-cookbook/nix-by-example/)
diff --git a/de-de/opencv-de.html.markdown b/de-de/opencv-de.html.markdown
new file mode 100644
index 00000000..2d9a2c4e
--- /dev/null
+++ b/de-de/opencv-de.html.markdown
@@ -0,0 +1,153 @@
+---
+category: tool
+tool: OpenCV
+filename: learnopencv.py
+contributors:
+ - ["Yogesh Ojha", "http://github.com/yogeshojha"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+### Opencv
+
+OpenCV (Open Source Computer Vision) ist eine Bibliothek von Programmierfunktionen,
+die hauptsächlich auf maschinelles Sehen in Echtzeit ausgerichtet ist.
+Ursprünglich wurde OpenCV von Intel entwickelt. Später wurde es von von
+Willow Garage und dann Itseez (das später von Intel übernommen wurde) unterstützt.
+OpenCV unterstützt derzeit eine Vielzahl von Sprachen, wie C++, Python, Java uvm.
+
+#### Installation
+
+Bitte lese diese Artikel für die Installation von OpenCV auf deinen Computer.
+
+* Windows Installationsanleitung: [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_setup_in_windows/py_setup_in_windows.html#install-opencv-python-in-windows]()
+* Mac Installationsanleitung (High Sierra): [https://medium.com/@nuwanprabhath/installing-opencv-in-macos-high-sierra-for-python-3-89c79f0a246a]()
+* Linux Installationsanleitung (Ubuntu 18.04): [https://www.pyimagesearch.com/2018/05/28/ubuntu-18-04-how-to-install-opencv]()
+
+### Hier werden wir uns auf die Pythonimplementierung von OpenCV konzentrieren.
+
+```python
+# Bild in OpenCV lesen
+import cv2
+img = cv2.imread('Katze.jpg')
+
+# Bild darstellen
+# Die imshow() Funktion wird verwendet um das Display darzustellen.
+cv2.imshow('Image',img)
+# Das erste Argument ist der Titel des Fensters und der zweite Parameter ist das Bild
+# Wenn du den Fehler Object Type None bekommst ist eventuell dein Bildpfad falsch.
+# Bitte überprüfe dann den Pfad des Bildes erneut.
+cv2.waitKey(0)
+# waitKey() ist eine Tastaturbindungsfunktion, sie nimmt Argumente in
+# Millisekunden an. Für GUI Ereignisse MUSST du die waitKey() Funktion verwenden.
+
+# Ein Bild schreiben
+cv2.imwrite('graueKatze.png',img)
+# Das erste Arkument ist der Dateiname und das Zweite ist das Bild
+
+# Konveriere das Bild zu Graustufen
+gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+# Videoaufnahme von der Webcam
+cap = cv2.VideoCapture(0)
+# 0 ist deine Kamera, wenn du mehrere Kameras hast musst du deren Id eingeben
+while(True):
+ # Erfassen von Einzelbildern
+ _, frame = cap.read()
+ cv2.imshow('Frame',frame)
+ # Wenn der Benutzer q drückt -> beenden
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+# Die Kamera muss wieder freigegeben werden
+cap.release()
+
+# Wiedergabe von Videos aus einer Datei
+cap = cv2.VideoCapture('film.mp4')
+while(cap.isOpened()):
+ _, frame = cap.read()
+ # Das Video in Graustufen abspielen
+ gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+ cv2.imshow('frame',gray)
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+cap.release()
+
+# Zeichne eine Linie in OpenCV
+# cv2.line(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)
+cv2.line(img,(0,0),(511,511),(255,0,0),5)
+
+# Zeichne ein Rechteck
+# cv2.rectangle(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)
+# thickness = -1 wird zum Füllen des Rechtecks verwendet
+cv2.rectangle(img,(384,0),(510,128),(0,255,0),3)
+
+# Zeichne ein Kreis
+cv2.circle(img,(xCenter,yCenter), radius, (color->r,g,b->0 to 255), thickness)
+cv2.circle(img,(200,90), 100, (0,0,255), -1)
+
+# Zeichne eine Ellipse
+cv2.ellipse(img,(256,256),(100,50),0,0,180,255,-1)
+
+# Text auf Bildern hinzufügen
+cv2.putText(img,"Hello World!!!", (x,y), cv2.FONT_HERSHEY_SIMPLEX, 2, 255)
+
+# Bilder zusammenfüggen
+img1 = cv2.imread('Katze.png')
+img2 = cv2.imread('openCV.jpg')
+dst = cv2.addWeighted(img1,0.5,img2,0.5,0)
+
+# Schwellwertbild
+# Binäre Schwellenwerte
+_,thresImg = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
+# Anpassbare Schwellenwerte
+adapThres = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,2)
+
+# Weichzeichnung von einem Bild
+# Gausßscher Weichzeichner
+blur = cv2.GaussianBlur(img,(5,5),0)
+# Rangordnungsfilter
+medianBlur = cv2.medianBlur(img,5)
+
+# Canny-Algorithmus
+img = cv2.imread('Katze.jpg',0)
+edges = cv2.Canny(img,100,200)
+
+# Gesichtserkennung mit Haarkaskaden
+# Lade die Haarkaskaden von https://github.com/opencv/opencv/blob/master/data/haarcascades/ herunter
+import cv2
+import numpy as np
+face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
+
+img = cv2.imread('Mensch.jpg')
+gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+aces = face_cascade.detectMultiScale(gray, 1.3, 5)
+for (x,y,w,h) in faces:
+ cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
+ roi_gray = gray[y:y+h, x:x+w]
+ roi_color = img[y:y+h, x:x+w]
+ eyes = eye_cascade.detectMultiScale(roi_gray)
+ for (ex,ey,ew,eh) in eyes:
+ cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
+
+cv2.imshow('img',img)
+cv2.waitKey(0)
+
+cv2.destroyAllWindows()
+# destroyAllWindows() zerstört alle Fenster
+# Wenn du ein bestimmtes Fenter zerstören möchtest musst du den genauen Namen des
+# von dir erstellten Fensters übergeben.
+```
+
+### Weiterführende Literatur:
+* Lade Kaskade hier herunter [https://github.com/opencv/opencv/blob/master/data/haarcascades]()
+* OpenCV Zeichenfunktionen [https://docs.opencv.org/2.4/modules/core/doc/drawing_functions.html]()
+* Eine aktuelle Sprachenreferenz kann hier gefunden werden [https://opencv.org]()
+* Zusätzliche Ressourcen können hier gefunden werden [https://en.wikipedia.org/wiki/OpenCV]()
+* Gute OpenCV Tutorials
+ * [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html]()
+ * [https://realpython.com/python-opencv-color-spaces]()
+ * [https://pyimagesearch.com]()
+ * [https://www.learnopencv.com]()
+ * [https://docs.opencv.org/master/]()
diff --git a/de-de/paren-de.html.markdown b/de-de/paren-de.html.markdown
new file mode 100644
index 00000000..0d914c05
--- /dev/null
+++ b/de-de/paren-de.html.markdown
@@ -0,0 +1,200 @@
+---
+
+language: Paren
+filename: learnparen.paren
+contributors:
+ - ["KIM Taegyoon", "https://github.com/kimtg"]
+ - ["Claudson Martins", "https://github.com/claudsonm"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+[Paren](https://bitbucket.org/ktg/paren) ist ein Dialekt von Lisp.
+Es ist als eingebettete Sprache konzipiert.
+
+Manche Beispiele sind von <http://learnxinyminutes.com/docs/racket/>.
+
+```scheme
+;;; Kommentare
+# Kommentare
+
+;; Einzeilige Kommentare starten mit einem Semikolon oder einem Hashtag
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Primitive Datentypen und Operatoren
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Zahlen
+123 ; int
+3.14 ; double
+6.02e+23 ; double
+(int 3.14) ; => 3 : int
+(double 123) ; => 123 : double
+
+;; Funktionsapplikationen werden so geschrieben: (f x y z ...)
+;; Dabei ist f eine Funktion und x, y, z sind die Operatoren.
+;; Wenn du eine Literalliste von Daten erstelllen möchtest,
+;; verwende (quote) um zu verhindern, dass sie ausgewertet zu werden.
+(quote (+ 1 2)) ; => (+ 1 2)
+;; Nun einige arithmetische Operationen
+(+ 1 1) ; => 2
+(- 8 1) ; => 7
+(* 10 2) ; => 20
+(^ 2 3) ; => 8
+(/ 5 2) ; => 2
+(% 5 2) ; => 1
+(/ 5.0 2) ; => 2.5
+
+;;; Wahrheitswerte
+true ; for Wahr
+false ; for Falsch
+(! true) ; => Falsch
+(&& true false (prn "doesn't get here")) ; => Falsch
+(|| false true (prn "doesn't get here")) ; => Wahr
+
+;;; Zeichen sind Ints.
+(char-at "A" 0) ; => 65
+(chr 65) ; => "A"
+
+;;; Zeichenketten sind ein Array von Zahlen mit fester Länge.
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel" ; Backslash ist ein Escape-Zeichen
+"Foo\tbar\r\n" ; beinhaltet C Escapes: \t \r \n
+
+;; Zeichenketten können auch verbunden werden!
+(strcat "Hello " "world!") ; => "Hello world!"
+
+;; Eine Zeichenketten kann als Liste von Zeichen behandelt werden
+(char-at "Apple" 0) ; => 65
+
+;; Drucken ist ziemlich einfach
+(pr "Ich bin" "Paren. ") (prn "Schön dich zu treffen!")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variablen
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Du kannst Variablen setzen indem du (set) verwedest
+;; eine Variable kann alle Zeichen besitzen außer: ();#"
+(set some-var 5) ; => 5
+some-var ; => 5
+
+;; Zugriff auf eine zuvor nicht zugewiesene Variable erzeugt eine Ausnahme
+; x ; => Unknown variable: x : nil
+
+;; Lokale Bindung: Verwende das Lambda Calculus! 'a' und 'b'
+;; sind nur zu '1' und '2' innerhalb von (fn ...) gebunden.
+((fn (a b) (+ a b)) 1 2) ; => 3
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Sammlungen
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Listen
+
+;; Listen sind Vektrorartige Datenstrukturen. (Zufälliger Zugriff ist O(1).
+(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
+;; 'list' ist ein komfortabler variadischer Konstruktor für Listen
+(list 1 2 3) ; => (1 2 3)
+;; und ein quote kann als literaler Listwert verwendet werden
+(quote (+ 1 2)) ; => (+ 1 2)
+
+;; Du kannst 'cons' verwenden um ein Element an den Anfang einer Liste hinzuzufügen.
+(cons 0 (list 1 2 3)) ; => (0 1 2 3)
+
+;; Listen sind ein sehr einfacher Typ, daher gibt es eine Vielzahl an Funktionen
+;; für Sie. Ein paar Beispiele:
+(map inc (list 1 2 3)) ; => (2 3 4)
+(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4)
+(length (list 1 2 3 4)) ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Funktionen
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Verwende 'fn' um Funktionen zu erstellen.
+;; eine Funktion gibt immer den Wert ihres letzten Ausdrucks zurück
+(fn () "Hello World") ; => (fn () Hello World) : fn
+
+;; Verwende Klammern um alle Funktionen aufzurufen, inklusive Lambda Ausdrücke
+((fn () "Hello World")) ; => "Hello World"
+
+;; Zuweisung einer Funktion zu einer Variablen
+(set hello-world (fn () "Hello World"))
+(hello-world) ; => "Hello World"
+
+;; Du kannst dies mit syntaktischen Zucker für die Funktionsdefinition verkürzen:
+(defn hello-world2 () "Hello World")
+
+;; Die () von oben ist eine Liste von Argumente für die Funktion.
+(set hello
+ (fn (name)
+ (strcat "Hello " name)))
+(hello "Steve") ; => "Hello Steve"
+
+;; ... oder gleichwertig, unter Verwendung mit syntaktischen Zucker:
+(defn hello2 (name)
+ (strcat "Hello " name))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Gleichheit
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Für Zahlen verwende '=='
+(== 3 3.0) ; => wahr
+(== 2 1) ; => falsch
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Kontrollfluss
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Bedingungen
+
+(if true ; test Ausdruck
+ "this is true" ; then Ausdruck
+ "this is false") ; else Ausdruck
+; => "this is true"
+
+;;; Schleifen
+
+;; for Schleifen ist für Zahlen
+;; (for SYMBOL START ENDE SCHRITT AUSDRUCK ..)
+(for i 0 10 2 (pr i "")) ; => schreibt 0 2 4 6 8 10
+(for i 0.0 10 2.5 (pr i "")) ; => schreibt 0 2.5 5 7.5 10
+
+;; while Schleife
+((fn (i)
+ (while (< i 10)
+ (pr i)
+ (++ i))) 0) ; => schreibt 0123456789
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Verwende 'set' um einer Variablen oder einer Stelle einen neuen Wert zuzuweisen.
+(set n 5) ; => 5
+(set n (inc n)) ; => 6
+n ; => 6
+(set a (list 1 2)) ; => (1 2)
+(set (nth 0 a) 3) ; => 3
+a ; => (3 2)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Makros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Makros erlauben es dir die Syntax der Sprache zu erweitern.
+;; Parens Makros sind einfach.
+;; Tatsächlich ist (defn) ein Makro.
+(defmacro setfn (name ...) (set name (fn ...)))
+(defmacro defn (name ...) (def name (fn ...)))
+
+;; Lass uns eine Infix Notation hinzufügen
+;; Let's add an infix notation
+(defmacro infix (a op ...) (op a ...))
+(infix 1 + 2 (infix 3 * 4)) ; => 15
+
+;; Makros sind nicht hygenisch, Du kannst bestehende Variablen überschreiben!
+;; Sie sind Codetransformationenen.
+```
diff --git a/de-de/pyqt-de.html.markdown b/de-de/pyqt-de.html.markdown
new file mode 100644
index 00000000..93ee20d4
--- /dev/null
+++ b/de-de/pyqt-de.html.markdown
@@ -0,0 +1,89 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-de.py
+contributors:
+ - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+**Qt** ist eine weit bekanntes Framework mit den man plattformunabhängige Programme schreiben kann,
+die auf verschiedenen Sotfware und Hardware Plattformen laufen mit kleinen oder keinen Änderungen im Code.
+Dabei besitzen sie trozdem die Power und Geschwindigkeit von nativen Anwendungen.
+**Qt** wurde ursprünglich in *C++** geschrieben.
+
+Das ist eine Adaption von dem C++ Intro für QT von [Aleksey Kholovchuk](https://github.com/vortexxx192),
+manche der Codebeispiele sollte in der selben Funktionalität resultieren.
+Diese Version wurde in pyqt erstellt.
+
+```python
+import sys
+from PyQt4 import QtGui
+
+def window():
+ # Erschafft ein Anwendungsobjekt.
+ app = QtGui.QApplication(sys.argv)
+ # Erschafft ein Widget, auf dem unser Label platziert wird.
+ w = QtGui.QWidget()
+ # Fügt ein Label zu dem Widget hinzu.
+ b = QtGui.QLabel(w)
+ # Setzt einen Text für das Label.
+ b.setText("Hello World!")
+ # Setzt die Größe und die Platzierungsinfomationen.
+ w.setGeometry(100, 100, 200, 50)
+ b.move(50, 20)
+ # Setzt unserem Fenster einen schönen Titel.
+ w.setWindowTitle("PyQt")
+ # Lässt alles anzeigen.
+ w.show()
+ # Führe alles aus, nachdem wir alles aufgebaut haben.
+ sys.exit(app.exec_())
+
+if __name__ == '__main__':
+ window()
+
+```
+
+Damit wir weitere fortgeschrittene Funktionen in **pyqt** verwenden können,
+müssen wir anfangen zusätzliche Elemente zu bauen.
+Hier zeigen wir wie man eine Dialog Popup Box einführt.
+Diese ist nützlich, um den Benutzer eine Entscheidung zu bestätigen oder um Informationen anzuzeigen.
+
+```Python
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+ app = QApplication(sys.argv)
+ w = QWidget()
+ # Erschafft einen Knopf und fügt das Widget w hinzu
+ b = QPushButton(w)
+ b.setText("drücke mich")
+ b.move(50, 50)
+ # Wenn b gedrückt wird, wird diese Funktion aufgerufen.
+ # Bemerke das Fehlen von () bei dem Funktionsaufruf.
+ b.clicked.connect(showdialog)
+ w.setWindowTitle("PyQt Dialog")
+ w.show()
+ sys.exit(app.exec_())
+
+# Diese Funktion soll ein Dialogfenster mit einem Knopf erschaffen.
+# Der Knopf wartet bis er geklickt wird und beendet das Programm
+def showdialog():
+ d = QDialog()
+ b1 = QPushButton("ok", d)
+ b1.move(50, 50)
+ d.setWindowTitle("Dialog")
+ # Diese Modalität sagt dem Popup, dass es den Parent blocken soll, solange es aktiv ist.
+ d.setWindowModality(Qt.ApplicationModal)
+ # Beim klicken möchte ich, dass der gesamte Prozess beendet wird.
+ b1.clicked.connect(sys.exit)
+ d.exec_()
+
+if __name__ == '__main__':
+ window()
+```
diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown
index ef1786c8..b313727c 100644
--- a/de-de/python3-de.html.markdown
+++ b/de-de/python3-de.html.markdown
@@ -146,13 +146,13 @@ bool({}) #=> False
####################################################
# Textausgabe ist sehr einfach
-print "Ich bin Python. Schön, dich kennenzulernen!"
+print("Ich bin Python. Schön, dich kennenzulernen!")
# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren.
some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm
some_var #=> 5
-# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus.
+# Das Ansprechen einer noch nicht deklarierten Variable löst eine Exception aus.
# Unter "Kontrollstruktur" kann noch mehr über
# Ausnahmebehandlung erfahren werden.
some_unknown_var # Löst einen NameError aus
@@ -225,7 +225,7 @@ a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3
# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen
d, e, f = 4, 5, 6
# Es ist kinderleicht zwei Werte zu tauschen
-e, d = d, e # d is now 5 and e is now 4
+e, d = d, e # d ist nun 5 und e ist nun 4
# Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare
@@ -307,11 +307,11 @@ some_var = 5
# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig!
# gibt "some_var ist kleiner als 10" aus
if some_var > 10:
- print "some_var ist viel größer als 10."
+ print("some_var ist viel größer als 10.")
elif some_var < 10: # Dieser elif-Absatz ist optional.
- print "some_var ist kleiner als 10."
+ print("some_var ist kleiner als 10.")
else: # Das hier ist auch optional.
- print "some_var ist tatsächlich 10."
+ print("some_var ist tatsächlich 10.")
"""
@@ -334,7 +334,7 @@ Ausgabe:
3
"""
for i in range(4):
- print i
+ print(i)
"""
"range(unten, oben)" gibt eine Liste von der unteren Zahl bis zur oberen Zahl aus
@@ -357,7 +357,7 @@ Ausgabe:
"""
x = 0
while x < 4:
- print x
+ print(x)
x += 1 # Kurzform für x = x + 1
# Ausnahmebehandlung mit einem try/except-Block
@@ -379,8 +379,8 @@ with open("meineDatei.txt") as f:
print(line)
# Python bietet ein fundamentales Konzept der Iteration.
-# Das Objekt, auf das die Interation, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
-# Die range Method gibt ein solches Objekt aus.
+# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
+# Die range Methode gibt ein solches Objekt aus.
filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
@@ -396,8 +396,8 @@ our_iterable[1] # TypeError
# Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft.
our_iterator = iter(our_iterable)
-# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es geraden hat während wir durch es gehen.
-# Das jeweeils nächste Objekt bekommen wir mit "next()"
+# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat während wir durch es gehen.
+# Das jeweils nächste Objekt bekommen wir mit "next()"
next(our_iterator) #=> "one"
# Es hält den vorherigen Status
@@ -418,7 +418,7 @@ list(filled_dict.keys()) #=> ["one", "two", "three"]
# Mit def neue Funktionen erstellen
def add(x, y):
- print "x ist %s und y ist %s" % (x, y)
+ print("x ist %s und y ist %s" % (x, y))
return x + y # Werte werden mit return zurückgegeben
# Funktionen mit Parametern aufrufen
@@ -442,10 +442,10 @@ def keyword_args(**kwargs):
# Rufen wir es mal auf, um zu sehen, was passiert
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
-# Wir können beides gleichzeitig machem, wenn wir wollen
+# Wir können beides gleichzeitig machen, wenn wir wollen
def all_the_args(*args, **kwargs):
- print args
- print kwargs
+ print(args)
+ print(kwargs)
"""
all_the_args(1, 2, a=3, b=4) Ausgabe:
(1, 2)
@@ -532,10 +532,10 @@ class Human(object):
# Eine Instanz einer Klasse erstellen
i = Human(name="Ian")
-print i.say("hi") # gibt "Ian: hi" aus
+print(i.say("hi")) # gibt "Ian: hi" aus
j = Human("Joel")
-print j.say("hello") #gibt "Joel: hello" aus
+print(j.say("hello")) #gibt "Joel: hello" aus
# Rufen wir mal unsere Klassenmethode auf
i.get_species() #=> "H. sapiens"
@@ -555,12 +555,12 @@ Human.grunt() #=> "*grunt*"
# Wir können Module importieren
import math
-print math.sqrt(16) #=> 4
+print(math.sqrt(16)) #=> 4
# Wir können auch nur spezielle Funktionen eines Moduls importieren
from math import ceil, floor
-print ceil(3.7) #=> 4.0
-print floor(3.7) #=> 3.0
+print(ceil(3.7)) #=> 4.0
+print(floor(3.7)) #=> 3.0
# Wir können auch alle Funktionen eines Moduls importieren
# Warnung: Dies wird nicht empfohlen
diff --git a/de-de/qt-de.html.markdown b/de-de/qt-de.html.markdown
new file mode 100644
index 00000000..480030fe
--- /dev/null
+++ b/de-de/qt-de.html.markdown
@@ -0,0 +1,175 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-de.cpp
+contributors:
+ - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+**Qt** ist ein weithin bekanntes Framework zum Entwickeln von cross-platform Software,
+die auf verschiedenen Hard- und Softwareplatformen mit wenig oder keinen Veränderungen im Code läuft.
+Dabei besitzt man die Power und Geschiwindigkeit von nativen Anwendungen.
+Obwohl **Qt** ursprünglich in *C++* geschrieben wurde,
+gibt es verschiedene Ports für andere Sprachen: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** eignet sich hervorragend zum Erstellen von Anwendungen mit grafischer Benutzeroberfläche (GUI).
+Dieses Tutorial zeigt, wie man das in *C++* macht.
+
+```c++
+/*
+ * Lass uns klassisch starten
+ */
+
+// Alle Header vom Qt Framework starten mit dem Großbuchstaben 'Q'.
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+ // Erstellt ein Objekt um applikationsweit die Resourcen zu managen.
+ QApplication app(argc, argv);
+
+ // Erstellt ein Line edit Widget und zeigt es auf dem Bildschirm
+ QLineEdit lineEdit("Hello world!");
+ lineEdit.show();
+
+ // Startet die Event Loop der Anwendung.
+ return app.exec();
+}
+```
+
+Die GUI bezogene Teile von **Qt** bestehen aus *Widgets* und den *Verbindungen*
+dazwischen.
+
+[Lies mehr über Widgets](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Lass uns Label und einen Button machen.
+ * Ein Label soll auftauchen, wenn der Button gedrückt wird.
+ *
+ * Der Qt Code spricht für sich selbst.
+ */
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ // Füge ein vertikales Layout hinzu
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ QLabel textLabel("Danke für das Knopf drücken");
+ layout.addWidget(&textLabel);
+ textLabel.hide();
+
+ QPushButton button("Drück mich");
+ layout.addWidget(&button);
+
+ // Zeigt verstecktes Label, wenn der Button gedrückt wird.
+ QObject::connect(&button, &QPushButton::pressed,
+ &textLabel, &QLabel::show);
+
+ return app.exec();
+}
+```
+
+Beachte den *QObject::connect* Teil. Diese Methode wird verwendet,
+um *Signale* eines Objekts mit den *Slots* eines Objektes zu verbinden.
+
+**Signale** werden ausgegeben, wenn bestimmte Dinge mit Objekten passieren.
+Beispielsweise wird das *pressed* Signal ausgegeben,
+wenn der Benutzer auf das QPushButton Objekt drückt.
+
+**Slots** sind Aktionen, die als Reaktion auf empfangene Signale ausgeführt werden können.
+
+[Lies mehr über Slots und Signale](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+Als Nächstes lernen wir, dass wir nicht nur Standard Widgets verwenden können,
+sondern auch ihr Verhalten mithilfe von Vererbung verändern können.
+Lass uns einen Button erschaffen, der zählt, wie häufig er gedrückt wird.
+Dafür definieren wir unsere eigene Klasse *CounterLabel*.
+Diese muss wegen der speziellen Qt Architektur in einer seperaten Datei deklariert werden.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+ Q_OBJECT // Qt definiertes Makro, welches in jedem modifizierten Widget vorhanden sein muss.
+
+public:
+ CounterLabel() : counter(0) {
+ setText("Zähler wurde noch nicht erhöht."); // Methode von QLabel
+ }
+
+public slots:
+ // Aktion, die ausgeführt wird, wenn der Button gedrückt wird.
+ void increaseCounter() {
+ setText(QString("Zähler Wert: %1").arg(QString::number(++counter)));
+ }
+
+private:
+ int counter;
+};
+
+#endif // Zähllabel
+```
+
+```c++
+// main.cpp
+// Fast das Gleiche, wie das vorherige Beispiel
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ CounterLabel counterLabel;
+ layout.addWidget(&counterLabel);
+
+ QPushButton button("Drück mich nochmal.");
+ layout.addWidget(&button);
+ QObject::connect(&button, &QPushButton::pressed,
+ &counterLabel, &CounterLabel::increaseCounter);
+
+ return app.exec();
+}
+```
+
+Das wars! Natürlich ist das Qt Framework erheblich größer, als der der Teil der in diesem Tutorial behandelt wurde.
+Das heißt, es gibt viel zu lesen und zu üben.
+
+## Further reading
+
+- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Viel Erfolg und viel Spaß!
diff --git a/de-de/rst-de.html.markdown b/de-de/rst-de.html.markdown
new file mode 100644
index 00000000..bcfe21bd
--- /dev/null
+++ b/de-de/rst-de.html.markdown
@@ -0,0 +1,119 @@
+---
+language: restructured text (RST)
+filename: restructuredtext.rst
+contributors:
+ - ["DamienVGN", "https://github.com/martin-damien"]
+ - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+RST ist ein Dateiformat, das von der Python Community entwickelt wurde,
+
+um Dokumentation zu schreiben (und ist somit Teil von Docutils).
+
+RST-Dateien sind simple Textdateien mit einer leichtgewichtigen Syntax (im Vergleich zu HTML).
+
+
+## Installation
+
+Um Restructured Text zu vewenden musst du [Python](http://www.python.org)
+
+installieren und das `docutils` Packet installieren. `docutils` kann mit dem folgenden
+
+Befehl auf der Kommandozeile installiert werden:
+
+```bash
+$ easy_install docutils
+```
+
+Wenn auf deinem System `pip` installiert kannst du es statdessen auch verwenden:
+
+```bash
+$ pip install docutils
+```
+
+
+## Dateisyntax
+
+Ein einfaches Beispiel für die Dateisyntax:
+
+```
+.. Zeilen, die mit zwei Punkten starten sind spezielle Befehle.
+
+.. Wenn kein Befehl gefunden wird, wird die Zeile als Kommentar gewertet.
+
+============================================================================
+Haupttitel werden mit Gleichheitszeichen darüber und darunter gekennzeichnet
+============================================================================
+
+Beachte das es genau so viele Gleichheitszeichen, wie Hauptitelzeichen
+geben muss.
+
+Titel werden auch mit Gleichheitszeichen unterstrichen
+======================================================
+
+Untertitel werden mit Strichen gekennzeichnet
+---------------------------------------------
+
+Text in *kursiv* oder in **fett**. Du kannst Text als Code "makieren", wenn
+du doppelte Backquotes verwendest ``: ``print()``.
+
+Listen sind so einfach wie in Markdown:
+
+- Erstes Element
+- Zweites Element
+ - Unterelement
+
+oder
+
+* Erstes Element
+* Zweites Element
+ * Unterelement
+
+Tabellen sind einfach zu schreiben:
+
+=========== ==========
+Land Hauptstadt
+=========== ==========
+Frankreich Paris
+Japan Tokyo
+=========== ========
+
+Komplexere Tabellen (zusammengeführte Spalten und Zeilen) können einfach
+erstellt werden, aber ich empfehle dir dafür die komplette Dokumentation zu lesen :)
+
+Es gibt mehrere Möglichkeiten um Links zu machen:
+
+- Wenn man einen Unterstrich hinter einem Wort hinzufügt: Github_ Zusätzlich
+muss man die Zielurl nach dem Text hinzufügen.
+(Dies hat den Vorteil, dass man keine unnötigen Urls in lesbaren Text einfügt.
+- Wenn man die vollständige Url eingibt : https://github.com/
+(Dies wird automatisch in ein Link konvertiert.)
+- Wenn man es mehr Markdown ähnlich eingibt: `Github <https://github.com/>`_ .
+
+.. _Github https://github.com/
+
+```
+
+
+## Wie man es verwendet
+
+RST kommt mit docutils, dort hast du den Befehl `rst2html`, zum Beispiel:
+
+```bash
+$ rst2html myfile.rst output.html
+```
+
+*Anmerkung : Auf manchen Systemen könnte es rst2html.py sein*
+
+Es gibt komplexere Anwendungen, die das RST Format verwenden:
+
+- [Pelican](http://blog.getpelican.com/), ein statischer Websitengenerator
+- [Sphinx](http://sphinx-doc.org/), Ein Dokumentationsgenerator
+- und viele Andere
+
+## Zum Lesen
+
+- [Offizielle Schnellreferenz](http://docutils.sourceforge.net/docs/user/rst/quickref.html)
diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index 456403a2..a8344e6a 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -8,89 +8,90 @@ contributors:
- ["Dennis Keller", "github.com/denniskeller"]
translators:
- ["Christian Albrecht", "https://github.com/coastalchief"]
+ - ["Jonas Grote", "https://github.com/exic"]
filename: learnscala-de.scala
lang: de-de
---
-Scala ist eine funktionale und objektorientierte Programmiersprache
-für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben
-zu erledigen. Scala hat einen akademischen Hintergrund und wurde an
+Scala ist eine funktionale und objektorientierte Programmiersprache
+für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben
+zu erledigen. Scala hat einen akademischen Hintergrund und wurde an
der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt.
-```scala
+```scala
/*
-Scala Umgebung einrichten:
+Scala-Umgebung einrichten:
1. Scala binaries herunterladen- http://www.scala-lang.org/downloads
2. Unzip/untar in ein Verzeichnis
-3. das bin Unterverzeichnis der `PATH` Umgebungsvariable hinzufügen
+3. das Unterverzeichnis `bin` der `PATH`-Umgebungsvariable hinzufügen
4. Mit dem Kommando `scala` wird die REPL gestartet und zeigt als Prompt:
scala>
-Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.
-Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt
-ausgegeben.
-Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
+Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.
+Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt
+ausgegeben.
+Als nächstes beschäftigen wir uns mit ein paar Scala-Grundlagen.
*/
/////////////////////////////////////////////////
-// 1. Basics
+// 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
+// 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
+// Einen Wert ohne eine zusätzliche neue Zeile ausgeben:
-print("Hello world")
+print("Hallo Welt")
/*
- Variablen werden entweder mit var oder val deklariert.
- Deklarationen mit val sind immutable, also unveränderlich
- Deklarationen mit var sind mutable, also veränderlich
- Immutability ist gut.
+ Variablen werden entweder mit var oder val deklariert.
+ Deklarationen mit val sind immutable, also unveränderlich.
+ Deklarationen mit var sind mutable, also veränderlich.
+ Immutability ist gut.
*/
val x = 10 // x ist 10
-x = 20 // error: reassignment to val
+x = 20 // Error: reassignment to val (Fehler: neue Zuweisung zu einem unveränderlichen Wert)
var y = 10
y = 20 // y ist jetzt 20
/*
-Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel
-keine Typen an x und y geschrieben haben.
-In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der
-Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist,
-so dass der Typ nicht jedes mal angegeben werden muss.
-Einen Typ gibt man bei einer Variablendeklaration wie folgt an:
+Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel
+keine Typen an x und y geschrieben haben.
+In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt, dass der
+Scala Compiler in den meisten Fällen erraten kann, von welchem Typ eine Variable ist,
+so dass der Typ nicht jedes mal angegeben werden muss.
+Einen Typ gibt man bei einer Variablendeklaration wie folgt an:
*/
val z: Int = 10
val a: Double = 1.0
-// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0
+// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0:
val b: Double = 10
-// Boolean Werte
+// Boolean-Werte:
true
false
-// Boolean Operationen
+// Boolean-Operationen:
!true // false
!false // true
@@ -98,7 +99,7 @@ true == false // false
10 > 5 // true
-// Mathematische Operationen sind wie gewohnt
+// Mathematische Operationen sind wie gewohnt:
1 + 1 // 2
2 - 1 // 1
@@ -108,88 +109,87 @@ true == false // false
6.0 / 4 // 1.5
-// Die Auswertung eines Ausdrucks in der REPL gibt den Typ
-// und das Ergebnis zurück.
+// Die Auswertung eines Ausdrucks in der REPL gibt den Typ
+// und das Ergebnis zurück:
scala> 1 + 7
res29: Int = 8
/*
-Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt
-von Typ Int ist und einen Wert 0 hat.
-"res29" ist ein sequentiell generierter name, um das Ergebnis des
-Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
+Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt
+von Typ Int ist und einen Wert 8 hat.
+"res29" ist ein sequentiell generierter Name, um das Ergebnis des
+Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
*/
-"Scala strings werden in doppelten Anführungszeichen eingeschlossen"
-'a' // A Scala Char
-// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error
-
-// Für Strings gibt es die üblichen Java Methoden
+"Scala strings werden in doppelten Anführungszeichen eingeschlossen"
+'a' // Ein Scala Char
+// 'Einzeln ge-quotete strings gibt es nicht!' <= Das erzeugt einen Fehler!
-"hello world".length
-"hello world".substring(2, 6)
-"hello world".replace("C", "3")
+// Für Strings gibt es die üblichen Java-Methoden:
+"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)
+// Zusätzlich gibt es noch extra Scala-Methoden
+// siehe: scala.collection.immutable.StringOps
+"Hallo Welt".take(5)
+"Hallo Welt".drop(5)
-// String interpolation: prefix "s"
+
+// String-Interpolation: prefix "s":
val n = 45
-s"We have $n apples" // => "We have 45 apples"
+s"Wir haben $n Äpfel" // => "Wir haben 45 Äpfel"
-// Ausdrücke im Innern von interpolierten Strings gibt es auch
+// Ausdrücke im Innern von interpolierten Strings gibt es auch:
val a = Array(11, 9, 6)
-val n = 100
-s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old."
-s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
-s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4"
+s"Meine zweite Tochter ist ${a(0) - a(2)} Jahre alt." // => "Meine zweite Tochter ist 5 Jahre alt."
+s"Wir haben das Doppelte von ${n / 2.0} an Äpfeln." // => "Wir haben das Doppelte von 22.5 an Äpfeln."
+s"2 im Quadrat: ${math.pow(2, 2)}" // => "2 im Quadrat: 4"
-// Formatierung der interpolierten Strings mit dem prefix "f"
+// Formatierung der interpolierten Strings mit dem prefix "f":
-f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25"
-f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
+f"5 im Quadrat: ${math.pow(5, 2)}%1.0f" // "5 im Quadrat: 25"
+f"Quadratwurzel von 122: ${math.sqrt(122)}%1.4f" // "Quadratwurzel von 122: 11.0454"
-// Raw Strings, ignorieren Sonderzeichen.
+// Raw Strings ignorieren Sonderzeichen:
raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
-// Manche Zeichen müssen "escaped" werden, z.B.
-// ein doppeltes Anführungszeichen in innern eines Strings.
+// Manche Zeichen müssen "escaped" werden, z.B.
+// ein doppeltes Anführungszeichen im Innern eines Strings:
-"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+"Sie standen vor der \"Rose and Crown\"" // => "Sie standen vor der "Rose and Crown""
-// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht
-// und Anführungszeichen enthalten kann.
+// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht
+// und Anführungszeichen enthalten kann:
-val html = """<form id="daform">
- <p>Press belo', Joe</p>
+val html = """<form id="dieform">
+ <p>Drück belo', Joe</p>
<input type="submit">
</form>"""
-
+
/////////////////////////////////////////////////
// 2. Funktionen
/////////////////////////////////////////////////
-// Funktionen werden so definiert
-//
-// def functionName(args...): ReturnType = { body... }
-//
-// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck
-// in einer Funktion der Rückgabewert.
+// Funktionen werden so definiert:
+//
+// def functionName(args...): ReturnType = { body... }
+//
+// Beachte: Es wird hier kein Schlüsselwort "return" verwendet.
+// In Scala ist der letzte Ausdruck in einer Funktion der Rückgabewert.
def sumOfSquares(x: Int, y: Int): Int = {
val x2 = x * x
@@ -198,118 +198,118 @@ def sumOfSquares(x: Int, y: Int): Int = {
}
-// Die geschweiften Klammern können weggelassen werden, wenn
-// die Funktion nur aus einem einzigen Ausdruck besteht:
+// Die geschweiften Klammern können weggelassen werden, wenn
+// die Funktion nur aus einem einzigen Ausdruck besteht:
def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
-// Syntax für Funktionsaufrufe:
+// Syntax für Funktionsaufrufe:
sumOfSquares(3, 4) // => 25
-// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können
-// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei
-// Variablen, auch bei Funktionen greift:
+// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen) können
+// Rückgabetypen auch weggelassen werden, da dieselbe Typ-Inferenz, wie bei
+// Variablen, auch bei Funktionen greift:
def sq(x: Int) = x * x // Compiler errät, dass der return type Int ist
-// Funktionen können default parameter haben:
+// Funktionen können Default-Parameter haben:
def addWithDefault(x: Int, y: Int = 5) = x + y
addWithDefault(1, 2) // => 3
addWithDefault(1) // => 6
-// Anonyme Funktionen sehen so aus:
+// Anonyme Funktionen sehen so aus:
(x: Int) => x * x
-// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen
-// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.
-// Beachte den Typ "Int => Int", dies beschreibt eine Funktion,
-// welche Int als Parameter erwartet und Int zurückgibt.
+// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen
+// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.
+// Beachte den Typ "Int => Int", dies beschreibt eine Funktion,
+// welche Int als Parameter erwartet und Int zurückgibt.
val sq: Int => Int = x => x * x
-// Anonyme Funktionen benutzt man ganz normal:
+// Anonyme Funktionen benutzt man ganz normal:
sq(10) // => 100
-// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,
-// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,
-// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge
-// verwendet werden. Diese anonymen Funktionen werden sehr häufig
-// verwendet.
+// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,
+// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,
+// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge
+// verwendet werden. Diese anonymen Funktionen werden sehr häufig
+// verwendet.
-val addOne: Int => Int = _ + 1
-val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
-addOne(5) // => 6
-weirdSum(2, 4) // => 16
+val addOne: Int => Int = _ + 1
+val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
+addOne(5) // => 6
+weirdSum(2, 4) // => 16
-// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung
-// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus
-// dem innersten def, welches den return Ausdruck umgibt, zurück.
-// "return" hat keinen Effekt in anonymen Funktionen:
+// Es gibt ein Schlüsselwort "return" in Scala. Allerdings ist seine Verwendung
+// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus
+// dem innersten def, welches den return Ausdruck umgibt, zurück.
+// "return" hat keinen Effekt in anonymen Funktionen:
-def foo(x: Int): Int = {
- val anonFunc: Int => Int = { z =>
- if (z > 5)
- return z // Zeile macht z zum return Wert von foo
- else
- z + 2 // Zeile ist der return Wert von anonFunc
- }
- anonFunc(x) // Zeile ist der return Wert von foo
-}
+def foo(x: Int): Int = {
+ val anonFunc: Int => Int = { z =>
+ if (z > 5)
+ return z // Zeile macht z zum return Wert von foo
+ else
+ z + 2 // Zeile ist der return Wert von anonFunc
+ }
+ anonFunc(x) // Zeile ist der return Wert von foo
+}
/////////////////////////////////////////////////
-// 3. Flow Control
+// 3. Flusskontrolle
/////////////////////////////////////////////////
-// Wertebereiche und Schleifen
+// Wertebereiche und Schleifen:
1 to 5
val r = 1 to 5
r.foreach(println)
r foreach println
(5 to 1 by -1) foreach (println)
-
-// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende
-// sind optional, beim Aufruf von Methoden können die Punkte
-// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden
-// while Schleife
+// Scala ist syntaktisch sehr großzügig; Semikolons am Zeilenende
+// sind optional, beim Aufruf von Methoden können die Punkte
+// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden.
+
+// while Schleife:
var i = 0
while (i < 10) { println("i " + i); i += 1 }
i // i ausgeben, res3: Int = 10
-// Beachte: while ist eine Schleife im klassischen Sinne -
-// 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.
+// Beachte: while ist eine Schleife im klassischen Sinne -
+// 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 parallelisieren.
-// Ein do while Schleife
+// Ein do while Schleife
do {
- println("x ist immer noch weniger wie 10")
+ println("x ist immer noch weniger als 10")
x += 1
} while (x < 10)
-// Endrekursionen sind ideomatisch um sich wiederholende
-// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
-// return Typ, der Compiler kann ihn nicht erraten.
-// Unit, in diesem Beispiel.
+// Endrekursionen sind idiomatisch um sich wiederholende
+// Aufgaben in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
+// Rückgabe-Typ, der Compiler kann ihn nicht erraten.
+// Der Rückgabe-Typ in diesem Beispiel ist Unit:
def showNumbersInRange(a: Int, b: Int): Unit = {
print(a)
@@ -331,7 +331,7 @@ val text = if (x == 10) "yeah" else "nope"
/////////////////////////////////////////////////
-// 4. Daten Strukturen (Array, Map, Set, Tuples)
+// 4. Datenstrukturen (Array, Map, Set, Tupel)
/////////////////////////////////////////////////
// Array
@@ -344,11 +344,11 @@ a(21) // Exception
// Map - Speichert Key-Value-Paare
-val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+val m = Map("fork" -> "Gabel", "spoon" -> "Löffel", "knife" -> "Messer")
m("fork")
m("spoon")
m("bottle") // Exception
-val safeM = m.withDefaultValue("no lo se")
+val safeM = m.withDefaultValue("unbekannt")
safeM("bottle")
// Set - Speichert Unikate, unsortiert (sortiert -> SortedSet)
@@ -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,15 +368,15 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
(a, 2, "three")
-// Hier ist der Rückgabewert der Funktion ein Tuple
-// Die Funktion gibt das Ergebnis, so wie den Rest zurück.
+// 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
-// Notation: _._n wobei n der index des Elements ist (Index startet bei 1)
+// 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)
d._1
@@ -388,32 +388,32 @@ d._2
/////////////////////////////////////////////////
/*
- Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar
- zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in
- einem Scala file selten alleine zu finden sind.
- Die einzigen Top-Level Konstrukte in Scala sind nämlich:
+ Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar
+ zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in
+ einer Scala-Datei selten alleine zu finden sind.
+ Die einzigen Top-Level-Konstrukte in Scala sind nämlich:
- Klassen (classes)
- Objekte (objects)
- case classes
- traits
- Diesen Sprachelemente wenden wir uns jetzt zu.
+ Diesen Sprachelemente wenden wir uns jetzt zu.
*/
// Klassen
-// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen
-// anderen Sprachen auch.
+// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen
+// anderen Sprachen auch.
-// erzeugt Klasse mit default Konstruktor
+// erzeugt Klasse mit default Konstruktor:
class Hund
scala> val t = new Hund
t: Hund = Hund@7103745
-// Der Konstruktor wird direkt hinter dem Klassennamen deklariert.
+// Der Konstruktor wird direkt hinter dem Klassennamen deklariert.
class Hund(sorte: String)
scala> val t = new Hund("Dackel")
@@ -421,8 +421,8 @@ t: Hund = Hund@14be750c
scala> t.sorte //error: value sorte is not a member of Hund
-// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse
-// Per var wird aus dem Attribut ein veränderliches Feld der Klasse
+// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse
+// Per var wird aus dem Attribut ein veränderliches Feld der Klasse
class Hund(val sorte: String)
scala> val t = new Hund("Dackel")
@@ -431,14 +431,14 @@ scala> t.sorte
res18: String = Dackel
-// Methoden werden mit def geschrieben
+// Methoden werden mit def geschrieben
-def bark = "Woof, woof!"
+def bark = "Wuff, wuff!"
-// Felder und Methoden können public, protected und private sein
-// default ist public
-// private ist nur innerhalb des deklarierten Bereichs sichtbar
+// Felder und Methoden können public, protected und private sein
+// default ist public
+// private ist nur innerhalb des deklarierten Bereichs sichtbar
class Hund {
private def x = ...
@@ -446,8 +446,8 @@ class Hund {
}
-// protected ist nur innerhalb des deklarierten und aller
-// erbenden Bereiche sichtbar
+// protected ist nur innerhalb des deklarierten und aller
+// erbenden Bereiche sichtbar
class Hund {
protected def x = ...
@@ -457,12 +457,12 @@ class Dackel extends Hund {
}
// Object
-// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.
-// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so
-// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse
-// benutzen ohne ein Objekt instanziieren zu müssen.
-// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn
-// es genauso heisst und in derselben Datei wie die Klasse definiert wurde.
+// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.
+// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so
+// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse
+// verwenden, ohne ein Objekt instanziieren zu müssen.
+// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn
+// es genauso heißt und in derselben Datei wie die Klasse definiert wurde.
object Hund {
def alleSorten = List("Pitbull", "Dackel", "Retriever")
@@ -470,50 +470,51 @@ object Hund {
}
// Case classes
-// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra
-// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar
-// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.
-// ein companion object mit den entsprechenden Methoden,
-// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch
-// Getter für unsere Attribute (das Angeben von val entfällt dadurch)
+// Fallklassen bzw. Case classes sind Klassen, die normale Klassen um
+// zusätzliche Funktionalität erweitern.
+// Mit Case-Klassen bekommt man ein paar
+// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.
+// ein companion object mit den entsprechenden Methoden,
+// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch
+// Getter für unsere Attribute (das Angeben von val entfällt dadurch)
class Person(val name: String)
class Hund(val sorte: String, val farbe: String, val halter: Person)
-// Es genügt das Schlüsselwort case vor die Klasse zu schreiben.
+// Es genügt, das Schlüsselwort case vor die Klasse zu schreiben:
case class Person(name: String)
case class Hund(sorte: String, farbe: String, halter: Person)
-// Für neue Instanzen brauch man kein "new"
+// Für neue Instanzen braucht man kein "new":
val dackel = Hund("dackel", "grau", Person("peter"))
val dogge = Hund("dogge", "grau", Person("peter"))
-
-// getter
+
+// getter
dackel.halter // => Person = Person(peter)
-
-// equals
+
+// equals
dogge == dackel // => false
-
-// copy
-// otherGeorge == Person("george", "9876")
+
+// copy
+// otherGeorge == Person("george", "9876")
val otherGeorge = george.copy(phoneNumber = "9876")
// Traits
-// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp
-// und Methodensignaturen. Scala erlaubt allerdings das teilweise
-// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.
-// Traits können von anderen Traits oder Klassen erben, aber nur von
-// parameterlosen.
+// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp
+// und Methodensignaturen. Scala erlaubt allerdings das teilweise
+// Implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.
+// Traits können von anderen Traits oder Klassen erben, aber nur von
+// parameterlosen.
trait Hund {
def sorte: String
@@ -527,22 +528,23 @@ class Bernhardiner extends Hund{
def beissen = false
}
-
-scala> b
-res0: Bernhardiner = Bernhardiner@3e57cd70
-scala> b.sorte
-res1: String = Bernhardiner
-scala> b.bellen
-res2: Boolean = true
-scala> b.beissen
-res3: Boolean = false
+scala> b
+res0: Bernhardiner = Bernhardiner@3e57cd70
+scala> b.sorte
+res1: String = Bernhardiner
+scala> b.bellen
+res2: Boolean = true
+scala> b.beissen
+res3: Boolean = false
-// Traits können auch via Mixins (Schlüsselwort "with") eingebunden werden
+// Ein Trait kann auch als Mixin eingebunden werden. Die Klasse erbt vom
+// ersten Trait mit dem Schlüsselwort "extends", während weitere Traits
+// mit "with" verwendet werden können.
trait Bellen {
- def bellen: String = "Woof"
+ def bellen: String = "Wuff"
}
trait Hund {
def sorte: String
@@ -555,17 +557,17 @@ class Bernhardiner extends Hund with Bellen{
scala> val b = new Bernhardiner
b: Bernhardiner = Bernhardiner@7b69c6ba
scala> b.bellen
-res0: String = Woof
+res0: String = Wuff
/////////////////////////////////////////////////
-// 6. Pattern Matching
+// 6. Mustervergleich (Pattern Matching)
/////////////////////////////////////////////////
-// Pattern matching in Scala ist ein sehr nützliches und wesentlich
-// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala
-// benötigt ein case Statement kein "break", ein fall-through gibt es nicht.
-// Mehrere Überprüfungen können mit einem Statement gemacht werden.
-// Pattern matching wird mit dem Schlüsselwort "match" gemacht.
+// Pattern matching in Scala ist ein sehr nützliches und wesentlich
+// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala
+// benötigt ein case Statement kein "break", ein fall-through gibt es nicht.
+// Mehrere Überprüfungen können mit einem Statement gemacht werden.
+// Pattern matching wird mit dem Schlüsselwort "match" gemacht.
val x = ...
x match {
@@ -575,19 +577,19 @@ x match {
}
-// Pattern Matching kann auf beliebige Typen prüfen
+// Pattern Matching kann auf beliebige Typen prüfen
val any: Any = ...
val gleicht = any match {
case 2 | 3 | 5 => "Zahl"
- case "woof" => "String"
+ case "wuff" => "String"
case true | false => "Boolean"
case 45.35 => "Double"
case _ => "Unbekannt"
}
-// und auf Objektgleichheit
+// und auf Objektgleichheit
def matchPerson(person: Person): String = person match {
case Person("George", nummer) => "George! Die Nummer ist " + number
@@ -596,31 +598,31 @@ def matchPerson(person: Person): String = person match {
}
-// Und viele mehr...
+// Und viele mehr...
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"
}
-// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden
-// Ganze Funktionen können Patterns sein
+// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden.
+// Ganze Funktionen können Patterns sein:
val patternFunc: Person => String = {
case Person("George", number) => s"George's number: $number"
@@ -629,58 +631,58 @@ val patternFunc: Person => String = {
/////////////////////////////////////////////////
-// 37. Higher-order functions
+// 7. "Higher-order"-Funktionen
/////////////////////////////////////////////////
-Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden
-als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen
-higher-order functions
-Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für
-die meisten anderen Collection Typen, sowie andere Klassen in Scala
-Nennenswerte sind:
-"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"
+// Scala erlaubt, dass Methoden und Funktionen wiederum Funtionen und Methoden
+// als Aufrufparameter oder Rückgabewert verwenden. Diese Methoden heißen
+// higher-order functions.
+// Es gibt zahlreiche higher-order-Funtionen nicht nur für Listen, auch für
+// die meisten anderen Collection-Typen, sowie andere Klassen in Scala.
+// Nennenswerte sind:
+// "filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"
-## List
+// List
-def isGleichVier(a:Int) = a == 4
+def istGleichVier(a:Int) = a == 4
val list = List(1, 2, 3, 4)
val resultExists4 = list.exists(isEqualToFour)
-## map
-// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt
-// eine neue Liste
-
-// Funktion erwartet ein Int und returned ein Int
+// map
+// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt
+// eine neue Liste
-val add10: Int => Int = _ + 10
+// Funktion erwartet einen Int und gibt einen Int zurück:
+val add10: Int => Int = _ + 10
-// add10 wird auf jedes Element angewendet
+
+// add10 wird auf jedes Element angewendet:
List(1, 2, 3) map add10 // => List(11, 12, 13)
-// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden
+// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden:
List(1, 2, 3) map (x => x + 10)
-// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion
-// verwendet. Er wird an die Variable gebunden.
+// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion
+// verwendet. Er wird an die Variable gebunden:
List(1, 2, 3) map (_ + 10)
-// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,
-// kann sogar der Unterstrich weggelassen werden.
+// Wenn der anonyme Block und die Funktion beide EIN Argument erwarten,
+// kann sogar der Unterstrich weggelassen werden.
List("Dom", "Bob", "Natalia") foreach println
// filter
-// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet
-// alle Elemente die auf das Prädikat passen
+// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet
+// alle Elemente, die auf das Prädikat passen:
List(1, 2, 3) filter (_ > 2) // => List(3)
case class Person(name: String, age: Int)
@@ -691,19 +693,19 @@ List(
// reduce
-// reduce nimmt zwei Elemente und kombiniert sie zu einem Element,
-// und zwar solange bis nur noch ein Element da ist.
+// reduce nimmt zwei Elemente und kombiniert sie zu einem Element,
+// und zwar so lange, bis nur noch ein Element da ist.
// foreach
-// foreach gibt es für einige Collections
+// foreach gibt es für einige Collections
val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
aListOfNumbers foreach (x => println(x))
aListOfNumbers foreach println
// For comprehensions
-// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.
-// Dies ist keine for-Schleife.
+// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.
+// Dies ist keine for-Schleife.
for { n <- s } yield sq(n)
val nSquared2 = for { n <- s } yield sq(n)
@@ -715,108 +717,108 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
// 8. Implicits
/////////////////////////////////////////////////
-// **ACHTUNG:**
+// **ACHTUNG:**
// Implicits sind ein sehr mächtiges Sprachfeature von Scala.
-// Es sehr einfach
-// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am
-// besten erst dann benutzen, wenn man versteht wie sie funktionieren.
-// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle
-// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles
-// machen kann.
-// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.
+// Es sehr einfach,
+// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am
+// besten erst dann benutzen, wenn sie verstehen, wie sie funktionieren.
+// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle
+// vorkommen und man auch mit einer Bibliothek, die Implicits benutzt, sonst
+// nichts sinnvolles machen kann.
+// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.
-// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte
-// zu "implicit Methods" werden.
+// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte
+// zu "implicit Methods" werden.
implicit val myImplicitInt = 100
implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte)
-// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion
+// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion
myImplicitInt + 2 // => 102
myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
-// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein
-// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von
-// implicit Funktionsparametern
-
-// Diese Funktion hat zwei Parameter: einen normalen und einen implicit
+// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein
+// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von
+// implicit Funktionsparametern
+
+// 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
-// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet
+sendGreetings("John")(1000) // => "Hallo John, 1000 Segenswünsche für Sie und Ihre Angehörigen!"
-sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!"
+// Wird der implicit-Parameter jedoch weggelassen, wird ein anderer
+// implicit-Wert vom gleichen Typ genommen. Der Compiler sucht im
+// lexikalischen Scope und im companion object nach einem implicit-Wert,
+// der vom Typ passt, oder nach einer implicit-Methode, mit der er in den
+// geforderten Typ konvertieren kann.
-// Wird der implicit Parameter jedoch weggelassen, wird ein anderer
-// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im
-// lexikalischen Scope und im companion object nach einem implicit Wert,
-// der vom Typ passt, oder nach einer implicit Methode mit der er in den
-// geforderten Typ konvertieren kann.
-
-// Hier also: "myImplicitInt", da ein Int gesucht wird
+// 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"
-// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und
-// dann wird die Methode aufgerufen
+// bzw. "myImplicitFunction"
+// Der String wird erst mit Hilfe der Funktion in Hund konvertiert,
+// dann wird die Methode aufgerufen:
"Retriever".sorte // => "Golden Retriever"
/////////////////////////////////////////////////
-// 19. Misc
+// 9. Sonstiges
/////////////////////////////////////////////////
// Importe
import scala.collection.immutable.List
-// Importiere alle Unterpackages
+// Importiere alle Unterpackages
import scala.collection.immutable._
-// Importiere verschiedene Klassen mit einem Statement
+// Importiere verschiedene Klassen mit einem Statement
import scala.collection.immutable.{List, Map}
-// Einen Import kann man mit '=>' umbenennen
+// Einen Import kann man mit '=>' umbenennen
import scala.collection.immutable.{List => ImmutableList}
-// Importiere alle Klasses, mit Ausnahem von....
-// Hier ohne: Map and Set:
+// Importiere alle Klasses, mit Ausnahem von....
+// Hier ohne: Map and Set:
import scala.collection.immutable.{Map => _, Set => _, _}
-// Main
+// Main
object Application {
def main(args: Array[String]): Unit = {
- // Sachen kommen hierhin
+ // Zeugs hier rein.
}
}
// I/O
-// Eine Datei Zeile für Zeile lesen
+// Eine Datei Zeile für Zeile lesen
import scala.io.Source
for(line <- Source.fromFile("myfile.txt").getLines())
println(line)
-// Eine Datei schreiben
+// Eine Datei schreiben
val writer = new PrintWriter("myfile.txt")
writer.write("Schreibe Zeile" + util.Properties.lineSeparator)
@@ -825,13 +827,13 @@ writer.close()
```
-## Weiterführende Hinweise
+## Weiterführende Hinweise
-// DE
+### DE
* [Scala Tutorial](https://scalatutorial.wordpress.com)
* [Scala Tutorial](http://scalatutorial.de)
-// EN
+### EN
* [Scala for the impatient](http://horstmann.com/scala/)
* [Twitter Scala school](http://twitter.github.io/scala_school/)
* [The scala documentation](http://docs.scala-lang.org/)
diff --git a/de-de/shutit-de.html.markdown b/de-de/shutit-de.html.markdown
new file mode 100644
index 00000000..f66ed906
--- /dev/null
+++ b/de-de/shutit-de.html.markdown
@@ -0,0 +1,330 @@
+---
+category: tool
+filename: learnshutit.html
+tool: ShutIt
+contributors:
+ - ["Ian Miell", "http://ian.meirionconsulting.tk"]
+translators:
+ - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+## ShutIt
+
+ShuIt ist eine Shellautomationsframework, welches für eine einfache
+Handhabung entwickelt wurde.
+
+Er ist ein Wrapper, der auf einem Python expect Klon (pexpect) basiert.
+
+Es ist damit ein 'expect ohne Schmerzen'.
+
+Es ist verfügbar als pip install.
+
+## Hello World
+
+Starten wir mit dem einfachsten Beispiel. Erstelle eine Datei names example.py
+
+```python
+
+import shutit
+session = shutit.create_session('bash')
+session.send('echo Hello World', echo=True)
+```
+
+Führe es hiermit aus:
+
+```bash
+python example.py
+```
+
+gibt aus:
+
+```bash
+$ python example.py
+echo "Hello World"
+echo "Hello World"
+Hello World
+Ians-MacBook-Air.local:ORIGIN_ENV:RhuebR2T#
+```
+
+Das erste Argument zu 'send' ist der Befehl, den du ausführen möchtest.
+Das 'echo' Argument gibt die Terminalinteraktion aus. ShuIt ist standardmäßig leise.
+
+'Send' kümmert sich um die nervige Arbeiten mit den Prompts und macht
+alles was du von 'expect' erwarten würdest.
+
+
+## Logge dich auf einen Server ein
+
+Sagen wir du möchtest dich auf einen Server einloggen und einen Befehl ausführen.
+Ändere dafür example.py folgendermaßen:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.login('ssh you@example.com', user='du', password='meinpassword')
+session.send('hostname', echo=True)
+session.logout()
+```
+
+Dies erlaubt dir dich auf deinen Server einzuloggen
+(ersetze die Details mit deinen Eigenen) und das Programm gibt dir deinen Hostnamen aus.
+
+```
+$ python example.py
+hostname
+hostname
+example.com
+example.com:cgoIsdVv:heDa77HB#
+```
+
+
+Es ist klar das das nicht sicher ist. Stattdessen kann man Folgendes machen:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+password = session.get_input('', ispass=True)
+session.login('ssh you@example.com', user='du', password=password)
+session.send('hostname', echo=True)
+session.logout()
+```
+
+Dies zwingt dich dein Passwort einzugeben:
+
+```
+$ python example.py
+Input Secret:
+hostname
+hostname
+example.com
+example.com:cgoIsdVv:heDa77HB#
+```
+
+
+Die 'login' Methode übernimmt wieder das veränderte Prompt für den Login.
+Du übergibst ShutIt den User und das Passwort, falls es benötigt wird,
+mit den du dich einloggen möchtest. ShutIt übernimmt den Rest.
+
+'logout' behandelt das Ende von 'login' und übernimmt alle Veränderungen des
+Prompts für dich.
+
+## Einloggen auf mehrere Server
+
+Sagen wir, dass du eine Serverfarm mit zwei Servern hast und du dich in
+beide Server einloggen möchtest. Dafür musst du nur zwei Session und
+Logins erstellen und kannst dann Befehle schicken:
+
+```python
+import shutit
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session1.get_input('Password für server1', ispass=True)
+password2 = session2.get_input('Password für server2', ispass=True)
+session1.login('ssh you@one.example.com', user='du', password=password1)
+session2.login('ssh you@two.example.com', user='du', password=password2)
+session1.send('hostname', echo=True)
+session2.send('hostname', echo=True)
+session1.logout()
+session2.logout()
+```
+
+Gibt aus:
+
+```bash
+$ python example.py
+Password for server1
+Input Secret:
+
+Password for server2
+Input Secret:
+hostname
+hostname
+one.example.com
+one.example.com:Fnh2pyFj:qkrsmUNs# hostname
+hostname
+two.example.com
+two.example.com:Gl2lldEo:D3FavQjA#
+```
+
+## Beispiel: Überwachen mehrerer Server
+
+Wir können das obige Programm in ein einfaches Überwachungstool bringen indem
+wir Logik hinzufügen um die Ausgabe von einem Befehl zu betrachten.
+
+```python
+import shutit
+capacity_command="""df / | awk '{print $5}' | tail -1 | sed s/[^0-9]//"""
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session.get_input('Passwort für Server1', ispass=True)
+password2 = session.get_input('Passwort für Server2', ispass=True)
+session1.login('ssh you@one.example.com', user='du', password=password1)
+session2.login('ssh you@two.example.com', user='du', password=password2)
+capacity = session1.send_and_get_output(capacity_command)
+if int(capacity) < 10:
+ print(kein Platz mehr auf Server1!')
+capacity = session2.send_and_get_output(capacity_command)
+if int(capacity) < 10:
+ print(kein Platz mehr auf Server2!')
+session1.logout()
+session2.logout()
+```
+
+Hier kannst du die 'send\_and\_get\_output' Methode verwenden um die Ausgabe von dem
+Kapazitätsbefehl (df) zu erhalten.
+
+Es gibt elegantere Wege als oben (z.B. kannst du ein Dictionary verwenden um über
+die Server zu iterieren), aber es hängt and dir wie clever das Python sein muss.
+
+
+## kompliziertere IO - Expecting
+
+Sagen wir du hast eine Interaktion mit einer interaktiven Kommandozeilenprogramm,
+die du automatisieren möchtest. Hier werden wir Telnet als triviales Beispiel verwenden:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.send('telnet', expect='elnet>', echo=True)
+session.send('open google.com 80', expect='scape character', echo=True)
+session.send('GET /', echo=True, check_exit=False)
+session.logout()
+```
+
+Beachte das 'expect' Argument. Du brauchst nur ein Subset von Telnets
+Eingabeaufforderung um es abzugleichen und fortzufahren.
+
+Beachte auch das neue Argument 'check\_exit'. Wir werden nachher nochmal
+darauf zurückkommen. Die Ausgabe von oben ist:
+
+```bash
+$ python example.py
+telnet
+telnet> open google.com 80
+Trying 216.58.214.14...
+Connected to google.com.
+Escape character is '^]'.
+GET /
+HTTP/1.0 302 Found
+Cache-Control: private
+Content-Type: text/html; charset=UTF-8
+Referrer-Policy: no-referrer
+Location: http://www.google.co.uk/?gfe_rd=cr&ei=huczWcj3GfTW8gfq0paQDA
+Content-Length: 261
+Date: Sun, 04 Jun 2017 10:57:10 GMT
+
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+<TITLE>302 Moved</TITLE></HEAD><BODY>
+<H1>302 Moved</H1>
+The document has moved
+<A HREF="http://www.google.co.uk/?gfe_rd=cr&amp;ei=huczWcj3GfTW8gfq0paQDA">
+here
+</A>.
+</BODY></HTML>
+Connection closed by foreign host.
+```
+
+Nun zurück zu 'check\_exit=False'. Da das Telnet Programm einen Fehler mit
+Fehlercode (1) zurückgibt und wir nicht möchten das das Skript fehlschlägt
+kannst du 'check\_exit=False' setzen und damit ShuIt wissen lassen, dass
+der Ausgabecode dich nicht interessiert.
+
+Wenn du das Argument nicht mitgegeben hättest, dann hätte dir ShutIt
+ein interaktives Terminal zurückgegeben, falls es ein Terminal zum
+kommunizieren gibt. Dies nennt sich ein 'Pause point'.
+
+
+## Pause Points
+
+Du kannst jederzeit 'pause point' auslösen, wenn du Folgendes in deinem Skript aufrufst:
+
+```python
+[...]
+session.pause_point('Das ist ein pause point')
+[...]
+```
+
+Danach kannst du das Skript fortführen, wenn du CTRL und ']' zur selben Zeit drückst.
+Dies ist gut für Debugging: Füge ein Pause Point hinzu und schaue dich um.
+Danach kannst du das Programm weiter ausführen. Probiere folgendes aus:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.pause_point('Schaue dich um!')
+session.send('echo "Hat dir der Pause point gefallen?"', echo=True)
+```
+
+Dies würde folgendes ausgeben:
+
+```bash
+$ python example.py
+Schaue dich um!
+
+Ians-Air.home:ORIGIN_ENV:I00LA1Mq# bash
+imiell@Ians-Air:/space/git/shutit ⑂ master + 
+CTRL-] caught, continuing with run...
+2017-06-05 15:12:33,577 INFO: Sending: exit
+2017-06-05 15:12:33,633 INFO: Output (squashed): exitexitIans-Air.home:ORIGIN_ENV:I00LA1Mq# [...]
+echo "Hat dir der Pause point gefallen?"
+echo "Hat dir der Pause point gefallen?"
+Hat dir der Pause point gefallen?
+Ians-Air.home:ORIGIN_ENV:I00LA1Mq#
+```
+
+
+## noch kompliziertere IO - Hintergrund
+
+Kehren wir zu unseren Beispiel mit dem Überwachen von mehreren Servern zurück.
+Stellen wir uns vor, dass wir eine langlaufende Aufgabe auf jedem Server durchführen möchten.
+Standardmäßig arbeitet ShutIt seriell, was sehr lange dauern würde.
+Wir können jedoch die Aufgaben im Hintergrund laufen lassen um sie zu beschleunigen.
+
+Hier ist ein Beispiel, welches du ausprobieren kannst.
+Es verwendet den trivialen Befehl: 'sleep'.
+
+
+```python
+import shutit
+import time
+long_command="""sleep 60"""
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session1.get_input('Password for server1', ispass=True)
+password2 = session2.get_input('Password for server2', ispass=True)
+session1.login('ssh you@one.example.com', user='du', password=password1)
+session2.login('ssh you@two.example.com', user='du', password=password2)
+start = time.time()
+session1.send(long_command, background=True)
+session2.send(long_command, background=True)
+print('Es hat: ' + str(time.time() - start) + ' Sekunden zum Starten gebraucht')
+session1.wait()
+session2.wait()
+print('Es hat:' + str(time.time() - start) + ' Sekunden zum Vollenden gebraucht')
+```
+
+Mein Computer meint, dass er 0.5 Sekunden gebraucht hat um die Befehle zu starten
+und dann nur etwas über eine Minute gebraucht um sie zu beenden
+(mit Verwendung der 'wait' Methode).
+
+
+Das alles ist trivial, aber stelle dir vor das du hunderte an Servern so managen
+kannst und man kann nun das Potential sehen, die in ein paar Zeilen Code und ein Python
+import liegen können.
+
+
+## Lerne mehr
+
+Es gibt noch viel mehr, was mit ShutIt erreicht werden kann.
+
+Um mehr zu erfahren, siehe:
+
+[ShutIt](https://ianmiell.github.io/shutit/)
+[GitHub](https://github.com/ianmiell/shutit/blob/master/README.md)
+
+Es handelt sich um ein breiteres Automatiesierungsframework, und das oben
+genannte ist der sogennante 'standalone Modus'.
+
+Feedback, feature requests, 'Wie mache ich es' sind herzlich willkommen! Erreiche mit unter
+[@ianmiell](https://twitter.com/ianmiell)
diff --git a/de-de/swift-de.html.markdown b/de-de/swift-de.html.markdown
index b58a72d3..08f72a35 100644
--- a/de-de/swift-de.html.markdown
+++ b/de-de/swift-de.html.markdown
@@ -440,13 +440,13 @@ if let circle = myEmptyCircle {
// Wie Klassen auch können sie Methoden haben
enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
@@ -455,35 +455,35 @@ enum Suit {
// Enum-Werte können vereinfacht geschrieben werden, es muss nicht der Enum-Typ
// genannt werden, wenn die Variable explizit deklariert wurde
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
// Nicht-Integer-Enums brauchen direkt zugewiesene "Rohwerte"
enum BookName: String {
- case John = "John"
- case Luke = "Luke"
+ case john = "John"
+ case luke = "Luke"
}
-print("Name: \(BookName.John.rawValue)")
+print("Name: \(BookName.john.rawValue)")
// Enum mit assoziierten Werten
enum Furniture {
// mit Int assoziiert
- case Desk(height: Int)
+ case desk(height: Int)
// mit String und Int assoziiert
- case Chair(String, Int)
-
+ case chair(String, Int)
+
func description() -> String {
switch self {
- case .Desk(let height):
+ case .desk(let height):
return "Desk with \(height) cm"
- case .Chair(let brand, let height):
+ case .chair(let brand, let height):
return "Chair of \(brand) with \(height) cm"
}
}
}
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
print(desk.description()) // "Desk with 80 cm"
-var chair = Furniture.Chair("Foo", 40)
+var chair = Furniture.chair("Foo", 40)
print(chair.description()) // "Chair of Foo with 40 cm"