Fix failing build for a German version because of template tags

Author: mistadikay

de/02.2.md

@@ -15,36 +15,36 @@ Definiere mehrere Variablen.
 
 	// Definiere drei Variablen vom Typ "type"
 	var vname1, vname2, vname3 type
-	
+
 Definiere eine Variable mit einem Startwert.
 
 	// Definiere eine Variable mit dem Namen “variableName” vom Typ "type" und dem Wert "value"
 	var variableName type = value
-	
+
 Definiere mehrere Variablen mit einem Startwert.
 
 	/*
     Definiere drei Variablen vom Typ "type" und gib ihnen drei Startwerte.
     vname1 ist gleich v1, vname2 ist gleich  v2, vname3 ist gleich v3
 	*/
 	var vname1, vname2, vname3 type = v1, v2, v3
-	
+
 Findest Du es nicht auch ein wenig mühsehlig, Variablen auf diesem Weg zu definieren? Keine Sorge, denn das Team hinter Go hat auch so gedacht. Daher kannst Du Variablen Startwerte geben, ohne explizit den Datentyp zu definieren. Der Code würde dann so aussehen:
 
 	/*
     Definiere drei Variablen vom Typ "type" und gib ihnen drei Ausgangswerte.
     vname1 ist gleich v1, vname2 ist gleich  v2, vname3 ist gleich v3
 	*/
 	var vname1, vname2, vname3 = v1, v2, v3
-	
+
 Schön, ich weiß das dies immer noch nicht einfach genug für Dich ist. Mal schauen, wie wir das lösen können.
 
 	/*
 	Definiere drei Variablen ohne den Typ "type", ohne das Schlüsselwort "var" und gib ihnen Startwerte.
     vname1 ist gleich v1，vname2 ist gleich v2，vname3 ist gleich v3
 	*/
 	vname1, vname2, vname3 := v1, v2, v3
-	
+
 
 So sieht es schon viel besser aus. Nutze `:=`, um `var` und `type` zu ersetzen. Es handelt sich hierbei um eine Kurzschreibweise. Aber warte, es gibt einen kleinen Haken: diese Form der Definition kann nur innerhalb von Fuktionen genutzt werden. Der Compiler wird sonst eine Fehlermeldung ausgeben, wenn Du es trotzdem außerhalb der `{}` einer Funktion versuchst. Daher nutzen wir meist das Schlüsselwort `var` um globale Variablen zu definieren oder die Funktion `var()`.
 
@@ -59,15 +59,15 @@ Wenn Du Variablen in Deinem Programm definierst, aber keine Verwendung finden, w
 	func main() {
 	    var i int
 	}
-	
+
 ## Konstanten
 
 Konstanten sind Werte, die während der Kompilierung festgelegt werden und während der Laufzeit nicht veränderbar sind. In Go kannst Du Konstanten als Wert Nummern, Booleans oder Strings geben.
 
 Definiere eine Konstante wie folgt.
 
 	const constantName = value
-	// Du kannst auch den Datentyp hinzufügen, wenn nötig 
+	// Du kannst auch den Datentyp hinzufügen, wenn nötig
 	const Pi float32 = 3.1415926
 
 Mehr Beispiele.
@@ -76,7 +76,7 @@ Mehr Beispiele.
 	const i = 10000
 	const MaxThread = 10
 	const prefix = "astaxie_"
-	
+
 ## Grundlegende Datentypen
 
 ### Boolean
@@ -91,7 +91,7 @@ In Go nutzen wir `bool`, um Booleans (Wahrheitswerte) auszudrücken, die entwede
     	valid := false      // Kurzschreibweise einer Definition
     	available = true    // Eine Variable deklarieren
 	}
-	
+
 ### Numerische Datentypen
 
 Der Datentyp Integer (ganze Zahlen) kann sowohl den positiven, als auch den negativen Zahlenraum umfassen, was durch ein Vorzeichen kenntlich gemacht wird. Go besitzt `int` und `uint`, welche den selben Wertebereich haben. Dessen Größe hängt aber vom Betriebssystem ab. Es werden 32-Bit unter 32-Bit Betriebssystemen verwendet und 64-Bit unter 64-Bit Betriebssystemen. Go umfasst außerdem Datentypen mit einer spezifischen Länge: `rune`, `int8`, `int16`, `int32`, `int64`, `byte`, `uint8`, `uint16`, `uint32` und `uint64`. Bedenke, dass `rune` ein Alias für `int32` ist und `byte` dem `uint8` gleicht.
