summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
Diffstat (limited to 'de-de')
-rw-r--r--de-de/asciidoc-de.html.markdown13
-rw-r--r--de-de/brainfuck-de.html.markdown4
-rw-r--r--de-de/c++-de.html.markdown2
-rw-r--r--de-de/c-de.html.markdown2
-rw-r--r--de-de/crystal-de.html.markdown561
-rw-r--r--de-de/csharp-de.html.markdown2
-rw-r--r--de-de/elixir-de.html.markdown2
-rw-r--r--de-de/git-de.html.markdown2
-rw-r--r--de-de/go-de.html.markdown8
-rw-r--r--de-de/pug-de.html.markdown4
-rw-r--r--de-de/qt-de.html.markdown2
-rw-r--r--de-de/rust-de.html.markdown2
-rw-r--r--de-de/vim-de.html.markdown309
-rw-r--r--de-de/visualbasic-de.html.markdown290
-rw-r--r--de-de/yaml-de.html.markdown2
15 files changed, 1027 insertions, 178 deletions
diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown
index e3f64a00..d0a62c66 100644
--- a/de-de/asciidoc-de.html.markdown
+++ b/de-de/asciidoc-de.html.markdown
@@ -4,15 +4,19 @@ contributors:
- ["Ryan Mavilia", "http://unoriginality.rocks/"]
translators:
- ["Dennis Keller", "https://github.com/denniskeller"]
-filename: asciidoc-de.md
+filename: asciidoc-de.adoc
lang: de-de
---
-AsciiDoc ist eine Auszeichnungssprache ähnlich zu Markdown. Sie kann für alles verwendet werden von Büchern zu Blogs. Erfunden wurde sie 2002 von Stuart Rackham. Die Sprache ist simpel aber sie ermöglicht eine große Anzahl an Anpassungen.
+AsciiDoc ist eine Auszeichnungssprache ähnlich zu Markdown. Sie kann für alles
+verwendet werden von Büchern zu Blogs. Erfunden wurde sie 2002 von Stuart
+Rackham. Die Sprache ist simpel aber sie ermöglicht eine große Anzahl an
+Anpassungen.
Kopfzeile des Dokuments
-Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen mindestens eine Leerzeile vom Inhalt versetzt sein.
+Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen
+mindestens eine Leerzeile vom Inhalt versetzt sein.
Nur Titel
@@ -104,7 +108,8 @@ Um eine nummerierte Liste zu erstellen, verwendest du Punkte.
. item 3
```
-Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
+Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise
+Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
```
* foo 1
diff --git a/de-de/brainfuck-de.html.markdown b/de-de/brainfuck-de.html.markdown
index dd62dd67..09f01cd2 100644
--- a/de-de/brainfuck-de.html.markdown
+++ b/de-de/brainfuck-de.html.markdown
@@ -1,11 +1,11 @@
---
-language: brainfuck
+language: bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]
translators:
- ["urfuchs", "https://github.com/urfuchs"]
-filename: brainfuck-de
+filename: brainfuck-de.bf
lang: de-de
---
diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown
index 87e75ad6..cca54c30 100644
--- a/de-de/c++-de.html.markdown
+++ b/de-de/c++-de.html.markdown
@@ -1,5 +1,5 @@
---
-language: c++
+language: C++
filename: learncpp-de.cpp
contributors:
- ["Steven Basart", "http://github.com/xksteven"]
diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown
index f9090518..3a726b83 100644
--- a/de-de/c-de.html.markdown
+++ b/de-de/c-de.html.markdown
@@ -1,5 +1,5 @@
---
-language: c
+language: C
filename: learnc-de.c
contributors:
- ["caminsha", "https://github.com/caminsha"]
diff --git a/de-de/crystal-de.html.markdown b/de-de/crystal-de.html.markdown
new file mode 100644
index 00000000..535267ee
--- /dev/null
+++ b/de-de/crystal-de.html.markdown
@@ -0,0 +1,561 @@
+---
+language: crystal
+contributors:
+ - ["Vitalii Elenhaupt", "http://veelenga.com"]
+ - ["Arnaud Fernandés", "https://github.com/TechMagister/"]
+translators:
+ - ["caminsha", "https://github.com/caminsha"]
+filename: learncrystal-de.cr
+lang: de-de
+---
+
+```crystal
+
+# Das ist ein Kommentar
+
+# Alles ist ein Objekt
+nil.class # => Nil
+100.class # => Int32
+true.class # => Bool
+
+# Falschwerte sind: nil, false und Nullpointer
+!nil # => true : Bool
+!false # => true : Bool
+!0 # => false : Bool
+
+# Integer
+
+1.class # => Int32
+
+# Fünf vorzeichenbehaftete Ganzzahlen
+1_i8.class # => Int8
+1_i16.class # => Int16
+1_i32.class # => Int32
+1_i64.class # => Int64
+1_i128.class # => Int128
+
+# Fünf vorzeichenlose Ganzzahlen
+1_u8.class # => UInt8
+1_u16.class # => UInt16
+1_u32.class # => UInt32
+1_u64.class # => UInt64
+1_u128.class # => UInt128
+
+
+2147483648.class # => Int64
+9223372036854775808.class # => UInt64
+
+# Binäre Zahlen
+0b1101 # => 13 : Int32
+
+# Oktalzahlen
+0o123 # => 83 : Int32
+
+# Hexadezimalzahlen
+0xFE012D # => 16646445 : Int32
+0xfe012d # => 16646445 : Int32
+
+# Gleitkommazahlen (floats)
+
+1.0.class # => Float64
+
+# Es gibt zwei Typen von Gleitkommazahlen
+
+1.0_f32.class # => Float32
+1_f32.class # => Float32
+
+1e10.class # => Float64
+1.5e10.class # => Float64
+1.5e-7.class # => Float64
+
+
+# Chars (einzelne Zeichen)
+
+'a'.class # => Char
+
+# Oktale Schreibweise
+'\101' # => 'A' : Char
+
+# Unicode Schreibweise
+'\u0041' # => 'A' : Char
+
+# Strings (Zeichenketten)
+"s".class # => String
+
+# Strings sind unveränderlich
+s = 'hello, " # => "hello, " : String
+s.object_id # => 1234667712 : UInt64
+s += "Crystal" # => "hello, Crystal" : String
+s.object_id # => 142528472 : UInt64
+
+# Interpolation wird unterstützt
+"sum = #{1 + 2}" # => "sum = 3" : String
+
+# Mehrzeilige Strings
+" Dies ist ein
+ mehrzeiliger String."
+
+# String mit doppeltem Anführungszeichen
+%(hello "world") # => "hello \"world\""
+
+# Symbole
+# Unveränderbare, wiederverwendbare Konstanten, welche intern als Int32 Integer
+# Werte repräsentiert werden.
+# Symbole werden oft anstelle von Strings verwendet, um bestimmte Werte zu bestimmen.
+
+:symbol.class # => Symbol
+
+sentence = :question? # :"question?" : Symbol
+
+sentence = :question? # => true : Bool
+sentence = :exclamation! # => false : Bool
+sentence = "question?" # => false : Bool
+
+# Arrays
+[1, 2, 3].class # => Array(Int32)
+[1, "hello", 'x'].class # => Array(Int32 | String | Char)
+
+# Leere Arrays sollten einen Typen definieren
+[] # => Syntaxfehler: für leere Arrays,
+ # verwende `[] of ElementType`
+[] of Int32 # => [] : Array(Int32)
+Array(Int32).new # => [] : Array(Int32)
+
+# Arrays können indiziert werden
+array = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5] : Array(Int32)
+array[0] # => 1 : Int32
+array[10] # führt zu einem IndexError
+array[-6] # führt zu einem IndexError
+array[10]? # => nil : (Int32 | Nil)
+array[-6]? # => nil : (Int32 | Nil)
+
+# Starte am Ende des Arrays
+array[-1] # => 5
+
+# Mit einem Startindex und einer Länge
+array[2, 4] # => [3, 4, 5]
+
+# oder mit einem Bereich
+array[1..3] # => [2, 3, 4]
+
+# Füge etwas zu einem Array hinzu
+array << 6 # => [1, 2, 3, 4, 5, 6]
+
+# Entferne Einträge am Ende des Arrays
+array.pop # => 6
+array # => [1, 2, 3, 4, 5]
+
+# Entferne ersten Eintrag im Array
+array.shift # => 1
+array # => [2, 3, 4, 5]
+
+# Überprüfe, ob ein Element in einem Array existiert
+array.includes? 3 # => true
+
+# Spezielle Syntax für String-Arrays und Symbol-Arrays
+%w(one two three) # => ["one", "two", "three"] : Array(String)
+%i(one two three) # 0> [:one, :two, :three] : Array(Symbol)
+
+# Es gibt auch für andere Arrays eine spezielle Syntax, wenn die Methoden
+# `.new` und `#<<` definiert werden.
+set = Set{1, 2, 3} # => [1, 2, 3]
+set.class # => Set(Int32)
+
+# Das obere ist äquivalent zu:
+set = Set(typeof(1, 2, 3)).new
+set << 1
+set << 2
+set << 3
+
+# Hashes
+{1 => 2, 3 => 4}.class # => Hash(Int32, Int32)
+{1 => 2, 'a' => 3}.class # => Hash (Int32 | Char, Int32)
+
+# Leere Hashes sollten einen Typen spezifieren
+{} # Syntaxfehler
+{} of Int32 => Int32 # {}
+Hash(Int32, Int32).new # {}
+
+# Hashes können schnell mit dem Key nachgeschaut werden
+hash = {"color" => "green", "number" => 5}
+hash["color"] # => "green"
+hash["no_such_key"] # => Fehlender hash key: "no_such_key" (KeyError)
+hash["no_such_key"]? # => nil
+
+# Überprüfe die Existenz eines Hashkeys
+hash.has_key? "color" # => true
+
+# Spezielle Schreibweise für Symbol- und Stringkeys
+{key1: 'a', key2: 'b'} # {:key1 => 'a', :key2 => 'b'}
+{"key1": 'a', "key2": 'b'} # {"key1" => 'a', "key2" => 'b'}
+
+# Die spezielle Syntax für Hash-Literale gibt es auch für andere Typen, sofern
+# diese die Methoden `.new` und `#[]=` Methoden definieren.
+class MyType
+ def []=(key, value)
+ puts "do stuff"
+ end
+end
+
+MyType{"foo" => "bar"}
+
+# Das obere ist äquivalent zu:
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+# Ranges (Bereiche)
+1..10 # => Range(Int32, Int32)
+Range.new(1,10).class # => Range(Int32, Int32)
+
+# Ranges können inklusiv oder exklusiv sein.
+(3..5).to_a # => [3, 4, 5]
+(3...5).to_a # => [3, 4]
+
+# Überprüfe, ob ein Range einen Wert enthält oder nicht.
+(1..8).includes? 2 # => true
+
+# Tupel sind unveränderliche, Stack-zugewiese Folgen von Werten mit fester
+# Größe und möglicherweise unterschiedlichen Typen
+{1, "hello", 'x'}.class # => Tuple(Int32, String, Char)
+
+# Erhalte den Wert eines Tupels über den Index
+tuple = {:key1, :key2}
+tuple[1] # => :key2
+tuple[2] # syntax error: Index out of bound
+
+# Können auf mehrere Variablen erweitert werden
+a, b, c = {:a, 'b', "c"}
+a # => :a
+b # => 'b'
+c # => "c"
+
+# Procs repräsentieren ein Funktionspointer mit einem optionalen Kontext.
+# Normalerweise wird ein Proc mit einem proc-Literal erstellt.
+proc = ->(x : Int32) { x.to_s }
+proc.class # => Print(Int32, String)
+# Außerdem kann man auch mit der Methode `new` ein Proc erstellen.
+Proc(Int32, String).new { |x| x.to_s }
+
+# Rufe ein Proc auf mit der Methode `call`
+proc.call 10 # => "10"
+
+# Kontrollstatements
+
+if true
+ "if statement"
+elsif false
+ "else-f, optional"
+else
+ "else, auch optional"
+end
+
+puts "if as a suffix" if true # => if as a suffix
+
+# If als Ausdruck
+a = if 2 > 1
+ 3
+ else
+ 4
+ end
+
+a # => 3
+
+# Bedingter ternärer Ausdruck
+a = 1 > 2 ? 3 : 4 # => 4
+
+# Case-Statement
+cmd = "move"
+
+action = case cmd
+ when "create"
+ "Creating..."
+ when "copy"
+ "Copying..."
+ when "move"
+ "Moving..."
+ when "delete"
+ "Deleting..."
+end
+
+action # => "Moving..."
+
+# Schleifen
+index = 0
+while index <= 3
+ puts "Index: #{index}"
+ index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+index = 0
+until index > 3
+ puts "Index: #{index}"
+ index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Der bevorzugte Weg, ist `each` zu verwenden.
+(1..3).each do |index|
+ puts "Index: #{index}"
+end
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Der Typ der Variablen hängt vom Typen innerhalb der Kontrollanweisung ab
+if a < 3
+ a = "hello"
+else
+ a = true
+end
+typeof a # => (Bool | String)
+
+if a && b
+ # Hier wird garantiert, dass weder a noch b vom Typ Nil sind
+end
+
+if a.is_a? String
+ a.class # => String
+end
+
+# Funktionen
+def double(x)
+ x * 2
+end
+
+# Funktionen geben implizit den Wert der letzten Anweisung zurück
+# Dies ist auch bei anderen Blöcken der Fall.
+double(2) # => 4
+
+# Klammern müssen nicht gesetzt werden, wenn der Aufruf eindeutig ist
+double 3 # => 6
+double double 3 # => 12
+
+def sum(x, y)
+ x + y
+end
+
+# Funktionsargumente werden mit einem Komma separiert.
+sum 3, 4 # => 7
+
+sum sum(3, 4), 5 # => 12
+
+# yield
+# Alle Methoden haben einen impliziten, optionalen Blockparameter.
+# Dieser kann mit dem Schlüsselwort `yield` aufgerufen werden.
+
+def surround
+ puts '{'
+ yield
+ puts '}'
+end
+
+surround { puts "Hallo Welt" }
+
+# {
+# Hallo Welt
+# }
+
+# Du kannst ein Block einer Funktion übergeben.
+# "&" kennzeichnet eine Referenz zu einem übergebenen Block
+def guests(&block)
+ block.call "some_argument"
+end
+
+# Du kannst eine Liste von Argumenten mitgeben, welche zu einem Array
+# umgewandelt werden.
+# Hierfür ist der Splat-Operator ("*")
+def guests(*array)
+ array.each { |guest| puts guest }
+end
+
+# Wenn eine Methode ein Array zurückgibt, kann destrukturiende Zuordnung
+# verwendet werden.
+def foods
+ ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast # => "pancake"
+dinner # => "quesadilla"
+
+# Gemäß der Konvention enden alle Methoden, welchen einen Boolean zurückgeben
+# mit einem Fragezeichen.
+5.even? # false
+5.odd? # true
+
+# Und wenn eine Methode mit einem Ausrufezeichen endet, macht sie etwas
+# destruktives. Zum Beispiel wird der Aufrufer verändert. Einige Methoden haben
+# eine !-Version, um eine Änderung zu machen und eine Nicht-!-Version, welche
+# lediglich eine neue veränderte Version zurückgibt.
+
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald" # => "Donald Mifflin"
+company_name # => "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name # => "Donald Mifflin"
+
+# definiere eine Klasse mit dem Schlüsselwort `class`.
+class Human
+
+# eine Klassenvariable. Diese wird mit allen Instanzen dieser Klasse geteilt.
+ @@species = "H. sapiens"
+
+ # type of name is String
+ @name: String
+
+ # Grundlegender Intialisierer
+ # Weise das Argument der Instanz-Variable "name" zu
+ # Wenn kein Alter angegeben wird, wird der Default (hier 0) genommen.
+ def initialize(@name, @age = 0)
+ end
+
+ # Einfache Setter-Methode
+ def name=(name)
+ @name = name
+ end
+
+ # einfache Getter-Methode
+ def name
+ @name
+ end
+
+ # Die obere Funktionalität kann mit der property-Methode gekapselt werden:
+ property :name
+
+ # Getter/Setter-Methoden können auch individuell erstellt werden:
+ getter :name
+ setter :name
+
+ # eine Klassenmethode verwendet `self` um sich von Instanzmethoden zu
+ # unterscheiden. Diese kann lediglich von einer Klasse aufgerufen werden,
+ # nicht von einer Instanz.
+ def self.say(msg)
+ puts msg
+ end
+
+ def species
+ @@species
+ end
+end
+
+
+# Eine Klasse instanzieren
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Lass uns ein paar Methoden aufrufen
+jim.species # => "H. sapiens"
+jim.name # => "Jim Halpert"
+jim.name = "Jim Halpert II" # => "Jim Halpert II"
+jim.name # => "Jim Halpert II"
+dwight.species # => "H. sapiens"
+dwight.name # => "Dwight K. Schrute"
+
+# Rufe die Klassenmethode auf
+Human.say("Hi") # => gibt Hi aus und gibt `nil` zurück
+
+# Variablen, welche mit @ starten, sind im Scope der Instanz
+class TestClass
+ @var = "Ich bin eine Instanzvariable"
+end
+
+# Variablen, welche mit @@ starten, sind im Scope der Klasse
+class TestClass
+ @@var = "Ich bin eine Klassenvariable"
+end
+
+# Variablen, welche mit einem Großbuchstaben starten, sind Konstanten.
+Var = "Ich bin eine Konstante"
+Var = "Ich kann nicht aktualisiert werden." # Die Konstante Var wurde bereits
+ # initialisiert.
+
+# In Crystal ist Class auch ein Objekt. Dadurch können Klassen Instanzvariablen
+# haben. Klassenvariablen werden mit der Klasse und allen Subklassen geteilt.
+
+# Basisklasse
+class Human
+ @@foo = 0
+
+ def self.foo
+ @@foo
+ end
+
+ def self.foo=(value)
+ @@foo = value
+ end
+end
+
+# abgeleitete Klasse
+class Worker < Human
+end
+
+Human.foo # => 0
+Worker.foo # => 0
+
+Human.foo = 2 # => 2
+Worker.foo # => 0
+
+Worker.foo = 3 # => 3
+Human.foo # => 2
+Worker.foo # => 3
+
+module ModuleExample
+ def foo
+ "foo"
+ end
+end
+
+# Wenn ein Modul mit include eingeschlossen wird, so werden die Methoden an die
+# Instanzen gebunden.
+# Wenn eine Klasse mit einem Modul erweitert wird, so werden die Methoden an die
+# Klasse selbst gebunden.
+
+class Person
+ include ModuleExample
+end
+
+class Book
+ extend ModuleExample
+end
+
+Person.foo # => undefinierte Methode 'foo' für Person:Class
+Person.new.foo # => 'foo'
+Book.foo # => 'foo'
+Book.new.foo # => undefinierte Methode für Book
+
+# Ausnahmebehandlung
+
+# Definiere eine neue Ausnahme
+class MyException < Exception
+end
+
+# Definiere eine weitere Ausnahme
+class MyAnotherException < Exception; end
+
+ex = begin
+ raise MyException.new
+rescue ex1 : IndexError
+ "ex1"
+rescue ex2 : MyException | MyAnotherException
+ "ex2"
+rescue ex3 : Exception
+ "ex3"
+rescue ex4 # fange alle Ausnahmen ab
+ "ex4"
+end
+
+ex # => "ex2"
+```
+
+
+## Weitere Unterlagen
+
+- [offizielle Dokumentation, englisch](https://crystal-lang.org/)
diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown
index 78bb0a6b..18a23017 100644
--- a/de-de/csharp-de.html.markdown
+++ b/de-de/csharp-de.html.markdown
@@ -1,5 +1,5 @@
---
-language: c#
+language: C#
contributors:
- ["Irfan Charania", "https://github.com/irfancharania"]
- ["Max Yankov", "https://github.com/golergka"]
diff --git a/de-de/elixir-de.html.markdown b/de-de/elixir-de.html.markdown
index 254cca51..ec933696 100644
--- a/de-de/elixir-de.html.markdown
+++ b/de-de/elixir-de.html.markdown
@@ -1,5 +1,5 @@
---
-language: elixir
+language: Elixir
contributors:
- ["Joao Marques", "http://github.com/mrshankly"]
translators:
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index 0896f513..3065a033 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -385,6 +385,4 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
-* [GitGuys](http://www.gitguys.com/)
-
* [gitflow - Ein Modell um mit Branches zu arbeiten](http://nvie.com/posts/a-successful-git-branching-model/)
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 9409e181..1b09a1e1 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -82,7 +82,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
// nicht-ASCII Literal. Go Quelltext ist UTF-8 kompatibel.
g := 'Σ' // Ein Runen-Typ, alias int32, gebraucht für unicode code points.
- f := 3.14195 // float64, eine IEEE-754 64-bit Dezimalzahl
+ f := 3.14159 // float64, eine IEEE-754 64-bit Dezimalzahl
c := 3 + 4i // complex128, besteht intern aus zwei float64-er
// "var"-Syntax mit Initalwert
@@ -308,13 +308,13 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
```
## Weitere Resourcen
-Informationen zu Go findet man auf der [offiziellen Go Webseite](http://golang.org/).
+Informationen zu Go findet man auf der [offiziellen Go Webseite](https://go.dev/).
Dort gibt es unter anderem ein Tutorial und interaktive Quelltext-Beispiele, vor
allem aber Dokumentation zur Sprache und den Paketen.
Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
kurz und 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/)
+ist außerdem der Quelltext der [Go standard Bibliothek](https://go.dev/src/)
einzusehen. Dieser kann als Referenz für leicht zu verstehendes und im idiomatischen Stil
verfasstes Go dienen. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
-in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
+in der [offiziellen Dokumentation von Go](https://go.dev/pkg/).
diff --git a/de-de/pug-de.html.markdown b/de-de/pug-de.html.markdown
index c86494ce..10172d6b 100644
--- a/de-de/pug-de.html.markdown
+++ b/de-de/pug-de.html.markdown
@@ -162,13 +162,13 @@ case bestellungsStatus
//- <p class="warn">Deine Bestellung steht noch aus</p>
//- --INCLUDE--
-//- File path -> "includes/nav.png"
+//- File path -> "includes/nav.pug"
h1 Firmenname
nav
a(href="index.html") Home
a(href="about.html") Über uns
-//- Dateipfad -> "index.png"
+//- Dateipfad -> "index.pug"
html
body
include includes/nav.pug
diff --git a/de-de/qt-de.html.markdown b/de-de/qt-de.html.markdown
index 480030fe..7d287cab 100644
--- a/de-de/qt-de.html.markdown
+++ b/de-de/qt-de.html.markdown
@@ -1,7 +1,7 @@
---
category: tool
tool: Qt Framework
-language: c++
+language: C++
filename: learnqt-de.cpp
contributors:
- ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
diff --git a/de-de/rust-de.html.markdown b/de-de/rust-de.html.markdown
index 02bb460a..6208db68 100644
--- a/de-de/rust-de.html.markdown
+++ b/de-de/rust-de.html.markdown
@@ -1,5 +1,5 @@
---
-language: rust
+language: Rust
contributors:
- ["P1start", "http://p1start.github.io/"]
translators:
diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 8abf9a14..d0b4eb9d 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -3,95 +3,92 @@ category: tool
tool: vim
lang: de-de
contributors:
- - ["RadhikaG", "https://github.com/RadhikaG"]
+- ["RadhikaG", "https://github.com/RadhikaG"]
translators:
- - ["caminsha", "https://github.com/caminsha"]
+- ["caminsha", "https://github.com/caminsha"]
filename: LearnVim-de.txt
---
-
[Vim](http://www.vim.org)
(Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
-Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt
-wurde.
-Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten
-einer Datei.
+Texteditor, welcher mit Fokus auf Geschwindigkeit und Produktivität entwickelt
+wurde. Vim hat viele Keybindings für ein schnelles navigieren und schnelles
+bearbeiten einer Datei.
## Grundlagen, um in Vim zu navigieren
```
- vim <filename> # Öffne <filename> in Vim
- :help <topic> # Open up built-in help docs about <topic> if any exists
- :help <topic> # Öffne die eingebaute Hilfe zum Thema <topic>, wenn
- # es existiert
- :q # Schließe vim
- :w # Speichere diese Datei
- :wq # Speichere diese Datei und schließe vim
- ZZ # Speichere diese Datei und schließe vim
- :q! # Schließe vim ohne die Datei zu speichern
- # ! *zwingt* die Ausführung von :q,
- # daher wird die Datei nicht gespeichert.
- ZQ # Beende vim ohne die Datei zu speichern
- :x # Speichere die Datei und beende vim
- # Dies ist eine kürzere Version von :wq
-
- u # Änderung rückgängig machen
- CTRL+R # Änderung wiederherstellen
-
- h # Den Cursor um ein Zeichen nach links bewegen
- j # Den Cursor eine Zeile nach unten bewegen
- k # Den Cursor eine Zeile nach oben bewegen
- l # Den Cursor um ein Zeichen nach rechts bewegen
-
- Ctrl+B # Gehe eine Bildschirmanzeige zurück
- Ctrl+F # Gehe eine Bildschirmanzeige vorwärts
- Ctrl+D # Gehe eine halbe Bildschirmanzeige vorwärts
- Ctrl+U # Gehe eine halbe Bildschirmanzeige zurück
-
- # Navigieren innerhalb einer Zeile
-
- 0 # Navigiere zum Anfang der Zeile
- $ # Navigiere zum Ende der Zeile
- ^ # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
-
- # Im Text suchen
-
- /word # Hebt alle Ergebnisse nach dem Cursor hervor
- ?word # Hebt alle Ergebnisse vor dem Cursor hervor
- n # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
- N # Bewegt den Cursor zum vorherigen Ergebnis der Suche
-
- :%s/foo/bar/g # Ersetze "foo" durch "bar" in allen Zeilen
- :s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile
- :%s/\n/\r/g # Ersetze das newline-Zeichen bei allen Zeilen durch
- # ein carriage return
-
- # Zu einzelnen Zeichen springen
-
- f<character> # Springe vorwärts und auf dem Zeichen <character>
- t<character> # Springe vorwärts und lande vor dem Zeichen <character>
-
- # Zum Beispiel,
- f< # Springe vorwärts und lande auf <
- t< # Springe vorwärts und lande vor <
-
- # Wortweise navigieren
-
- w # Springe um ein Wort vorwärts
- b # Gehe ein Wort zurück
- e # Springe zum Ende des aktuellen Wortes
-
- # Weitere Befehle, um zu navigieren
-
- gg # Gehe an den Start der Datei
- G # Gehe an das Ende der Datei
- :NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
- H # Navigiere zum Start der aktuellen Bildschirmanzeige
- M # Navigiere in die Mitte der aktuellen Bildschirmanzeige
- L # Navigiere an das Ende der aktuellen Bildschirmanzeige
+vim <filename> # Öffne <filename> in Vim
+:help <topic> # Öffne die eingebaute Hilfe zum Thema <topic>, wenn
+ # es existiert
+:q # Schließe vim
+:w # Speichere diese Datei
+:wq # Speichere diese Datei und schließe vim
+ZZ # Speichere diese Datei und schließe vim
+:q! # Schließe vim ohne die Datei zu speichern
+ # ! *zwingt* die Ausführung von :q,
+ # daher wird die Datei nicht gespeichert.
+ZQ # Beende vim ohne die Datei zu speichern
+:x # Speichere die Datei und beende vim
+ # Dies ist eine kürzere Version von :wq
+
+u # Änderung rückgängig machen
+CTRL+R # Änderung wiederherstellen
+
+h # Den Cursor um ein Zeichen nach links bewegen
+j # Den Cursor eine Zeile nach unten bewegen
+k # Den Cursor eine Zeile nach oben bewegen
+l # Den Cursor um ein Zeichen nach rechts bewegen
+
+Ctrl+B # Gehe eine Bildschirmanzeige zurück
+Ctrl+F # Gehe eine Bildschirmanzeige vorwärts
+Ctrl+D # Gehe eine halbe Bildschirmanzeige vorwärts
+Ctrl+U # Gehe eine halbe Bildschirmanzeige zurück
+
+# Navigieren innerhalb einer Zeile
+
+0 # Navigiere zum Anfang der Zeile
+$ # Navigiere zum Ende der Zeile
+^ # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
+
+# Im Text suchen
+
+/word # Hebt alle Ergebnisse nach dem Cursor hervor
+?word # Hebt alle Ergebnisse vor dem Cursor hervor
+n # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
+N # Bewegt den Cursor zum vorherigen Ergebnis der Suche
+
+:%s/foo/bar/g # Ersetze "foo" durch "bar" in allen Zeilen
+:s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile
+:%s/\n/\r/g # Ersetze das newline-Zeichen bei allen Zeilen durch
+ # ein carriage return
+
+# Zu einzelnen Zeichen springen
+
+f<character> # Springe vorwärts und auf dem Zeichen <character>
+t<character> # Springe vorwärts und lande vor dem Zeichen <character>
+
+# Zum Beispiel,
+f< # Springe vorwärts und lande auf <
+t< # Springe vorwärts und lande vor <
+
+# Wortweise navigieren
+
+w # Springe um ein Wort vorwärts
+b # Gehe ein Wort zurück
+e # Springe zum Ende des aktuellen Wortes
+
+# Weitere Befehle, um zu navigieren
+
+gg # Gehe an den Start der Datei
+G # Gehe an das Ende der Datei
+:NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
+H # Navigiere zum Start der aktuellen Bildschirmanzeige
+M # Navigiere in die Mitte der aktuellen Bildschirmanzeige
+L # Navigiere an das Ende der aktuellen Bildschirmanzeige
```
-## Hilfsdokumente:
+## Hilfsdokumente
Vim hat eine eingebaute Dokumentation, welche mit `:help <topic>` aufgerufen
werden kann.
@@ -99,34 +96,33 @@ Zum Beispiel öffnet `:help navigation` die Dokumentation über das Navigieren
`:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard-
Hilfsdialog an, welcher den Start mit vim einfacher macht.
-that aims to make getting started with vim more approachable!
-## Modi:
+## Modi
Vim basiert auf dem Konzept von **modes**.
-- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und Befehle eingeben
+- Command Mode - Vims erster Modus, hier kann man navigieren und Befehle eingeben
- Insert Mode - Wird verwendet, um Änderungen in der Datei zu machen.
-- Visual Mode - Wird verwendet, um Text zu markieren und Operationen durchzuführen
+- Visual Mode - Wird verwendet, um Text zu markieren und diesen zu verändern
- Ex Mode - Wird verwendet, um im ':'-Prompt Befehle einzugeben
```
- i # Führt vim in den Insert Mode, vor der Cursorposition
- a # Führt vim in den Insert Mode, nach der Cursorposition
- v # Führt vim in den Visual Mode
- : # Führt vim in den Ex Mode
- <esc> # Führt zurück in den Command Mode, egal in welchem Mode
- # man sich gerade befindet.
-
- # Kopieren und einfügen von Text
-
- y # Kopiere alles, was im Moment ausgewählt ist
- yy # Kopiert die aktuelle Zeile
- d # Löscht alles, was im Moment ausgewählt ist
- dd # Löscht die aktuelle Zeile
- p # Fügt den kopierten Text nach dem Cursor ein
- P # Fügt den kopierten Text vor dem Cursor ein
- x # Löscht das Zeichen unter dem Cursor
+i # Führt vim in den Insert Mode, vor der Cursorposition
+a # Führt vim in den Insert Mode, nach der Cursorposition
+v # Führt vim in den Visual Mode
+: # Führt vim in den Ex Mode
+<esc> # Führt zurück in den Command Mode, egal in welchem Mode
+ # man sich gerade befindet.
+
+# Kopieren und einfügen von Text
+
+y # Kopiere alles, was im Moment ausgewählt ist
+yy # Kopiert die aktuelle Zeile
+d # Löscht alles, was im Moment ausgewählt ist
+dd # Löscht die aktuelle Zeile
+p # Fügt den kopierten Text nach dem Cursor ein
+P # Fügt den kopierten Text vor dem Cursor ein
+x # Löscht das Zeichen unter dem Cursor
```
## Die 'Grammatik' von Vim
@@ -141,68 +137,67 @@ Vim kann als Satz von Kommandos angesehen werden, welche im Format
Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
```
- # 'Verb'
-
- d # löschen
- c # ändern
- y # kopieren
- v # visuelles auswählen
-
- # 'Modifiers'
-
- i # innerhalb
- a # außerhalb
- NUM # Nummer (NUM kann irgendeine Zahl sein)
- f # Sucht nach etwas und landet darauf
- t # Sucht nach etwas und stoppt davor
- / # Suche eine Zeichenfolge ab dem Cursor
- ? # Suche eine Zeichenfolge vor dem Cursor
-
- # 'Nouns'
-
- w # Wort
- s # Satz
- p # Abschnitt
- b # Block
-
- # Beispielsätze resp. Kommandos
-
- d2w # lösche zwei Wörter
- cis # Ändere innerhalb des Satzes.
- yip # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
- # in welchem du bist)
- ct< # Ändere bis zur spitzen Klammer
- # Ändere den Text von deiner aktuellen Cursorposition bis
- # zur nächsten spitzen Klammer
- d$ # Lösche bis zum Ende der Zeile
+# 'Verb'
+
+d # löschen
+c # ändern
+y # kopieren
+v # visuelles auswählen
+
+# 'Modifiers'
+
+i # innerhalb
+a # außerhalb
+NUM # Nummer (NUM kann irgendeine Zahl sein)
+f # Sucht nach etwas und landet darauf
+t # Sucht nach etwas und stoppt davor
+/ # Suche eine Zeichenfolge ab dem Cursor
+? # Suche eine Zeichenfolge vor dem Cursor
+
+# 'Nouns'
+
+w # Wort
+s # Satz
+p # Abschnitt
+b # Block
+
+# Beispielsätze resp. Kommandos
+
+d2w # lösche zwei Wörter
+cis # Ändere innerhalb des Satzes.
+yip # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
+ # in welchem du bist)
+ct< # Ändere bis zur spitzen Klammer
+ # Ändere den Text von deiner aktuellen Cursorposition bis
+ # zur nächsten spitzen Klammer
+d$ # Lösche bis zum Ende der Zeile
```
## Einige Shortcuts und Tricks
```
- > # Rücke die Auswahl um einen Block ein
- < # Lösche eine Einrückung der Auswahl
- :earlier 15m # Stellt das Dokument so wieder her, wie es vor 15
- # Minuten war
- :later 15m # den oberen Befehl rückgängig machen
- ddp # Vertauschen zweier aufeinanderfolgenden Zeilen
- # Zuerst dd, dann p
- . # Wiederhole die vorherige Aktion
- :w !sudo tee % # Speichere die Datei als Root
- :set syntax=c # Stelle das Syntax-Highlighting für 'C' ein
- :sort # Alle Zeilen sortieren
- :sort! # Alle Zeilen rückwärts sortieren
- :sort u # Alle Zeilen sortieren und Duplikate entfernen
- ~ # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
- u # Ausgewählten Text zu Kleinschreibung ändern
- U # Ausgewählten Text zu Großschreibung ändern
-
- # Text-Folding (Textfaltung)
- zf # Erstelle eine Faltung des ausgewählten Textes
- zo # Öffne die aktuelle Faltung
- zc # Schließe die aktuelle Faltung
- zR # Öffne alle Faltungen
- zM # Schließe alle Faltungen
+> # Rücke die Auswahl um einen Block ein
+< # Lösche eine Einrückung der Auswahl
+:earlier 15m # Stellt das Dokument so wieder her, wie es vor 15 Minuten war
+:later 15m # den oberen Befehl rückgängig machen
+ddp # Vertauschen zweier aufeinanderfolgenden Zeilen
+ # Zuerst dd, dann p
+. # Wiederhole die vorherige Aktion
+:w !sudo tee % # Speichere die Datei als Root
+:set syntax=c # Stelle das Syntax-Highlighting für 'C' ein
+:sort # Alle Zeilen sortieren
+:sort! # Alle Zeilen rückwärts sortieren
+:sort u # Alle Zeilen sortieren und Duplikate entfernen
+~ # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
+u # Ausgewählten Text zu Kleinschreibung ändern
+U # Ausgewählten Text zu Großschreibung ändern
+
+# Text-Folding (Textfaltung)
+zf # Erstelle eine Faltung des ausgewählten Textes
+zo # Öffne die aktuelle Faltung
+zc # Schließe die aktuelle Faltung
+zR # Öffne alle Faltungen
+zM # Schließe alle Faltungen
```
## Makros
@@ -213,9 +208,9 @@ Kommandos, welche du braucht, aufgenommen bis die Aufnahme gestoppt wird.
Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht.
```
- qa # Starte das Aufnehmen des Makros 'a'
- q # Beende das Aufnehmen
- @a # Führe das Makro 'a' aus
+qa # Starte das Aufnehmen des Makros 'a'
+q # Beende das Aufnehmen
+@a # Führe das Makro 'a' aus
```
### Konfigurieren mit ~/.vimrc
diff --git a/de-de/visualbasic-de.html.markdown b/de-de/visualbasic-de.html.markdown
new file mode 100644
index 00000000..a0dde471
--- /dev/null
+++ b/de-de/visualbasic-de.html.markdown
@@ -0,0 +1,290 @@
+---
+language: Visual Basic
+contributors:
+ - ["Brian Martin", "http://brianmartin.biz"]
+translators:
+ - ["Enno Nagel", "https://github.com/konfekt"]
+filename: learnvisualbasic-de.vb
+lang: de-de
+---
+
+```
+Module Modul1
+
+Sub Main()
+ ' Ein kurzer Blick auf Visual Basic-Konsolenanwendungen
+ ' bevor wir tiefer in das Thema eintauchen.
+ ' Das Hochkomma leitet eine Kommentarzeile ein.
+ ' Um dieses Tutorial innerhalb des Visual Basic Compilers zu erkunden,
+ ' habe ich ein Navigationssystem erstellt.
+ ' Dieses System wird im weiteren Verlauf des Tutorials erklärt;
+ ' Sie werden nach und nach verstehen, was das alles bedeutet.
+ Console.Title = ("Lerne X in Y Minuten")
+ Console.WriteLine ("NAVIGATION") 'Anzeige
+ Console.WriteLine ("")
+ Console.ForegroundColor = ConsoleColor.Green
+ Console.WriteLine ("1. Ausgabe von 'Hallo, Welt'")
+ Console.WriteLine ("2. Eingabe 'Hallo, Welt'")
+ Console.WriteLine ("3. ganze Zahlen berechnen")
+ Console.WriteLine ("4. Berechne Dezimalzahlen")
+ Console.WriteLine ("5. ein funktionaler Taschenrechner")
+ Console.WriteLine ("6. 'Do While'-Schleifen verwenden")
+ Console.WriteLine ("7. Verwendung von 'For While'-Schleifen")
+ Console.WriteLine ("8. Bedingte Anweisungen")
+ Console.WriteLine ("9. Ein Getränk auswählen")
+ Console.WriteLine ("50. Über")
+ Console.WriteLine ("Wählen Sie eine Zahl aus der obigen Liste")
+ Dim selection As String = Console.Readline()
+ Select Case auswahl
+ Case "1" 'Ausgabe "Hallo, Welt"
+ Console.Clear() 'Löscht die Konsole und öffnet die private Subroutine
+ AusgabeHalloWelt() 'Öffnet die genannte private Subroutine
+ Case "2" 'Eingabe "hallo, Welt"
+ Console.Clear()
+ EingabeHalloWelt()
+ Case "3" 'Berechne ganze Zahlen
+ Console.Clear()
+ BerechneGanzeZahlen()
+ Case "4" 'Dezimalzahlen berechnen
+ Console.Clear()
+ BerechneDezimalZahlen()
+ Case "5" 'Ein funktionaler Taschenrechner
+ Console.Clear()
+ Taschenrechner()
+ Case "6" 'Verwendung von "Do While"-Schleifen
+ Console.Clear()
+ WhileSchleife()
+ Case "7" 'Verwendung von "For While"-Schleifen
+ Console.Clear()
+ ForSchleife()
+ Case "8" 'Bedingte Anweisungen
+ Console.Clear()
+ BedingteAnweisung()
+ Case "9" 'If/Else-Anweisung
+ Console.Clear()
+ IfElseAnweisung() 'Ein Getränk auswählen
+ Case "50" '"Über" Infobox
+ Console.Clear()
+ Console.Title = ("Lernen Sie X in Y Minuten :: Über")
+ MsgBox ("Tutorial geschrieben von Brian Martin (@BrianMartinn)")
+ Console.Clear()
+ Main()
+ Console.ReadLine()
+
+ End Select
+End Sub
+
+'Eins - Ich habe Zahlen verwendet, um mich durch das obige Navigationssystem zu
+'führen auf das ich später zurückkomme, um es zu implementieren.
+
+'wir verwenden private Unterprogramme, um verschiedene Abschnitte des Programms
+'zu trennen.
+Private Sub AusgabeHalloWelt()
+ 'Titel der Konsolenanwendung
+ Console.Title = "Ausgabe 'Hallo, Welt' | Lerne X in Y Minuten"
+ 'Verwenden Sie Console.Write("") oder Console.WriteLine(""), um die Ausgabe
+ 'anzuzeigen, gefolgt von Console.Read(), oder Console.Readline()
+ 'Console.ReadLine() zeigt die Ausgabe auf der Konsole an.
+ Console.WriteLine ("Hallo, Welt")
+ Console.ReadLine()
+End Sub
+
+'Zwei
+Private Sub EingabeHalloWelt()
+ Console.Title = "Hallo, Welt, ich bin.. | Lerne X in Y Minuten"
+ 'Variablen
+ 'Vom Benutzer eingegebene Daten müssen gespeichert werden.
+ 'Variablen beginnen ebenfalls mit Dim und enden mit As VariableType.
+
+ 'In diesem Lernprogramm wollen wir Ihren Namen wissen und das Programm
+ 'auf ihn antworten.
+ Dim nutzername As String
+ ' Wir verwenden "String", weil es sich um eine textbasierte Variable handelt.
+ Console.WriteLine ("Hallo, wie ist Ihr Name?") 'Frage nach dem Benutzernamen.
+ nutzername = Console.ReadLine() 'Benutzernamen speichern.
+ Console.WriteLine ("Hallo, " + nutzername) 'Ausgabe ist Hallo, Name
+ Console.ReadLine() 'Die obige Ausgabe anzeigen.
+ 'Der obige Code stellt Ihnen eine Frage und zeigt die Antwort an.
+ 'Neben anderen Variablentypen gibt es Integer, den wir für ganze Zahlen
+ 'verwenden werden.
+End Sub
+
+'Drei
+Private Sub BerechneGanzeZahlen()
+ Console.Title = "Berechne ganze Zahlen | Lerne X in Y Minuten"
+ Console.Write ("Erste Zahl: ") 'Schreiben Sie eine ganze Zahl, 1, 2, 104, usw
+ Dim a As Integer = Console.ReadLine()
+ Console.Write ("Zweite Zahl: ") 'Schreiben Sie eine weitere ganze Zahl.
+ Dim b As Integer = Console.ReadLine()
+ Dim c As Integer = a + b
+ Console.WriteLine (c)
+ Console.ReadLine()
+ 'Dies ist ein einfacher Taschenrechner
+End Sub
+
+'Vier
+Private Sub BerechneDezimalZahlen()
+ Console.Title = "Berechne mit dem Typ Double | Lerne X in Y Minuten"
+ 'Natürlich würden wir gerne Dezimalzahlen addieren.
+ 'Also könnten wir von Integer auf Double umstellen.
+
+ 'Schreiben Sie eine Bruchzahl, 1.2, 2.4, 50.1, 104.9 usw
+ Console.Write ("Erste Zahl: ")
+ Dim a As Double = Console.Readline()
+ Console.Write ("Zweite Zahl: ") 'Schreiben Sie die zweite Zahl.
+ Dim b As Double = Console.Readline()
+ Dim c As Double = a + b
+ Console.WriteLine (c)
+ Console.ReadLine()
+ 'Dieses Programm kann 1.1 und 2.2 addieren
+End Sub
+
+'Fünf
+Private Sub Taschenrechner()
+ Console.Title = "Der Funktionsrechner | Lerne X in Y Minuten"
+ 'Wenn Sie aber wollen, dass der Rechner subtrahiert, dividiert,
+ 'multipliziert und addiert.
+ 'Kopieren Sie den obigen Text und fügen Sie ihn ein.
+ Console.Write ("Erste Zahl: ")
+ Dim a As Double = Console.Readline()
+ Console.Write ("Zweite Zahl: ")
+ Dim b As Integer = Console.Readline()
+ Dim c As Integer = a + b
+ Dim d As Integer = a * b
+ Dim e As Integer = a - b
+ Dim f As Integer = a / b
+
+ 'Mit den folgenden Zeilen können wir die Werte a und b
+ 'subtrahieren, multiplizieren und dividieren
+ Console.Write (a.ToString() + " + " + b.ToString())
+ 'Wir wollen den Ergebnissen einen linken Rand von 3 Leerzeichen geben.
+ Console.WriteLine (" = " + c.ToString.PadLeft(3))
+ Console.Write (a.ToString() + " * " + b.ToString())
+ Console.WriteLine (" = " + d.ToString.PadLeft(3))
+ Console.Write (a.ToString() + " - " + b.ToString())
+ Console.WriteLine (" = " + e.ToString.PadLeft(3))
+ Console.Write (a.ToString() + " / " + b.ToString())
+ Console.WriteLine (" = " + f.ToString.PadLeft(3))
+ Console.ReadLine()
+
+End Sub
+
+'Sechs
+Private Sub WhileSchleife()
+ 'Gleich zur vorherigen privaten Subroutine.
+ 'Diesmal fragen wir den Benutzer, ob er fortfahren möchte (ja oder nein?).
+ 'Wir verwenden die Do While-Schleife, weil wir nicht wissen, ob der Benutzer
+ 'das Programm mehr als einmal verwenden möchte.
+ Console.Title = "Do While-Schleifen verwenden | X in Y Minuten lernen"
+ Dim antwort As String 'Wir verwenden "String", weil die Antwort ein Text ist
+ Do 'Wir beginnen das Programm mit
+ Console.Write ("Erste Zahl: ")
+ Dim a As Double = Console.Readline()
+ Console.Write ("Zweite Zahl: ")
+ Dim b As Integer = Console.Readline()
+ Dim c As Integer = a + b
+ Dim d As Integer = a * b
+ Dim e As Integer = a - b
+ Dim f As Integer = a / b
+
+ Console.Write (a.ToString() + " + " + b.ToString())
+ Console.WriteLine (" = " + c.ToString.PadLeft(3))
+ Console.Write (a.ToString() + " * " + b.ToString())
+ Console.WriteLine (" = " + d.ToString.PadLeft(3))
+ Console.Write (a.ToString() + " - " + b.ToString())
+ Console.WriteLine (" = " + e.ToString.PadLeft(3))
+ Console.Write (a.ToString() + " / " + b.ToString())
+ Console.WriteLine (" = " + f.ToString.PadLeft(3))
+ Console.ReadLine()
+ 'Fragen Sie den Benutzer, ob er fortfahren möchte. Unglücklicherweise
+ 'werden Groß- und Kleinschreibung unterschieden.
+ Console.Write ("Möchten Sie fortfahren? (j / n)")
+ 'Das Programm nimmt die Variable, zeigt sie an und beginnt von vorne.
+ antwort = Console.Readline()
+ 'Der Befehl, der diese Variable zum Laufen bringt, ist in diesem Fall "j"
+ Loop While antwort = "j"
+
+End Sub
+
+'Sieben
+Private Sub ForSchleife()
+ 'Manchmal muss das Programm nur einmal ausgeführt werden.
+ 'In diesem Programm werden wir von 10 loszählen.
+
+ Console.Title = "Mit "For"-Schleifen | X in Y Minuten lernen"
+ 'Deklarieren Sie die Variable und ab welcher Zahl in Schritt -1 gezählt
+ 'werden soll, Schritt -2, Schritt -3, usw.
+ For i As Integer = 10 To 0 Schritt -1
+ Console.WriteLine (i.ToString) 'Zählerwert anzeigen
+ Next i 'Berechne den neuen Wert
+ Console.WriteLine ("Start") 'Starten wir das Programm, baby!!!!
+ Console.ReadLine() 'BANG!!!! - Vielleicht war ich zu aufgeregt :)
+End Sub
+
+'Acht
+Private Sub BedingteAnweisung()
+ Console.Title = "Bedingte Anweisungen | X in Y Minuten lernen"
+ Dim username As String = Console.Readline()
+ 'Aufforderung zur Eingabe des Benutzernamens.
+ Console.WriteLine ("Hallo, wie ist Ihr Name?")
+ username = Console.ReadLine() 'Benutzernamen speichern.
+ If username = "Adam" Then
+ Console.WriteLine ("Hallo, Adam")
+ Console.WriteLine ("Danke, dass Sie diese nützliche Website erstellt haben")
+ Console.ReadLine()
+ Else
+ Console.WriteLine ("Hallo, " + Benutzername)
+ Console.WriteLine ("Haben Sie www.learnxinyminutes.com besucht?")
+ Console.ReadLine() 'Beendet und zeigt die obige Anweisung an.
+ End If
+End Sub
+
+ 'Neun
+Private Sub IfElseAnweisung()
+ Console.Title = "If / Else-Anweisung | X in Y Minuten lernen"
+ 'Manchmal ist es wichtig, mehr als zwei Alternativen in Betracht zu ziehen.
+ 'Manchmal sind einige von ihnen besser.
+ 'In diesem Fall brauchen wir mehr als eine "if"-Anweisung.
+ 'Eine "if"-Anweisung ist für Verkaufsautomaten geeignet.
+ 'Der Benutzer gibt einen Code ein (A1, A2, A3), aus dem er wählen kann.
+ 'Alle Auswahlmöglichkeiten können in einer einzigen "if"-Anweisung
+ 'kombiniert werden.
+
+ Dim auswahl As String = Console.ReadLine 'Der Wert der Auswahl
+ Console.WriteLine ("A1. für 7Up")
+ Console.WriteLine ("A2. für Fanta")
+ Console.WriteLine ("A3. für Dr. Pepper")
+ Console.WriteLine ("A4. für Coca-Cola")
+ Console.ReadLine()
+ If auswahl = "A1" Dann
+ Console.WriteLine ("7up")
+ Console.ReadLine()
+ ElseIf auswahl = "A2" Then
+ Console.WriteLine ("fanta")
+ Console.ReadLine()
+ ElseIf auswahl = "A3" Then
+ Console.WriteLine ("Dr. Pfeffer")
+ Console.ReadLine()
+ ElseIf auswahl = "A4" Then
+ Console.WriteLine ("Coca-Cola")
+ Console.ReadLine()
+ Else
+ Console.WriteLine ("Ein Produkt auswählen")
+ Console.ReadLine()
+ End If
+
+End Sub
+
+End Module
+```
+
+## Referenzen
+
+Für diejenigen, die mehr wissen wollen, hat Brian Martin ein umfassenderes
+[Visual Basic Tutorial](http://www.vbbootcamp.co.uk/ "Visual Basic Tutorial")
+erstellt.
+
+Die gesamte Syntax sollte gültig sein.
+Kopieren Sie den Code und fügen Sie ihn in den Visual Basic Compiler ein und
+führen Sie das Programm aus (F5).
+
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
index 0332c912..00e4fd94 100644
--- a/de-de/yaml-de.html.markdown
+++ b/de-de/yaml-de.html.markdown
@@ -112,7 +112,7 @@ python_komplexe_Zahlen: !!python/komplex 1+2j
####################
# Strings und Zahlen sind nicht die einzigen Skalare, welche YAML versteht.
-# ISO-formatierte Datumsangaben and Zeiangaben können ebenso geparsed werden.
+# ISO-formatierte Datumsangaben and Zeitangaben 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