summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
authorElena Bolshakova <lena-san@yandex-team.ru>2015-06-10 11:34:14 +0300
committerElena Bolshakova <lena-san@yandex-team.ru>2015-06-10 11:34:14 +0300
commit193f66553fc114e83e7c4cfb4607e4a1b57c4f09 (patch)
tree30988e25d31ed6dff83cf409ad093c3c7ec9322c /de-de
parent676568cca8731d0dbb2d2bdeff08cc092d283177 (diff)
parent5086480a04d27cff2380f04609210082000538d4 (diff)
Merge branch 'master' of https://github.com/adambard/learnxinyminutes-docs
Diffstat (limited to 'de-de')
-rw-r--r--de-de/bash-de.html.markdown2
-rw-r--r--de-de/go-de.html.markdown62
-rw-r--r--de-de/python-de.html.markdown4
-rw-r--r--de-de/yaml-de.html.markdown138
4 files changed, 172 insertions, 34 deletions
diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index ad782e06..fb9cd9d4 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -17,7 +17,7 @@ Beinahe alle der folgenden Beispiele können als Teile eines Shell-Skripts oder
```bash
#!/bin/bash
-# Die erste Zeile des Scripts nennt sich Shebang in gibt dem System an, wie
+# Die erste Zeile des Scripts nennt sich Shebang, dies gibt dem System an,
# wie das Script ausgeführt werden soll: http://de.wikipedia.org/wiki/Shebang
# Du hast es bestimmt schon mitgekriegt, Kommentare fangen mit # an. Das Shebang ist auch ein Kommentar
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index ca27fdc7..83d59c8b 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -5,34 +5,34 @@ contributors:
- ["Joseph Adams", "https://github.com/jcla1"]
lang: de-de
---
-Go wurde entwickelt um probleme zu lösen. Sie ist zwar nicht der neuste Trend in
-der Informatik, aber sie ist eine der neusten und schnellsten Wege um Aufgabe in
+Go wurde entwickelt, um Probleme zu lösen. Sie ist zwar nicht der neueste Trend in
+der Informatik, aber sie ist einer der neuesten und schnellsten Wege, um Aufgabe in
der realen Welt zu lösen.
-Sie hat vertraute Elemente von imperativen Sprachen mit statisher Typisierung
+Sie hat vertraute Elemente von imperativen Sprachen mit statischer Typisierung
und kann schnell kompiliert und ausgeführt werden. Verbunden mit leicht zu
verstehenden Parallelitäts-Konstrukten, um die heute üblichen mehrkern
Prozessoren optimal nutzen zu können, eignet sich Go äußerst gut für große
Programmierprojekte.
-Außerdem beinhaltet Go eine gut ausgestattete standard bibliothek und hat eine
-aktive community.
+Außerdem beinhaltet Go eine gut ausgestattete Standardbibliothek und hat eine
+aktive Community.
```go
// Einzeiliger Kommentar
/* Mehr-
zeiliger Kommentar */
-// Eine jede Quelldatei beginnt mit einer Packet-Klausel.
-// "main" ist ein besonderer Packetname, da er ein ausführbares Programm
+// Eine jede Quelldatei beginnt mit einer Paket-Klausel.
+// "main" ist ein besonderer Pkaetname, da er ein ausführbares Programm
// einleitet, im Gegensatz zu jedem anderen Namen, der eine Bibliothek
// deklariert.
package main
-// Ein "import" wird verwendet um Packte zu deklarieren, die in dieser
+// Ein "import" wird verwendet, um Pakete zu deklarieren, die in dieser
// Quelldatei Anwendung finden.
import (
- "fmt" // Ein Packet in der Go standard Bibliothek
+ "fmt" // Ein Paket in der Go Standardbibliothek
"net/http" // Ja, ein Webserver.
"strconv" // Zeichenkettenmanipulation
)
@@ -42,10 +42,10 @@ import (
// Programms. Vergessen Sie nicht die geschweiften Klammern!
func main() {
// Println gibt eine Zeile zu stdout aus.
- // Der Prefix "fmt" bestimmt das Packet aus welchem die Funktion stammt.
+ // Der Prefix "fmt" bestimmt das Paket aus welchem die Funktion stammt.
fmt.Println("Hello world!")
- // Aufruf einer weiteren Funktion definiert innerhalb dieses Packets.
+ // Aufruf einer weiteren Funktion definiert innerhalb dieses Pakets.
beyondHello()
}
@@ -54,7 +54,7 @@ func main() {
func beyondHello() {
var x int // Deklaration einer Variable, muss vor Gebrauch geschehen.
x = 3 // Zuweisung eines Werts.
- // Kurze Deklaration: Benutzen Sie ":=" um die Typisierung automatisch zu
+ // Kurze Deklaration: Benutzen Sie ":=", um die Typisierung automatisch zu
// folgern, die Variable zu deklarieren und ihr einen Wert zu zuweisen.
y := 4
@@ -70,7 +70,7 @@ func learnMultiple(x, y int) (sum, prod int) {
return x + y, x * y // Wiedergabe zweier Werte
}
-// Überblick ueber einige eingebaute Typen und Literale.
+// Überblick über einige eingebaute Typen und Literale.
func learnTypes() {
// Kurze Deklarationen sind die Norm.
s := "Lernen Sie Go!" // Zeichenketten-Typ
@@ -111,7 +111,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
m["eins"] = 1
// Ungebrauchte Variablen sind Fehler in Go
- // Der Unterstrich wird verwendet um einen Wert zu verwerfen.
+ // Der Unterstrich wird verwendet, um einen Wert zu verwerfen.
_, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
// Die Ausgabe zählt natürlich auch als Gebrauch
fmt.Println(s, c, a4, s3, d2, m)
@@ -142,7 +142,7 @@ func learnFlowControl() {
if true {
fmt.Println("hab's dir ja gesagt!")
}
- // Die Formattierung ist durch den Befehl "go fmt" standardisiert
+ // Die Formatierung ist durch den Befehl "go fmt" standardisiert
if false {
// nicht hier
} else {
@@ -170,7 +170,7 @@ func learnFlowControl() {
continue // wird nie ausgeführt
}
- // Wie bei for, bedeutet := in einer Bedingten Anweisung zunächst die
+ // Wie bei for, bedeutet := in einer bedingten Anweisung zunächst die
// Zuweisung und erst dann die Überprüfung der Bedingung.
if y := expensiveComputation(); y > x {
x = y
@@ -217,8 +217,8 @@ func learnInterfaces() {
// Aufruf der String Methode von i, gleiche Ausgabe wie zuvor.
fmt.Println(i.String())
- // Funktionen des fmt-Packets rufen die String() Methode auf um eine
- // druckbare variante des Empfängers zu erhalten.
+ // Funktionen des fmt-Pakets rufen die String() Methode auf um eine
+ // druckbare Variante des Empfängers zu erhalten.
fmt.Println(p) // gleiche Ausgabe wie zuvor
fmt.Println(i) // und wieder die gleiche Ausgabe wie zuvor
@@ -244,18 +244,18 @@ func learnErrorHandling() {
learnConcurrency()
}
-// c ist ein Kannal, ein sicheres Kommunikationsmedium.
+// c ist ein Kanal, ein sicheres Kommunikationsmedium.
func inc(i int, c chan int) {
- c <- i + 1 // <- ist der "send" Operator, wenn ein Kannal auf der Linken ist
+ c <- i + 1 // <- ist der "send" Operator, wenn ein Kanal auf der Linken ist
}
// Wir verwenden "inc" um Zahlen parallel zu erhöhen.
func learnConcurrency() {
// Die selbe "make"-Funktion wie vorhin. Sie initialisiert Speicher für
- // maps, slices und Kannäle.
+ // maps, slices und Kanäle.
c := make(chan int)
// Starte drei parallele "Goroutines". Die Zahlen werden parallel (concurrently)
- // erhöht. Alle drei senden ihr Ergebnis in den gleichen Kannal.
+ // erhöht. Alle drei senden ihr Ergebnis in den gleichen Kanal.
go inc(0, c) // "go" ist das Statement zum Start einer neuen Goroutine
go inc(10, c)
go inc(-805, c)
@@ -269,16 +269,16 @@ func learnConcurrency() {
// Start einer neuen Goroutine, nur um einen Wert zu senden
go func() { c <- 84 }()
- go func() { cs <- "wortreich" }() // schon wider, diesmal für
+ go func() { cs <- "wortreich" }() // schon wieder, diesmal für
// "select" hat eine Syntax wie ein switch Statement, aber jeder Fall ist
- // eine Kannaloperation. Es wählt eine Fall zufällig aus allen die
- // kommunikationsbereit sind aus.
+ // eine Kanaloperation. Es wählt einen Fall zufällig aus allen, die
+ // kommunikationsbereit sind, aus.
select {
case i := <-c: // der empfangene Wert kann einer Variable zugewiesen werden
fmt.Printf("es ist ein: %T", i)
case <-cs: // oder der Wert kann verworfen werden
fmt.Println("es ist eine Zeichenkette!")
- case <-cc: // leerer Kannal, nicht bereit für den Empfang
+ case <-cc: // leerer Kanal, nicht bereit für den Empfang
fmt.Println("wird nicht passieren.")
}
// Hier wird eine der beiden Goroutines fertig sein, die andere nicht.
@@ -287,16 +287,16 @@ func learnConcurrency() {
learnWebProgramming() // Go kann es und Sie hoffentlich auch bald.
}
-// Eine einzige Funktion aus dem http-Packet kann einen Webserver starten.
+// Eine einzige Funktion aus dem http-Paket kann einen Webserver starten.
func learnWebProgramming() {
- // Der erste Parameter von "ListenAndServe" ist eine TCP Addresse an die
+ // Der erste Parameter von "ListenAndServe" ist eine TCP Addresse, an die
// sich angeschlossen werden soll.
// Der zweite Parameter ist ein Interface, speziell: ein http.Handler
err := http.ListenAndServe(":8080", pair{})
fmt.Println(err) // Fehler sollte man nicht ignorieren!
}
-// Wir lassen "pair" das http.Handler Interface erfüllen indem wir seine einzige
+// Wir lassen "pair" das http.Handler Interface erfüllen, indem wir seine einzige
// Methode implementieren: ServeHTTP
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Senden von Daten mit einer Methode des http.ResponseWriter
@@ -313,6 +313,6 @@ Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
kurz und auch gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/).
Gut documentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
-verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktions-
-Namen in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
+verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
+in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown
index 5ddb6f4b..ae29d6f9 100644
--- a/de-de/python-de.html.markdown
+++ b/de-de/python-de.html.markdown
@@ -149,7 +149,7 @@ li[0] #=> 1
# Das letzte Element ansehen
li[-1] #=> 3
-# Bei Zugriffen außerhal der Liste kommt es jedoch zu einem IndexError
+# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError
li[4] # Raises an IndexError
# Wir können uns Ranges mit Slice-Syntax ansehen
@@ -188,7 +188,7 @@ tup[:2] #=> (1, 2)
# Wir können Tupel (oder Listen) in Variablen entpacken
a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3
-# Tuple werden standardmäßig erstellt, wenn wir uns die Klammern sparen
+# 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
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
new file mode 100644
index 00000000..88318014
--- /dev/null
+++ b/de-de/yaml-de.html.markdown
@@ -0,0 +1,138 @@
+---
+language: yaml
+filename: learnyaml.yaml
+contributors:
+ - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+ - ["Ruben M.", https://github.com/switchhax]
+---
+
+YAML ist eine Sprache zur Datenserialisierung, die sofort von Menschenhand geschrieben und gelesen werden kann.
+
+YAML ist eine Erweiterung von JSON, mit der Erweiterung von syntaktisch wichtigen Zeilenumbrüche und Einrückung sowie in Python. Anders als in Python erlaubt YAML keine Tabulator-Zeichen.
+
+```yaml
+# Kommentare in YAML schauen so aus.
+
+#################
+# SKALARE TYPEN #
+#################
+
+# Unser Kernobjekt (für das ganze Dokument) wird das Assoziative Datenfeld (Map) sein,
+# welches equivalent zu einem Hash oder einem Objekt einer anderen Sprache ist.
+Schlüssel: Wert
+nochn_Schlüssel: Hier kommt noch ein Wert hin.
+eine_Zahl: 100
+wissenschaftliche_Notation: 1e+12
+boolean: true
+null_Wert: null
+Schlüssel mit Leerzeichen: value
+# Strings müssen nicht immer mit Anführungszeichen umgeben sein, können aber:
+jedoch: "Ein String in Anführungzeichen"
+"Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schluessel haben willst."
+
+# Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text)
+# oder ein 'folded block' (> gefolgt vom text).
+literal_block: |
+ Dieser ganze Block an Text ist der Wert vom Schlüssel literal_block,
+ mit Erhaltung der Zeilenumbrüche.
+
+ Das Literal fährt solange fort bis dieses unverbeult ist und die vorherschende Einrückung wird
+ gekürzt.
+
+ Zeilen, die weiter eingerückt sind, behalten den Rest ihrer Einrückung -
+ diese Zeilen sind mit 4 Leerzeichen eingerückt.
+folded_style: >
+ Dieser ganze Block an Text ist der Wert vom Schlüssel folded_style, aber diesmal
+ werden alle Zeilenumbrüche durch ein Leerzeichen ersetzt.
+
+ Freie Zeilen, wie obendrüber, werden in einen Zeilenumbruch verwandelt.
+
+ Weiter eingerückte Zeilen behalten ihre Zeilenumbrüche -
+ diese Textpassage wird auf zwei Zeilen sichtbar sein.
+
+####################
+# COLLECTION TYPEN #
+####################
+
+# Verschachtelung wird duch Einrückung erzielt.
+eine_verschachtelte_map:
+ schlüssel: wert
+ nochn_Schlüssel: Noch ein Wert.
+ noch_eine_verschachtelte_map:
+ hallo: hallo
+
+# Schlüssel müssen nicht immer String sein.
+0.25: ein Float-Wert als Schluessel
+
+# Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels
+? |
+ Dies ist ein Schlüssel,
+ der mehrzeilig ist.
+: und dies ist sein Wert
+
+# YAML erlaubt auch Collections als Schlüssel, doch viele Programmiersprachen
+# werden sich beklagen.
+
+# Folgen (equivalent zu Listen oder Arrays) schauen so aus:
+eine_Folge:
+ - Artikel 1
+ - Artikel 2
+ - 0.5 # Folgen können verschiedene Typen enthalten.
+ - Artikel 4
+ - schlüssel: wert
+ nochn_schlüssel: nochn_wert
+ -
+ - Dies ist eine Folge
+ - innerhalb einer Folge
+
+# Weil YAML eine Erweiterung von JSON ist, können JSON-ähnliche Maps und Folgen
+# geschrieben werden:
+json_map: {"schlüssel": "wert"}
+json_seq: [3, 2, 1, "Start"]
+
+############################
+# EXTRA YAML EIGENSCHAFTEN #
+############################
+
+# YAML stellt zusätzlich Verankerung zu Verfügung, welche es einfach machen
+# Inhalte im Dokument zu vervielfältigen. Beide Schlüssel werden den selben Wert haben.
+verankerter_inhalt: &anker_name Dieser String wird als Wert beider Schlüssel erscheinen.
+anderer_anker: *anker_name
+
+# YAML hat auch Tags, mit denen man explizit Typangaben angibt.
+explicit_string: !!str 0.5
+# Manche Parser implementieren sprachspezifische Tags wie dieser hier für Pythons
+# komplexe Zahlen.
+python_komplexe_Zahlen: !!python/komplex 1+2j
+
+####################
+# EXTRA YAML TYPEN #
+####################
+
+# Strings and Zahlen sind nicht die einzigen Skalare, welche YAML versteht.
+# ISO-formatierte Datumsangaben and Zeiangaben können ebenso geparsed werden.
+DatumZeit: 2001-12-15T02:59:43.1Z
+DatumZeit_mit_Leerzeichen: 2001-12-14 21:59:43.10 -5
+Datum: 2002-12-14
+
+# Der !!binary Tag zeigt das ein String base64 verschlüsselt ist.
+# Representation des Binären Haufens
+gif_datei: !!binary |
+ R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+ OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+ +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+ AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML bietet auch Mengen (Sets), welche so ausschauen
+menge:
+ ? artikel1
+ ? artikel2
+ ? artikel3
+
+# Wie in Python sind Mengen nicht anderes als Maps nur mit null als Wert; das Beispiel oben drüber ist equivalent zu:
+menge:
+ artikel1: null
+ artikel2: null
+ artikel3: null
+```