@@ -114,7 +114,7 @@ War das schon alles? Nein! Go unterstützt auch komplexe Zahlen. `complex128` (b
 	var c complex64 = 5+5i
 	// Ausgabe: (5+5i)
 	fmt.Printf("Der Wert ist: %v", c)
-	
+
 ### Strings
 
 Wir sprachen vorhin darüber, das Go eine native UTF-8 Unterstützung mit sich bringt. Strings (Zeichenketten) werden durch Anführungszeichen `""` gekennzeichet, oder durch Backticks (rückwärts geneigtes Hochkomma) ``` `` ```.
@@ -140,28 +140,28 @@ Aber was ist, wenn ich wirklich nur ein Zeichen in einem String ändern möchte?
 	c[0] = 'c'
 	s2 := string(c)  // Wandle den Wert in eine String zurück
 	fmt.Printf("%s\n", s2)
-	
+
 
 Nutze den `+` Operator, um zwei Strings zu verknüpfen.
 
 	s := "Hallo"
 	m := " Welt"
 	a := s + m
 	fmt.Printf("%s\n", a)
-	
+
 
 oder auch
 
 	s := "Hallo"
 	s = "c" + s[1:] // Du kannst die Werte mit Hilfe des Index nicht verändern, aber sie abfragen
 	fmt.Printf("%s\n", s)
-	
+
 
 Was ist, wenn ein String über mehrere Zeilen verlaufen soll?
 
 	m := `Hallo
     Welt`
- 
+
 `\`` wird die Zeichen in einem String escapen (d.h. mit `\` dessen Ausführung verhindern).
 
 ### Fehlermeldungen
@@ -172,7 +172,7 @@ Go besitzt mit `error` einen eigenen Datentyp, um mit Fehlermeldungen umzugehen.
 	if err != nil {
     	fmt.Print(err)
 	}
-	
+
 ### Grundeliegende Datenstrukturen
 
 Die folgende Grafik enstammt dem Artikel [Datenstrukturen in Go](http://research.swtch.com/godata) (auf englisch) aus [Russ Coxs Blog](http://research.swtch.com/). Wie Du sehen kannst, nutzt Go Abschnitte des Arbeitsspeichers, um Daten zu speichern.
@@ -199,7 +199,7 @@ Wenn Du mehrere Konstanten und Variablen deklarieren oder Pakete importieren mö
 	var i int
 	var pi float32
 	var prefix string
-	
+
 Gruppierter Ansatz.
 
 	import(
@@ -233,8 +233,8 @@ Go besitzt das Schlüselwort `iota`, um eine Aufzählung zu starten. Der Startwe
 	)
 
 	const v = iota // Sobald iota erneut auf `const` trifft, wird erneut mit `0` gestartet, also gilt v = 0.
-	
-	const ( 
+
+	const (
 	  e, f, g = iota, iota, iota // e, f und g haben den selben Wert 0, da sie in der selben Zeile stehen.
 	)
 
@@ -261,7 +261,7 @@ wobei in `[n]Datentyp` das `n` die Länge des Arrays angibt. `Datentyp` ist selb
 	fmt.Printf("Das erste Element ist %d\n", arr[0])   // Beim Auslesen des Wertes wird 42 zurückgegeben
 	fmt.Printf("Das letzte Element ist %d\n", arr[9]) // Es gibt den Standardwert des 10. Elements zurück, was in diesem Fall 0 ist.
 
-Da die Länge ein Teil des Array-Typs ist, sind `[3]int` und `[4]int` verschieden, sodass wir die Länge eines Arrays nicht ändern können. Nutzt Du Arrays als Argument in einer Funktion, dann wird eine Kopie des Arrays übergeben, statt einem Zeiger (bzw. ein Verweis) auf das Original. Möchtest Du stattdessen den Zeiger übergeben, dann musst Du einen `slice` verwenden. Darauf gehen wir aber später nochmals ein. 
+Da die Länge ein Teil des Array-Typs ist, sind `[3]int` und `[4]int` verschieden, sodass wir die Länge eines Arrays nicht ändern können. Nutzt Du Arrays als Argument in einer Funktion, dann wird eine Kopie des Arrays übergeben, statt einem Zeiger (bzw. ein Verweis) auf das Original. Möchtest Du stattdessen den Zeiger übergeben, dann musst Du einen `slice` verwenden. Darauf gehen wir aber später nochmals ein.
 
 Es ist möglich, `:=` zu nutzen, um ein Array zu deklarieren.
 
@@ -273,10 +273,10 @@ Vielleicht möchtest Du auch Arrays als Element in einem Array nutzen. Schauen w
 
 	// Deklariere ein zweidimensionales Array mit zwei Elementen, welche jeweils vier Elemente besitzen.
 	doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
-	
+
+
 	// Die Dekleration kann auch ein wenig kompakter geschrieben werden.
-	easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
-	
+{% raw %}	easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}} {% endraw %}
 
 Arrays sind grundlegende Datenstrukturen in Go.
 
@@ -308,12 +308,12 @@ Nun deklarieren wir ein `slice` und vergeben Startwerte.
 	// 'a' verweist auf die Elemente zwischen Index 3 und 5 im Array ar.
 	a = ar[2:5]
 	// 'a' besitzt nun die Elemente ar[2],ar[3] und ar[4]
-	
+
 	// 'b' ist ein weiterer Ausschnitt (Slice) vom Array ar
 	b = ar[3:5]
 	// 'b' besitzt nun die Elemente ar[3] und ar[4]
 
-Beachte die Unterscheide bei der Deklaration von `slice` und `array`. Wir nutzen `[…]`, um Go die Länge automatisch herausfinden zu lassen, aber nutzen `[]` lediglich zur Deklaration von Slices. 
+Beachte die Unterscheide bei der Deklaration von `slice` und `array`. Wir nutzen `[…]`, um Go die Länge automatisch herausfinden zu lassen, aber nutzen `[]` lediglich zur Deklaration von Slices.
 
 Ihre zugrundeliegenden Datentypen.
 
@@ -325,7 +325,7 @@ Slices haben bestimmte Anwendungsgebiete.
 
 - Ein `slice` beginnt mit dem Index 0, `ar[:n]` gleicht `ar[0:n]`.
 - Der zweite Index gibt die Länge vom Slice an, wenn er ausgelassen wird. `ar[n:]` gleicht `ar[n:len(ar)]`.
-- Du kannst auch `ar[:]` nutzen, um einen gesamtes Array zu kopieren, wie in den ersten beiden Punkten erklärt. 
+- Du kannst auch `ar[:]` nutzen, um einen gesamtes Array zu kopieren, wie in den ersten beiden Punkten erklärt.
 
 Mehr Beispiele zu `slice`
 
@@ -383,7 +383,7 @@ Schauen wir uns ein wenig Code an. Die 'set'- und 'get'-Werte in `map` sind der
 	// Ein alternativer Weg zum Deklarieren
 	nummern := make(map[string]int)
 	nummern["eins"] = 1  // Weise ein Wert durch einen Schlüssel zu
-	nummern["zehn"] = 10 
+	nummern["zehn"] = 10
 	nummern["drei"] = 3
 
 	fmt.Println("Die dritte Nummer lautet: ", nummern["drei"]) // Lese den Wert aus
@@ -398,7 +398,7 @@ Einige Anmerkungen zur Nutzung von maps.
 
 Du kannst das Schema `Schlüssel:Wert` nutzen, um eine `map` mit Startwerten zu erstellen. `map` hat auch eingebaute Funktionen, um die Existenz eines `key` zu überprüfen.
 
-Benutze `delete`, um ein Element in `map` zu löschen. 
+Benutze `delete`, um ein Element in `map` zu löschen.
 
 	// Erstelle eine map
 	bewertung := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
@@ -450,9 +450,9 @@ Standardwerte besitzen einen Wert. Dies sind die gebräuchlichsten Anwendungsfä
 	float64 0 // Die Größe beträgt 8 Byte
 	bool    false
 	string  ""
-	
+
 ## Links
 
 - [Inhaltsverzeichnis](preface.md)
 - Vorheriger Abschnitt: ["Hallo Go"](02.1.md)
-- Nächster Abschnitt: [Kontrollstrukturen und Funktionen](02.3.md)
+- Nächster Abschnitt: [Kontrollstrukturen und Funktionen](02.3.md)