info/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-04-03 22:12:55 +02:00
Code Issues Releases Wiki Activity

Merge pull request #964 from wincentbalin/master

Browse Source 
Spelling and grammar fixes for German translation
This commit is contained in:
Geoff Liu 2015-03-24 12:48:13 -06:00
commit 012a4a8ae5
2 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
de-de/go-de.html.markdown
View File

@ -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/).

4
de-de/python-de.html.markdown
View File

@ -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