Convert \r\n to \n

4 files changed, 2101 insertions, 2101 deletions

diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown
index 18a23017..662c2e76 100644
--- a/de-de/csharp-de.html.markdown
+++ b/de-de/csharp-de.html.markdown
@@ -1,890 +1,890 @@
----

-language: C#

-contributors:

-    - ["Irfan Charania", "https://github.com/irfancharania"]

-    - ["Max Yankov", "https://github.com/golergka"]

-    - ["Melvyn Laïly", "http://x2a.yt"]

-    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]

-translators:

-    - ["Frederik Ring", "https://github.com/m90"]

-filename: LearnCSharp-de.cs

-lang: de-de

----

-C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden.

-

-[Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx)

-

-```c#

-// Einzeilige Kommentare starten mit zwei Schrägstrichen: //

-/*

-Mehrzeile Kommentare wie in C Schrägstrich / Stern

-*/

-/// <summary>

-/// XML-Kommentare können zur automatisierten Dokumentation verwendet werden

-/// </summary>

-

-// Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt

-using System;

-using System.Collections.Generic;

-using System.Data.Entity;

-using System.Dynamic;

-using System.Linq;

-using System.Linq.Expressions;

-using System.Net;

-using System.Threading.Tasks;

-using System.IO;

-

-// definiert einen Namespace um Code in "packages" zu organisieren

-namespace Learning

-{

-    // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei

-    // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu

-    // handhaben führt aber unweigerlich ins Chaos (wirklich)!

-    public class LearnCSharp

-    {

-        // Zuerst erklärt dieses Tutorial die Syntax-Grundlagen,

-        // wenn du bereits Java oder C++ programmieren kannst:

-        // lies bei "Interessante Features" weiter!

-        public static void Syntax()

-        {

-            // Mit Console.WriteLine kannst du einfachen Text ausgeben:

-            Console.WriteLine("Hallo Welt");

-            Console.WriteLine(

-                "Integer: " + 10 +

-                " Double: " + 3.14 +

-                " Boolean: " + true);

-

-            // Console.Write erzeugt keinen Zeilenumbruch

-            Console.Write("Hallo ");

-            Console.Write("Welt");

-

-            ///////////////////////////////////////////////////

-            // Typen & Variablen

-            ///////////////////////////////////////////////////

-

-            // Deklariere eine Variable mit <Typ> <Name>

-

-            // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl

-            // (-128 <= sbyte <= 127)

-            sbyte fooSbyte = 100;

-

-            // Byte - Vorzeichenlose 8-Bit Ganzzahl

-            // (0 <= byte <= 255)

-            byte fooByte = 100;

-

-            // Short - 16-Bit Ganzzahl

-            // Vorzeichenbehaftet - (-32,768 <= short <= 32,767)

-            // Vorzeichenlos - (0 <= ushort <= 65,535)

-            short fooShort = 10000;

-            ushort fooUshort = 10000;

-

-            // Integer - 32-bit Ganzzahl

-            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)

-            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)

-

-            // Long - 64-bit Ganzzahl

-            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)

-            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)

-            // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder

-            // uint behandelt. Ein nachgestelltes L markiert den Wert als long

-            // oder ulong.

-

-            // Double - Double-precision 64-bit IEEE 754 Fließkommazahl

-            double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen

-

-            // Float - Single-precision 32-bit IEEE 754 Fließkommazahl

-            float fooFloat = 234.5f; // Genauigkeit: 7 Stellen

-            // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ

-            // float handelt

-

-            // Decimal - ein 128-Bit-Datentyp mit größerer Genauigkeit als

-            // andere Fließkommatypen, und somit bestens geeignet für

-            // die Berechnung von Geld- und Finanzwerten

-            decimal fooDecimal = 150.3m;

-

-            // Boolean - true & false

-            bool fooBoolean = true; // oder false

-

-            // Char - Ein einzelnes 16-Bit Unicode Zeichen

-            char fooChar = 'A';

-

-            // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die

-            // alle Werttypen sind, ist String ein Referenztyp. Strings sind

-            // somit nullable, Werttypen sind dies nicht.

-            string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu";

-            Console.WriteLine(fooString);

-

-            // Jeder Buchstabe eines Strings kann über seinen Index

-            // referenziert werden:

-            char charFromString = fooString[1]; // => 'e'

-            // Strings sind unveränderlich:

-            // `fooString[1] = 'X';` funktioniert nicht

-

-            // Ein Vergleich zweier Strings, unter Berücksichtigung der

-            // aktuellen, sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c

-            // in deutschsprachigen Umgebungen), und ohne Beachtung von

-            // Groß- und Kleinschreibung:

-            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);

-

-            // Formatierung, genau wie "sprintf"

-            string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2);

-

-            // Datumsangaben und Formatierung

-            DateTime fooDate = DateTime.Now;

-            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));

-

-            // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String

-            // schreiben. Um " zu maskieren benutzt man ""

-            string bazString = @"Hier geht es

-zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";

-

-            // Die Keywords const oder readonly kennzeichnen eine

-            // unveränderliche Variable/Konstante. Die Werte von Konstanten

-            // werden übrigens bereits zur Compile-Zeit berechnet.

-            const int HOURS_I_WORK_PER_WEEK = 9001;

-

-            ///////////////////////////////////////////////////

-            // Datenstrukturen

-            ///////////////////////////////////////////////////

-

-            // Arrays - Index beginnt bei Null

-            // Die Größe des Arrays wird bei der Deklaration festgelegt.

-            // Die syntaktische Struktur um ein neues Array zu erzeugen sieht

-            // folgendermaßen aus:

-            // <datatype>[] <varname> = new <datatype>[<array size>];

-            int[] intArray = new int[10];

-

-            // Arrays können auch über ein Array-Literal deklariert werden:

-            int[] y = { 9000, 1000, 1337 };

-

-            // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element

-            Console.WriteLine("intArray @ 0: " + intArray[0]);

-            // Arrays sind veränderbar

-            intArray[1] = 1;

-

-            // Listen

-            // Durch ihre größere Flexibilität kommen Listen in C# weit

-            // häufiger zum Einsatz als Arrays. Eine Liste wird so deklariert:

-            // List<datatype> <varname> = new List<datatype>();

-            List<int> intList = new List<int>();

-            List<string> stringList = new List<string>();

-            List<int> z = new List<int> { 9000, 1000, 1337 };

-            // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen"

-

-            // Listen haben keinen Default-Wert.

-            // Bevor auf einen Index zugegriffen werden kann, muss dieser

-            // auch gesetzt worden sein:

-            intList.Add(1);

-            Console.WriteLine("intList @ 0: " + intList[0]);

-

-            // Andere interessante Datenstrukturen sind:

-            // Stack/Queue

-            // Dictionary (entspricht einer Hash Map)

-            // HashSet

-            // Read-only Collections

-            // Tuple (.Net 4+)

-

-            ///////////////////////////////////////

-            // Operatoren

-            ///////////////////////////////////////

-            Console.WriteLine("\n->Operatoren");

-

-            // kurze Schreibweise um mehrere Deklarationen zusammenzufassen:

-            // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!)

-            int i1 = 1, i2 = 2;

-

-            // Arithmetik funktioniert wie erwartet:

-            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3

-

-            // Modulo

-            Console.WriteLine("11%3 = " + (11 % 3)); // => 2

-

-            // Vergleiche

-            Console.WriteLine("3 == 2? " + (3 == 2)); // => false

-            Console.WriteLine("3 != 2? " + (3 != 2)); // => true

-            Console.WriteLine("3 > 2? " + (3 > 2)); // => true

-            Console.WriteLine("3 < 2? " + (3 < 2)); // => false

-            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true

-            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true

-

-            // Bitweise Operatoren

-            /*

-            ~       Unäres bitweises NICHT

-            <<      Verschieben nach links

-            >>      Verschieben nach rechts

-            &       Bitweises UND

-            ^       Bitweises exklusives ODER

-            |       Bitweises inklusives ODER

-            */

-

-            // Inkremente

-            int i = 0;

-            Console.WriteLine("\n->Inkrement / Dekrement");

-            Console.WriteLine(i++); //i = 1. Post-Inkrement

-            Console.WriteLine(++i); //i = 2. Pre-Inkrement

-            Console.WriteLine(i--); //i = 1. Post-Dekrement

-            Console.WriteLine(--i); //i = 0. Pre-Dekrement

-

-            ///////////////////////////////////////

-            // Kontrollstrukturen

-            ///////////////////////////////////////

-            Console.WriteLine("\n->Kontrollstrukturen");

-

-            // If-Statements funktionieren wie in C

-            int j = 10;

-            if (j == 10)

-            {

-                Console.WriteLine("Ich werde ausgegeben");

-            }

-            else if (j > 10)

-            {

-                Console.WriteLine("Ich nicht");

-            }

-            else

-            {

-                Console.WriteLine("Ich leider auch nicht");

-            }

-

-            // Ternärer Operator

-            // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben:

-            // <condition> ? <true> : <false>

-            int zumVergleich = 17;

-            string isTrue = zumVergleich == 17 ? "Ja" : "Nein";

-

-            // while-Schleife

-            int fooWhile = 0;

-            while (fooWhile < 100)

-            {

-                // Wird 100mal wiederholt, fooWhile 0->99

-                fooWhile++;

-            }

-

-            // do-while-Schleife

-            int fooDoWhile = 0;

-            do

-            {

-                // Wird 100mal wiederholt, fooDoWhile 0->99

-                fooDoWhile++;

-            } while (fooDoWhile < 100);

-

-            //for-Schleifen => for(<start_statement>; <conditional>; <step>)

-            for (int fooFor = 0; fooFor < 10; fooFor++)

-            {

-                // Wird 10mal wiederholt, fooFor 0->9

-            }

-

-            // foreach-Schleife

-            // Die normale Syntax für eine foreach-Schleife lautet:

-            // foreach(<iteratorType> <iteratorName> in <enumerable>)

-            // foreach kann mit jedem Objekt verwendet werden das IEnumerable

-            // oder IEnumerable<T> implementiert. Alle Auflistungs-Typen

-            // (Array, List, Dictionary...) im .NET Framework implementieren

-            // eines dieser beiden Interfaces.

-

-            foreach (char character in "Hallo Welt".ToCharArray())

-            {

-                // Ein Durchgang für jedes Zeichen im String

-            }

-            // (ToCharArray() könnte man hier übrigens auch weglassen,

-            // da String IEnumerable bereits implementiert)

-

-            // Switch Struktur

-            // Ein Switch funktioniert mit byte, short, char und int Datentypen.

-            // Auch Aufzählungstypen können verwendet werden, genau wie

-            // die Klasse String, und ein paar Sonderklassen, die Wrapper für

-            // Primitives sind: Character, Byte, Short und Integer

-            int month = 3;

-            string monthString;

-            switch (month)

-            {

-                case 1:

-                    monthString = "Januar";

-                    break;

-                case 2:

-                    monthString = "Februar";

-                    break;

-                case 3:

-                    monthString = "März";

-                    break;

-                // Man kann für mehrere Fälle auch das selbe Verhalten

-                // definieren. Jeder Block muss aber mit einem break-Statement

-                // abgeschlossen werden. Einzelne Fälle können über

-                // `goto case x` erreicht werden

-                case 6:

-                case 7:

-                case 8:

-                    monthString = "Sommer!!";

-                    break;

-                default:

-                    monthString = "Irgendein anderer Monat";

-                    break;

-            }

-

-            ///////////////////////////////////////

-            // Umwandlung von Datentypen und Typecasting

-            ///////////////////////////////////////

-

-            // Umwandlung

-

-            // von String nach Integer

-            // bei einem Fehler wirft diese Code eine Exception

-            int.Parse("123"); //gibt die Ganzzahl 123 zurück

-

-            // TryParse gibt bei einem Fehler den Default-Wert zurück

-            // (im Fall von int: 0)

-            int tryInt;

-            if (int.TryParse("123", out tryInt)) // gibt true oder false zurück

-            {

-                Console.WriteLine(tryInt);       // 123

-            }

-

-            // von Integer nach String

-            // Die Klasse Convert stellt Methoden zur Konvertierung von

-            // unterschiedlichsten Daten zur Verfügung:

-            Convert.ToString(123); // "123"

-            // oder

-            tryInt.ToString(); // "123"

-        }

-

-        ///////////////////////////////////////

-        // Klassen

-        ///////////////////////////////////////

-        public static void Classes()

-        {

-

-            // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen

-            Bicycle trek = new Bicycle();

-

-            // So werden Methoden der Instanz aufgerufen

-            trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen

-            trek.Cadence = 100;

-

-            // ToString ist eine Konvention über die man üblicherweiser

-            // Informationen über eine Instanz erhält

-            Console.WriteLine("Infos zu trek: " + trek.ToString());

-

-            // Wir instantiieren ein neues Hochrad

-            PennyFarthing funbike = new PennyFarthing(1, 10);

-            Console.WriteLine("Infos zu funbike: " + funbike.ToString());

-

-            Console.Read();

-        } // Ende der Methode main

-

-        // Main als Konsolenstartpunkt

-        // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen

-        public static void Main(string[] args)

-        {

-            OtherInterestingFeatures();

-        }

-

-        ///////////////////////////////////////

-        // Interessante Features

-        ///////////////////////////////////////

-

-        // Methodensignaturen

-

-        public // Sichtbarkeit

-        static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz)

-        int // Typ des Rückgabewerts,

-        MethodSignatures(

-            // Erstes Argument, erwartet int

-            int maxCount,

-            // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird

-            int count = 0,

-            int another = 3,

-            // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats)

-            params string[] otherParams

-        )

-        {

-            return -1;

-        }

-

-        // Methoden können überladen werden, solange sie eindeutige

-        // Signaturen haben

-        public static void MethodSignatures(string maxCount)

-        {

-        }

-

-        // Generische Typen

-        // Die Typen für TKey und TValue werden erst beim Aufruf der Methode

-        // festgelegt. Diese Methode emuliert z.B. SetDefault aus Python:

-        public static TValue SetDefault<TKey, TValue>(

-            IDictionary<TKey, TValue> dictionary,

-            TKey key,

-            TValue defaultItem)

-        {

-            TValue result;

-            if (!dictionary.TryGetValue(key, out result))

-            {

-                return dictionary[key] = defaultItem;

-            }

-            return result;

-        }

-

-        // Möglichen Typen lassen sich auch über ihr Interface beschränken:

-        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>

-        {

-            // Da T ein IEnumerable ist können wir foreach benutzen

-            foreach (var item in toPrint)

-            {

-                // Item ist ein int

-                Console.WriteLine(item.ToString());

-            }

-        }

-

-        public static void OtherInterestingFeatures()

-        {

-            // Optionale Parameter

-            MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings");

-            // setzt explizit einen bestimmten Parameter, andere werden übersprungen

-            MethodSignatures(3, another: 3);

-

-            // Erweiterungsmethoden

-            int i = 3;

-            i.Print(); // Weiter unten definiert

-

-            // Nullables - perfekt für die Interaktion mit

-            // Datenbanken / Rückgabewerten

-            // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?

-            // nullable gemacht werden: <type>? <varname> = <value>

-            int? nullable = null; // Die explizite Langform wäre Nullable<int>

-            Console.WriteLine("Mein Nullable: " + nullable);

-            bool hasValue = nullable.HasValue; // true wenn nicht null

-

-            // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall

-            // dass die Variable null ist festzulegen.

-            int notNullable = nullable ?? 0; // 0

-

-            // Implizit typisierte Variablen

-            // Man kann auch den Typ einer Variable auch vom Compiler

-            // bestimmen lassen:

-            var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren";

-            magic = 9; // funktioniert nicht da magic vom Typ String ist

-

-            // Generics

-            var phonebook = new Dictionary<string, string>() {

-                {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu

-            };

-

-            // Hier könnte man auch unser generisches SetDefault von

-            // weiter oben benutzen:

-            Console.WriteLine(SetDefault<string,string>(phonebook, "Xaver", "kein Telefon")); // kein Telefon

-            // TKey und TValue müssen nicht zwingend angegeben werden, da sie

-            // auch implizit vom Compiler ermittelt werden können

-            Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67

-

-            // Lambdas - konzise Syntax für Inline-Funktionen

-            Func<int, int> square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert

-            Console.WriteLine(square(3)); // 9

-

-            // Disposables - einfaches Management von nicht verwalteten Ressourcen

-            // So gut wie alle Objekte die auf nicht verwaltete Ressourcen

-            // (Dateien, Geräte, ...) zugreifen, implementieren das Interface

-            // IDisposable. Das using Statement stellt sicher dass die vom

-            // IDisposable benutzten Ressourcen nach der Benutzung wieder

-            // freigegeben werden:

-            using (StreamWriter writer = new StreamWriter("log.txt"))

-            {

-                writer.WriteLine("Alles bestens!");

-                // Am Ende des Codeblocks werden die Ressourcen wieder

-                // freigegeben - auch im Falle einer Exception

-            }

-

-            // Parallel Klasse

-            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx

-            var websites = new string[] {

-                "http://www.google.com", "http://www.reddit.com",

-                "http://www.shaunmccarthy.com"

-            };

-            var responses = new Dictionary<string, string>();

-

-            // Für jeden Request wird ein neuer Thread erzeugt, der nächste

-            // Schritt wird erst nach Beendigung aller Tasks ausgeführt

-            Parallel.ForEach(websites,

-                // maximal 3 Threads gleichzeitig

-                new ParallelOptions() {MaxDegreeOfParallelism = 3},

-                website =>

-            {

-                // Hier folgt eine langwierige, asynchrone Operation

-                using (var r = WebRequest.Create(new Uri(website)).GetResponse())

-                {

-                    responses[website] = r.ContentType;

-                }

-            });

-

-            // Dieser Code wird erst nach Beendigung aller Requests ausgeführt

-            foreach (var key in responses.Keys)

-            {

-                Console.WriteLine("{0}:{1}", key, responses[key]);

-            }

-

-            // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten)

-            dynamic student = new ExpandoObject();

-            // hier muss keine Typ angegeben werden

-            student.FirstName = "Christian";

-

-            // Einem solchen Objekt kann man sogar Methoden zuordnen.

-            // Das Beispiel gibt einen String zurück und erwartet einen String

-            student.Introduce = new Func<string, string>(

-                (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo));

-            Console.WriteLine(student.Introduce("Bettina"));

-

-            // IQueryable<T> - So gut wie alle Aufzählungstypen implementieren

-            // dieses Interface, welches eine Vielzahl von funktionalen Methoden

-            // wie Map / Filter / Reduce zur Verfügung stellt:

-            var bikes = new List<Bicycle>();

-            // sortiert die Liste

-            bikes.Sort();

-            // sortiert nach Anzahl Räder

-            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels));

-            var result = bikes

-                // diese Filter können auch aneinandergehängt werden

-                .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück)

-                .Where(b => b.IsBroken && b.HasTassles)

-                // diese Zuordnung gibt ein IQueryable<String> zurück

-                .Select(b => b.ToString());

-

-            // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert

-            var sum = bikes.Sum(b => b.Wheels);

-

-            // So erzeugt man ein implizit typisiertes Objekt, basierend auf

-            // den Parametern der Elemente:

-            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });

-            // Auch wenn wir es hier nicht demonstrieren können:

-            // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead,

-            // da der Compiler in der Lage ist, die passenden Typen zu erkennen.

-            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))

-            {

-                Console.WriteLine(bikeSummary.Name);

-            }

-

-            // AsParallel-Methode

-            // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert

-            // LINQ und parallele Operationen:

-            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);

-            // Diese Berechnung passiert parallel! Benötigte Threads werden

-            // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt.

-            // Ein Traum für die Verarbeitung von großen Datenmengen

-            // auf mehreren Cores!

-

-            // LINQ - bildet einen Datenspeicher auf IQueryable<T> Objekte ab

-            // LinqToSql beispielsweise speichert und liest aus einer

-            // SQL-Datenbank, LinqToXml aus einem XML-Dokument.

-            // LINQ-Operationen werden "lazy" ausgeführt.

-            var db = new BikeRepository();

-

-            // Die verzögerte Ausführung ist optimal für Datenbankabfragen

-            var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage

-            // Es können noch mehr Filter hinzugefügt werden (auch mit

-            // Bedingungen) - ideal für z.B. "erweiterte Suchen"

-            if (42 > 6)

-            {

-                filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage

-            }

-

-            var query = filter

-                .OrderBy(b => b.Wheels)

-                .ThenBy(b => b.Name)

-                .Select(b => b.Name); // auch hier: immer noch keine Abfrage

-

-            // Erst hier wird die Datenbankabfrage wirklich ausgeführt,

-            // limitiert auf die Elemente die der foreach-Loop verwendet

-            foreach (string bike in query)

-            {

-                Console.WriteLine(result);

-            }

-

-        }

-

-    } // Ende der Klasse LearnCSharp

-

-    // Eine .cs-Datei kann auch mehrere Klassen enthalten

-

-    public static class Extensions

-    {

-        // Erweiterungsmethoden

-        public static void Print(this object obj)

-        {

-            Console.WriteLine(obj.ToString());

-        }

-    }

-

-    // Syntax zur Deklaration einer Klasse:

-    // <public/private/protected/internal> class <class name>{

-    //    // Datenfelder, Konstruktoren und Methoden leben alle

-    //    // innerhalb dieser Deklaration

-    // }

-

-    public class Bicycle

-    {

-        // Felder/Variablen der Klasse "Bicycle"

-        // Das Keyword public macht das Member von überall zugänglich

-        public int Cadence

-        {

-            get // get definiert eine Methode um die Eigenschaft abzurufen

-            {

-                return _cadence;

-            }

-            set // set definiert eine Methode um die Eigenschaft zu setzen

-            {

-                _cadence = value; // value ist der dem Setter übergebene Wert

-            }

-        }

-        private int _cadence;

-

-        // Das Keyword protected macht das Member nur für die Klasse selbst

-        // und ihre Subklassen zugänglich

-        protected virtual int Gear

-        {

-            get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird

-            set;

-        }

-

-        // Das Keyword internal macht das Member innerhalb der Assembly zugänglich

-        internal int Wheels

-        {

-            get;

-            private set; // get/set kann auch über Keywords modifiziert werden

-        }

-

-        int _speed; // Member ohne vorangestellte Keywords sind standardmäßig

-                    // private, sie sind nur innerhalb der Klasse zugänglich.

-                    // Man kann aber natürlich auch das Keyword private benutzen.

-        private string Name { get; set; }

-

-        // Ein Enum ist ein klar definierter Satz an benannten Konstanten.

-        // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu

-        // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für

-        // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint,

-        // long, oder ulong. Alle Werte in einem Enum sind eindeutig.

-        public enum BikeBrand

-        {

-            Colnago,

-            EddyMerckx,

-            Bianchi = 42, // so kann man den Wert explizit setzen

-            Kynast // 43

-        }

-        // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist,

-        // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren

-

-        // Nachdem das Enum deklariert ist, können wir den Typen verwenden:

-        public BikeBrand Brand;

-

-        // Als static gekennzeichnete Member gehören dem Typ selbst,

-        // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem

-        // Objekt benutzen

-        // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!");

-        static public int BicyclesCreated = 0;

-

-        // readonly-Werte werden zur Laufzeit gesetzt

-        // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor

-        // festgelegt werden

-        readonly bool _hasCardsInSpokes = false; // readonly und private

-

-        // Konstruktoren bestimmen was bei einer Instantiierung passiert.

-        // Das ist ein Default-Konstruktor:

-        public Bicycle()

-        {

-            // Member der Klasse können über das Keyword this erreicht werden

-            this.Gear = 1;

-            // oft ist das aber gar nicht nötig

-            Cadence = 50;

-            _speed = 5;

-            Name = "Bonanzarad";

-            Brand = BikeBrand.Kynast;

-            BicyclesCreated++;

-        }

-

-        // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente):

-        public Bicycle(int startCadence, int startSpeed, int startGear,

-                       string name, bool hasCardsInSpokes, BikeBrand brand)

-            : base() // ruft zuerst den "base"-Konstruktor auf

-        {

-            Gear = startGear;

-            Cadence = startCadence;

-            _speed = startSpeed;

-            Name = name;

-            _hasCardsInSpokes = hasCardsInSpokes;

-            Brand = brand;

-        }

-

-        // Konstruktoren können aneinandergehängt werden:

-        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :

-            this(startCadence, startSpeed, 0, "richtig große Räder", true, brand)

-        {

-        }

-

-        // Syntax für Methoden:

-        // <public/private/protected> <return type> <function name>(<args>)

-

-        // Klassen können Getter und Setter für Werte definieren,

-        // oder diese Werte direkt als Eigenschaft implementieren

-        // (in C# der bevorzugte Weg)

-

-        // Parameter von Methoden können Default-Werte haben.

-        // "SpeedUp" kann man also auch ohne Parameter aufrufen:

-        public void SpeedUp(int increment = 1)

-        {

-            _speed += increment;

-        }

-

-        public void SlowDown(int decrement = 1)

-        {

-            _speed -= decrement;

-        }

-

-        // Eigenschaften mit get/set

-        // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu

-        // empfehlen. Diese können Getter und Setter haben, oder auch nur

-        // einen Getter bzw. einen Setter

-        private bool _hasTassles; // private Variable

-        public bool HasTassles // öffentliches Interface

-        {

-            get { return _hasTassles; }

-            set { _hasTassles = value; }

-        }

-

-        // Das kann man auch kürzer schreiben:

-        // Dieser Syntax erzeugt automatisch einen hinterlegten Wert,

-        // (entsprechend `private bool _isBroken`) der gesetzt

-        // bzw. zurückgegeben wird:

-        public bool IsBroken { get; private set; }

-        public int FrameSize

-        {

-            get;

-            // für Getter und Setter kann der Zugriff auch einzeln

-            // beschränkt werden, FrameSize kann also nur von innerhalb

-            // der Klasse "Bicycle" gesetzt werden

-            private set;

-        }

-

-        // Diese Methode gibt eine Reihe an Informationen über das Objekt aus:

-        public virtual string ToString()

-        {

-            return "Gang: " + Gear +

-                    " Kadenz: " + Cadence +

-                    " Geschwindigkeit: " + _speed +

-                    " Name: " + Name +

-                    " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") +

-                    "\n------------------------------\n"

-                    ;

-        }

-

-        // Auch Methoden können als static gekennzeichnet werden, nützlich

-        // beispielsweise für Helper-Methoden

-        public static bool DidWeCreateEnoughBicyclesYet()

-        {

-            // In einer statischen Methode können wir natürlich auch nur

-            // statische Member der Klasse referenzieren

-            return BicyclesCreated > 9000;

-        }

-        // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee

-        // sein die Klasse selbst als static zu kennzeichnen

-

-    } // Ende der Klasse "Bicycle"

-

-    // "PennyFarthing" ist eine Unterklasse von "Bicycle"

-    class PennyFarthing : Bicycle

-    {

-        // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder

-        // mit riesigem Vorderrad. Sie haben keine Gangschaltung.)

-

-        // hier wird einfach der Elternkonstruktor aufgerufen

-        public PennyFarthing(int startCadence, int startSpeed) :

-            base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx)

-        {

-        }

-

-        protected override int Gear

-        {

-            get

-            {

-                return 0;

-            }

-            set

-            {

-                throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!");

-            }

-        }

-

-        public override string ToString()

-        {

-            string result = "Hochrad ";

-            result += base.ToString(); // ruft die "base"-Version der Methode auf

-            return result;

-        }

-    }

-

-    // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen

-    // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung:

-    interface IJumpable

-    {

-        // Alle Member eines Interfaces sind implizit public

-        void Jump(int meters);

-    }

-

-    interface IBreakable

-    {

-        // Interfaces können Eigenschaften, Methoden und Events definieren

-        bool Broken { get; }

-    }

-

-    // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige

-    // Anzahl von Interfaces implementieren

-    class MountainBike : Bicycle, IJumpable, IBreakable

-    {

-        int damage = 0;

-

-        public void Jump(int meters)

-        {

-            damage += meters;

-        }

-

-        public bool Broken

-        {

-            get

-            {

-                return damage > 100;

-            }

-        }

-    }

-

-    // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her.

-    // EntityFramework Code First ist großartig

-    // (ähnlich zu Ruby's ActiveRecord, aber bidirektional)

-    // http://msdn.microsoft.com/de-de/data/jj193542.aspx

-    public class BikeRepository : DbSet

-    {

-        public BikeRepository()

-            : base()

-        {

-        }

-

-        public DbSet<Bicycle> Bikes { get; set; }

-    }

-} // Ende des Namespaces

-```

-

-## In dieser Übersicht nicht enthalten sind die Themen:

-

- * Flags

- * Attributes

- * Statische Eigenschaften

- * Exceptions, Abstraction

- * ASP.NET (Web Forms/MVC/WebMatrix)

- * Winforms

- * Windows Presentation Foundation (WPF)

-

-## Zum Weiterlesen gibt es viele gute Anlaufpunkte:

-

- * [DotNetPerls](http://www.dotnetperls.com)

- * [C# in Depth](http://manning.com/skeet2)

- * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)

- * [LINQ](http://shop.oreilly.com/product/9780596519254.do)

- * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)

- * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)

- * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/overview/exploring-webmatrix)

- * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)

- * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)

-

-[C# Coding Conventions](http://msdn.microsoft.com/de-de/library/vstudio/ff926074.aspx)

+---
+language: C#
+contributors:
+    - ["Irfan Charania", "https://github.com/irfancharania"]
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Melvyn Laïly", "http://x2a.yt"]
+    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+translators:
+    - ["Frederik Ring", "https://github.com/m90"]
+filename: LearnCSharp-de.cs
+lang: de-de
+---
+C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden.
+
+[Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Einzeilige Kommentare starten mit zwei Schrägstrichen: //
+/*
+Mehrzeile Kommentare wie in C Schrägstrich / Stern
+*/
+/// <summary>
+/// XML-Kommentare können zur automatisierten Dokumentation verwendet werden
+/// </summary>
+
+// Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// definiert einen Namespace um Code in "packages" zu organisieren
+namespace Learning
+{
+    // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei
+    // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu
+    // handhaben führt aber unweigerlich ins Chaos (wirklich)!
+    public class LearnCSharp
+    {
+        // Zuerst erklärt dieses Tutorial die Syntax-Grundlagen,
+        // wenn du bereits Java oder C++ programmieren kannst:
+        // lies bei "Interessante Features" weiter!
+        public static void Syntax()
+        {
+            // Mit Console.WriteLine kannst du einfachen Text ausgeben:
+            Console.WriteLine("Hallo Welt");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+            // Console.Write erzeugt keinen Zeilenumbruch
+            Console.Write("Hallo ");
+            Console.Write("Welt");
+
+            ///////////////////////////////////////////////////
+            // Typen & Variablen
+            ///////////////////////////////////////////////////
+
+            // Deklariere eine Variable mit <Typ> <Name>
+
+            // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Vorzeichenlose 8-Bit Ganzzahl
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - 16-Bit Ganzzahl
+            // Vorzeichenbehaftet - (-32,768 <= short <= 32,767)
+            // Vorzeichenlos - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Integer - 32-bit Ganzzahl
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - 64-bit Ganzzahl
+            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+            // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder
+            // uint behandelt. Ein nachgestelltes L markiert den Wert als long
+            // oder ulong.
+
+            // Double - Double-precision 64-bit IEEE 754 Fließkommazahl
+            double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen
+
+            // Float - Single-precision 32-bit IEEE 754 Fließkommazahl
+            float fooFloat = 234.5f; // Genauigkeit: 7 Stellen
+            // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ
+            // float handelt
+
+            // Decimal - ein 128-Bit-Datentyp mit größerer Genauigkeit als
+            // andere Fließkommatypen, und somit bestens geeignet für
+            // die Berechnung von Geld- und Finanzwerten
+            decimal fooDecimal = 150.3m;
+
+            // Boolean - true & false
+            bool fooBoolean = true; // oder false
+
+            // Char - Ein einzelnes 16-Bit Unicode Zeichen
+            char fooChar = 'A';
+
+            // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die
+            // alle Werttypen sind, ist String ein Referenztyp. Strings sind
+            // somit nullable, Werttypen sind dies nicht.
+            string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu";
+            Console.WriteLine(fooString);
+
+            // Jeder Buchstabe eines Strings kann über seinen Index
+            // referenziert werden:
+            char charFromString = fooString[1]; // => 'e'
+            // Strings sind unveränderlich:
+            // `fooString[1] = 'X';` funktioniert nicht
+
+            // Ein Vergleich zweier Strings, unter Berücksichtigung der
+            // aktuellen, sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c
+            // in deutschsprachigen Umgebungen), und ohne Beachtung von
+            // Groß- und Kleinschreibung:
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // Formatierung, genau wie "sprintf"
+            string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Datumsangaben und Formatierung
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String
+            // schreiben. Um " zu maskieren benutzt man ""
+            string bazString = @"Hier geht es
+zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";
+
+            // Die Keywords const oder readonly kennzeichnen eine
+            // unveränderliche Variable/Konstante. Die Werte von Konstanten
+            // werden übrigens bereits zur Compile-Zeit berechnet.
+            const int HOURS_I_WORK_PER_WEEK = 9001;
+
+            ///////////////////////////////////////////////////
+            // Datenstrukturen
+            ///////////////////////////////////////////////////
+
+            // Arrays - Index beginnt bei Null
+            // Die Größe des Arrays wird bei der Deklaration festgelegt.
+            // Die syntaktische Struktur um ein neues Array zu erzeugen sieht
+            // folgendermaßen aus:
+            // <datatype>[] <varname> = new <datatype>[<array size>];
+            int[] intArray = new int[10];
+
+            // Arrays können auch über ein Array-Literal deklariert werden:
+            int[] y = { 9000, 1000, 1337 };
+
+            // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+            // Arrays sind veränderbar
+            intArray[1] = 1;
+
+            // Listen
+            // Durch ihre größere Flexibilität kommen Listen in C# weit
+            // häufiger zum Einsatz als Arrays. Eine Liste wird so deklariert:
+            // List<datatype> <varname> = new List<datatype>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 };
+            // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen"
+
+            // Listen haben keinen Default-Wert.
+            // Bevor auf einen Index zugegriffen werden kann, muss dieser
+            // auch gesetzt worden sein:
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+            // Andere interessante Datenstrukturen sind:
+            // Stack/Queue
+            // Dictionary (entspricht einer Hash Map)
+            // HashSet
+            // Read-only Collections
+            // Tuple (.Net 4+)
+
+            ///////////////////////////////////////
+            // Operatoren
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operatoren");
+
+            // kurze Schreibweise um mehrere Deklarationen zusammenzufassen:
+            // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!)
+            int i1 = 1, i2 = 2;
+
+            // Arithmetik funktioniert wie erwartet:
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Modulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Vergleiche
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+            // Bitweise Operatoren
+            /*
+            ~       Unäres bitweises NICHT
+            <<      Verschieben nach links
+            >>      Verschieben nach rechts
+            &       Bitweises UND
+            ^       Bitweises exklusives ODER
+            |       Bitweises inklusives ODER
+            */
+
+            // Inkremente
+            int i = 0;
+            Console.WriteLine("\n->Inkrement / Dekrement");
+            Console.WriteLine(i++); //i = 1. Post-Inkrement
+            Console.WriteLine(++i); //i = 2. Pre-Inkrement
+            Console.WriteLine(i--); //i = 1. Post-Dekrement
+            Console.WriteLine(--i); //i = 0. Pre-Dekrement
+
+            ///////////////////////////////////////
+            // Kontrollstrukturen
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Kontrollstrukturen");
+
+            // If-Statements funktionieren wie in C
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("Ich werde ausgegeben");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("Ich nicht");
+            }
+            else
+            {
+                Console.WriteLine("Ich leider auch nicht");
+            }
+
+            // Ternärer Operator
+            // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben:
+            // <condition> ? <true> : <false>
+            int zumVergleich = 17;
+            string isTrue = zumVergleich == 17 ? "Ja" : "Nein";
+
+            // while-Schleife
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                // Wird 100mal wiederholt, fooWhile 0->99
+                fooWhile++;
+            }
+
+            // do-while-Schleife
+            int fooDoWhile = 0;
+            do
+            {
+                // Wird 100mal wiederholt, fooDoWhile 0->99
+                fooDoWhile++;
+            } while (fooDoWhile < 100);
+
+            //for-Schleifen => for(<start_statement>; <conditional>; <step>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                // Wird 10mal wiederholt, fooFor 0->9
+            }
+
+            // foreach-Schleife
+            // Die normale Syntax für eine foreach-Schleife lautet:
+            // foreach(<iteratorType> <iteratorName> in <enumerable>)
+            // foreach kann mit jedem Objekt verwendet werden das IEnumerable
+            // oder IEnumerable<T> implementiert. Alle Auflistungs-Typen
+            // (Array, List, Dictionary...) im .NET Framework implementieren
+            // eines dieser beiden Interfaces.
+
+            foreach (char character in "Hallo Welt".ToCharArray())
+            {
+                // Ein Durchgang für jedes Zeichen im String
+            }
+            // (ToCharArray() könnte man hier übrigens auch weglassen,
+            // da String IEnumerable bereits implementiert)
+
+            // Switch Struktur
+            // Ein Switch funktioniert mit byte, short, char und int Datentypen.
+            // Auch Aufzählungstypen können verwendet werden, genau wie
+            // die Klasse String, und ein paar Sonderklassen, die Wrapper für
+            // Primitives sind: Character, Byte, Short und Integer
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "Januar";
+                    break;
+                case 2:
+                    monthString = "Februar";
+                    break;
+                case 3:
+                    monthString = "März";
+                    break;
+                // Man kann für mehrere Fälle auch das selbe Verhalten
+                // definieren. Jeder Block muss aber mit einem break-Statement
+                // abgeschlossen werden. Einzelne Fälle können über
+                // `goto case x` erreicht werden
+                case 6:
+                case 7:
+                case 8:
+                    monthString = "Sommer!!";
+                    break;
+                default:
+                    monthString = "Irgendein anderer Monat";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Umwandlung von Datentypen und Typecasting
+            ///////////////////////////////////////
+
+            // Umwandlung
+
+            // von String nach Integer
+            // bei einem Fehler wirft diese Code eine Exception
+            int.Parse("123"); //gibt die Ganzzahl 123 zurück
+
+            // TryParse gibt bei einem Fehler den Default-Wert zurück
+            // (im Fall von int: 0)
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // gibt true oder false zurück
+            {
+                Console.WriteLine(tryInt);       // 123
+            }
+
+            // von Integer nach String
+            // Die Klasse Convert stellt Methoden zur Konvertierung von
+            // unterschiedlichsten Daten zur Verfügung:
+            Convert.ToString(123); // "123"
+            // oder
+            tryInt.ToString(); // "123"
+        }
+
+        ///////////////////////////////////////
+        // Klassen
+        ///////////////////////////////////////
+        public static void Classes()
+        {
+
+            // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen
+            Bicycle trek = new Bicycle();
+
+            // So werden Methoden der Instanz aufgerufen
+            trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen
+            trek.Cadence = 100;
+
+            // ToString ist eine Konvention über die man üblicherweiser
+            // Informationen über eine Instanz erhält
+            Console.WriteLine("Infos zu trek: " + trek.ToString());
+
+            // Wir instantiieren ein neues Hochrad
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("Infos zu funbike: " + funbike.ToString());
+
+            Console.Read();
+        } // Ende der Methode main
+
+        // Main als Konsolenstartpunkt
+        // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        ///////////////////////////////////////
+        // Interessante Features
+        ///////////////////////////////////////
+
+        // Methodensignaturen
+
+        public // Sichtbarkeit
+        static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz)
+        int // Typ des Rückgabewerts,
+        MethodSignatures(
+            // Erstes Argument, erwartet int
+            int maxCount,
+            // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird
+            int count = 0,
+            int another = 3,
+            // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats)
+            params string[] otherParams
+        )
+        {
+            return -1;
+        }
+
+        // Methoden können überladen werden, solange sie eindeutige
+        // Signaturen haben
+        public static void MethodSignatures(string maxCount)
+        {
+        }
+
+        // Generische Typen
+        // Die Typen für TKey und TValue werden erst beim Aufruf der Methode
+        // festgelegt. Diese Methode emuliert z.B. SetDefault aus Python:
+        public static TValue SetDefault<TKey, TValue>(
+            IDictionary<TKey, TValue> dictionary,
+            TKey key,
+            TValue defaultItem)
+        {
+            TValue result;
+            if (!dictionary.TryGetValue(key, out result))
+            {
+                return dictionary[key] = defaultItem;
+            }
+            return result;
+        }
+
+        // Möglichen Typen lassen sich auch über ihr Interface beschränken:
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // Da T ein IEnumerable ist können wir foreach benutzen
+            foreach (var item in toPrint)
+            {
+                // Item ist ein int
+                Console.WriteLine(item.ToString());
+            }
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // Optionale Parameter
+            MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings");
+            // setzt explizit einen bestimmten Parameter, andere werden übersprungen
+            MethodSignatures(3, another: 3);
+
+            // Erweiterungsmethoden
+            int i = 3;
+            i.Print(); // Weiter unten definiert
+
+            // Nullables - perfekt für die Interaktion mit
+            // Datenbanken / Rückgabewerten
+            // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?
+            // nullable gemacht werden: <type>? <varname> = <value>
+            int? nullable = null; // Die explizite Langform wäre Nullable<int>
+            Console.WriteLine("Mein Nullable: " + nullable);
+            bool hasValue = nullable.HasValue; // true wenn nicht null
+
+            // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall
+            // dass die Variable null ist festzulegen.
+            int notNullable = nullable ?? 0; // 0
+
+            // Implizit typisierte Variablen
+            // Man kann auch den Typ einer Variable auch vom Compiler
+            // bestimmen lassen:
+            var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren";
+            magic = 9; // funktioniert nicht da magic vom Typ String ist
+
+            // Generics
+            var phonebook = new Dictionary<string, string>() {
+                {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu
+            };
+
+            // Hier könnte man auch unser generisches SetDefault von
+            // weiter oben benutzen:
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Xaver", "kein Telefon")); // kein Telefon
+            // TKey und TValue müssen nicht zwingend angegeben werden, da sie
+            // auch implizit vom Compiler ermittelt werden können
+            Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67
+
+            // Lambdas - konzise Syntax für Inline-Funktionen
+            Func<int, int> square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert
+            Console.WriteLine(square(3)); // 9
+
+            // Disposables - einfaches Management von nicht verwalteten Ressourcen
+            // So gut wie alle Objekte die auf nicht verwaltete Ressourcen
+            // (Dateien, Geräte, ...) zugreifen, implementieren das Interface
+            // IDisposable. Das using Statement stellt sicher dass die vom
+            // IDisposable benutzten Ressourcen nach der Benutzung wieder
+            // freigegeben werden:
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Alles bestens!");
+                // Am Ende des Codeblocks werden die Ressourcen wieder
+                // freigegeben - auch im Falle einer Exception
+            }
+
+            // Parallel Klasse
+            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+            var websites = new string[] {
+                "http://www.google.com", "http://www.reddit.com",
+                "http://www.shaunmccarthy.com"
+            };
+            var responses = new Dictionary<string, string>();
+
+            // Für jeden Request wird ein neuer Thread erzeugt, der nächste
+            // Schritt wird erst nach Beendigung aller Tasks ausgeführt
+            Parallel.ForEach(websites,
+                // maximal 3 Threads gleichzeitig
+                new ParallelOptions() {MaxDegreeOfParallelism = 3},
+                website =>
+            {
+                // Hier folgt eine langwierige, asynchrone Operation
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // Dieser Code wird erst nach Beendigung aller Requests ausgeführt
+            foreach (var key in responses.Keys)
+            {
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+            }
+
+            // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten)
+            dynamic student = new ExpandoObject();
+            // hier muss keine Typ angegeben werden
+            student.FirstName = "Christian";
+
+            // Einem solchen Objekt kann man sogar Methoden zuordnen.
+            // Das Beispiel gibt einen String zurück und erwartet einen String
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Bettina"));
+
+            // IQueryable<T> - So gut wie alle Aufzählungstypen implementieren
+            // dieses Interface, welches eine Vielzahl von funktionalen Methoden
+            // wie Map / Filter / Reduce zur Verfügung stellt:
+            var bikes = new List<Bicycle>();
+            // sortiert die Liste
+            bikes.Sort();
+            // sortiert nach Anzahl Räder
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels));
+            var result = bikes
+                // diese Filter können auch aneinandergehängt werden
+                .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück)
+                .Where(b => b.IsBroken && b.HasTassles)
+                // diese Zuordnung gibt ein IQueryable<String> zurück
+                .Select(b => b.ToString());
+
+            // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert
+            var sum = bikes.Sum(b => b.Wheels);
+
+            // So erzeugt man ein implizit typisiertes Objekt, basierend auf
+            // den Parametern der Elemente:
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Auch wenn wir es hier nicht demonstrieren können:
+            // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead,
+            // da der Compiler in der Lage ist, die passenden Typen zu erkennen.
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+            {
+                Console.WriteLine(bikeSummary.Name);
+            }
+
+            // AsParallel-Methode
+            // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert
+            // LINQ und parallele Operationen:
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // Diese Berechnung passiert parallel! Benötigte Threads werden
+            // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt.
+            // Ein Traum für die Verarbeitung von großen Datenmengen
+            // auf mehreren Cores!
+
+            // LINQ - bildet einen Datenspeicher auf IQueryable<T> Objekte ab
+            // LinqToSql beispielsweise speichert und liest aus einer
+            // SQL-Datenbank, LinqToXml aus einem XML-Dokument.
+            // LINQ-Operationen werden "lazy" ausgeführt.
+            var db = new BikeRepository();
+
+            // Die verzögerte Ausführung ist optimal für Datenbankabfragen
+            var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage
+            // Es können noch mehr Filter hinzugefügt werden (auch mit
+            // Bedingungen) - ideal für z.B. "erweiterte Suchen"
+            if (42 > 6)
+            {
+                filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage
+            }
+
+            var query = filter
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // auch hier: immer noch keine Abfrage
+
+            // Erst hier wird die Datenbankabfrage wirklich ausgeführt,
+            // limitiert auf die Elemente die der foreach-Loop verwendet
+            foreach (string bike in query)
+            {
+                Console.WriteLine(result);
+            }
+
+        }
+
+    } // Ende der Klasse LearnCSharp
+
+    // Eine .cs-Datei kann auch mehrere Klassen enthalten
+
+    public static class Extensions
+    {
+        // Erweiterungsmethoden
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Syntax zur Deklaration einer Klasse:
+    // <public/private/protected/internal> class <class name>{
+    //    // Datenfelder, Konstruktoren und Methoden leben alle
+    //    // innerhalb dieser Deklaration
+    // }
+
+    public class Bicycle
+    {
+        // Felder/Variablen der Klasse "Bicycle"
+        // Das Keyword public macht das Member von überall zugänglich
+        public int Cadence
+        {
+            get // get definiert eine Methode um die Eigenschaft abzurufen
+            {
+                return _cadence;
+            }
+            set // set definiert eine Methode um die Eigenschaft zu setzen
+            {
+                _cadence = value; // value ist der dem Setter übergebene Wert
+            }
+        }
+        private int _cadence;
+
+        // Das Keyword protected macht das Member nur für die Klasse selbst
+        // und ihre Subklassen zugänglich
+        protected virtual int Gear
+        {
+            get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird
+            set;
+        }
+
+        // Das Keyword internal macht das Member innerhalb der Assembly zugänglich
+        internal int Wheels
+        {
+            get;
+            private set; // get/set kann auch über Keywords modifiziert werden
+        }
+
+        int _speed; // Member ohne vorangestellte Keywords sind standardmäßig
+                    // private, sie sind nur innerhalb der Klasse zugänglich.
+                    // Man kann aber natürlich auch das Keyword private benutzen.
+        private string Name { get; set; }
+
+        // Ein Enum ist ein klar definierter Satz an benannten Konstanten.
+        // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu
+        // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für
+        // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint,
+        // long, oder ulong. Alle Werte in einem Enum sind eindeutig.
+        public enum BikeBrand
+        {
+            Colnago,
+            EddyMerckx,
+            Bianchi = 42, // so kann man den Wert explizit setzen
+            Kynast // 43
+        }
+        // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist,
+        // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren
+
+        // Nachdem das Enum deklariert ist, können wir den Typen verwenden:
+        public BikeBrand Brand;
+
+        // Als static gekennzeichnete Member gehören dem Typ selbst,
+        // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem
+        // Objekt benutzen
+        // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!");
+        static public int BicyclesCreated = 0;
+
+        // readonly-Werte werden zur Laufzeit gesetzt
+        // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor
+        // festgelegt werden
+        readonly bool _hasCardsInSpokes = false; // readonly und private
+
+        // Konstruktoren bestimmen was bei einer Instantiierung passiert.
+        // Das ist ein Default-Konstruktor:
+        public Bicycle()
+        {
+            // Member der Klasse können über das Keyword this erreicht werden
+            this.Gear = 1;
+            // oft ist das aber gar nicht nötig
+            Cadence = 50;
+            _speed = 5;
+            Name = "Bonanzarad";
+            Brand = BikeBrand.Kynast;
+            BicyclesCreated++;
+        }
+
+        // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente):
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand)
+            : base() // ruft zuerst den "base"-Konstruktor auf
+        {
+            Gear = startGear;
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name;
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Konstruktoren können aneinandergehängt werden:
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "richtig große Räder", true, brand)
+        {
+        }
+
+        // Syntax für Methoden:
+        // <public/private/protected> <return type> <function name>(<args>)
+
+        // Klassen können Getter und Setter für Werte definieren,
+        // oder diese Werte direkt als Eigenschaft implementieren
+        // (in C# der bevorzugte Weg)
+
+        // Parameter von Methoden können Default-Werte haben.
+        // "SpeedUp" kann man also auch ohne Parameter aufrufen:
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // Eigenschaften mit get/set
+        // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu
+        // empfehlen. Diese können Getter und Setter haben, oder auch nur
+        // einen Getter bzw. einen Setter
+        private bool _hasTassles; // private Variable
+        public bool HasTassles // öffentliches Interface
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // Das kann man auch kürzer schreiben:
+        // Dieser Syntax erzeugt automatisch einen hinterlegten Wert,
+        // (entsprechend `private bool _isBroken`) der gesetzt
+        // bzw. zurückgegeben wird:
+        public bool IsBroken { get; private set; }
+        public int FrameSize
+        {
+            get;
+            // für Getter und Setter kann der Zugriff auch einzeln
+            // beschränkt werden, FrameSize kann also nur von innerhalb
+            // der Klasse "Bicycle" gesetzt werden
+            private set;
+        }
+
+        // Diese Methode gibt eine Reihe an Informationen über das Objekt aus:
+        public virtual string ToString()
+        {
+            return "Gang: " + Gear +
+                    " Kadenz: " + Cadence +
+                    " Geschwindigkeit: " + _speed +
+                    " Name: " + Name +
+                    " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Auch Methoden können als static gekennzeichnet werden, nützlich
+        // beispielsweise für Helper-Methoden
+        public static bool DidWeCreateEnoughBicyclesYet()
+        {
+            // In einer statischen Methode können wir natürlich auch nur
+            // statische Member der Klasse referenzieren
+            return BicyclesCreated > 9000;
+        }
+        // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee
+        // sein die Klasse selbst als static zu kennzeichnen
+
+    } // Ende der Klasse "Bicycle"
+
+    // "PennyFarthing" ist eine Unterklasse von "Bicycle"
+    class PennyFarthing : Bicycle
+    {
+        // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder
+        // mit riesigem Vorderrad. Sie haben keine Gangschaltung.)
+
+        // hier wird einfach der Elternkonstruktor aufgerufen
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!");
+            }
+        }
+
+        public override string ToString()
+        {
+            string result = "Hochrad ";
+            result += base.ToString(); // ruft die "base"-Version der Methode auf
+            return result;
+        }
+    }
+
+    // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen
+    // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung:
+    interface IJumpable
+    {
+        // Alle Member eines Interfaces sind implizit public
+        void Jump(int meters);
+    }
+
+    interface IBreakable
+    {
+        // Interfaces können Eigenschaften, Methoden und Events definieren
+        bool Broken { get; }
+    }
+
+    // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige
+    // Anzahl von Interfaces implementieren
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her.
+    // EntityFramework Code First ist großartig
+    // (ähnlich zu Ruby's ActiveRecord, aber bidirektional)
+    // http://msdn.microsoft.com/de-de/data/jj193542.aspx
+    public class BikeRepository : DbSet
+    {
+        public BikeRepository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // Ende des Namespaces
+```
+
+## In dieser Übersicht nicht enthalten sind die Themen:
+
+ * Flags
+ * Attributes
+ * Statische Eigenschaften
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Zum Weiterlesen gibt es viele gute Anlaufpunkte:
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/overview/exploring-webmatrix)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+[C# Coding Conventions](http://msdn.microsoft.com/de-de/library/vstudio/ff926074.aspx)
diff --git a/de-de/elixir-de.html.markdown b/de-de/elixir-de.html.markdown
index ec933696..4acb8e23 100644
--- a/de-de/elixir-de.html.markdown
+++ b/de-de/elixir-de.html.markdown
@@ -1,423 +1,423 @@
----

-language: Elixir

-contributors:

-    - ["Joao Marques", "http://github.com/mrshankly"]

-translators:

-    - ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]

-filename: learnelixir-de.ex

-lang: de-de

----

-

-Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll 

-kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt 

-viele Features mit. 

-

-```ruby

-

-# Einzeilige Kommentare werden mit der Raute gesetzt.

-

-# Es gibt keine mehrzeiligen Kommentare;

-# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander 

-# zu setzen (so wie hier).

-

-# Mit 'iex' ruft man die Elixir-Shell auf.

-# Zum kompilieren von Modulen dient der Befehl 'elixirc'.

-

-# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt

-# installiert wurde.

-

-## ---------------------------

-## -- Basistypen

-## ---------------------------

-

-# Es gibt Nummern:

-3    # Integer

-0x1F # Integer

-3.0  # Float

-

-# Für bessere Lesbarkeit des Codes können Unterstriche "_" als Trennzeichen verwendet werden

-1_000_000 == 1000000  # Integer

-1_000.567 == 1000.567 # Float

-

-# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem 

-# ':'.

-:hello # Atom

-

-# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.

-{1,2,3} # Tupel

-

-# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen

-# werden:

-elem({1, 2, 3}, 0) # => 1

-

-# Listen sind als verkettete Listen implementiert.

-[1, 2, 3] # list

-

-# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:

-[ kopf | rest ] = [1,2,3]

-kopf # => 1

-rest # => [2, 3]

-

-# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'

-# (Musterabgleich) und keine Zuweisung.

-# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.

-# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen

-# werden.

-

-# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht 

-# zusammenpassen. 

-# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an

-# Elementen:

-{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}

-

-# Es gibt außerdem 'binaries', 

-<<1,2,3>> # binary.

-

-# Strings und 'char lists'

-"hello" # String

-'hello' # Char-Liste

-

-# ... und mehrzeilige Strings

-"""

-Ich bin ein 

-mehrzeiliger String.

-"""

-#=> "Ich bin ein\nmehrzeiliger String.\n"

-

-# Alles Strings werden in UTF-8 enkodiert:

-"héllò" #=> "héllò"

-

-# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach

-# Listen.

-<<?a, ?b, ?c>> #=> "abc"

-[?a, ?b, ?c]   #=> 'abc'

-

-# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.

-?a #=> 97

-

-# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'

-[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]

-'hello ' ++ 'world'  #=> 'hello world'

-

-<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>

-"hello " <> "world"  #=> "hello world"

-

-## ---------------------------

-## -- Operatoren

-## ---------------------------

-

-# Einfache Arithmetik

-1 + 1  #=> 2

-10 - 5 #=> 5

-5 * 2  #=> 10

-10 / 2 #=> 5.0

-

-# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.

-

-# Für Division mit ganzzahligen Ergebnis gibt es 'div'

-div(10, 2) #=> 5

-

-# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'

-rem(10, 3) #=> 1

-

-# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese

-# Operatoren erwarten einen Boolean als erstes Argument. 

-true and true #=> true

-false or true #=> true

-# 1 and true    #=> ** (ArgumentError) argument error

-

-# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs 

-# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.

-1 || true  #=> 1

-false && 1 #=> false

-nil && 20  #=> nil

-

-!true #=> false

-

-# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,

-# `<` und `>` 

-1 == 1 #=> true

-1 != 1 #=> false

-1 < 2  #=> true

-

-# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:

-1 == 1.0  #=> true

-1 === 1.0 #=> false

-

-# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:

-1 < :hello #=> true

-

-# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:

-# number < atom < reference < functions < port < pid < tuple < list < bitstring

-

-# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a

-# total ordering is well defined is important." 

-

-## ---------------------------

-## -- Kontrollstrukturen

-## ---------------------------

-

-# Es gibt die `if`-Verzweigung

-if false do

-  "Dies wird nie jemand sehen..."

-else

-  "...aber dies!"

-end

-

-# ...und ebenso `unless`

-unless true do

-  "Dies wird nie jemand sehen..."

-else

-  "...aber dies!"

-end

-

-# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir

-# arbeiten damit.

-

-# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.

-case {:one, :two} do

-  {:four, :five} ->

-    "Das wird nicht passen"

-  {:one, x} ->

-    "Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."

-  _ ->

-    "Dieser Fall greift immer."

-end

-

-# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert

-# nicht weiter verwendet wird.

-# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:

-[kopf | _] = [1,2,3]

-kopf #=> 1

-

-# Für bessere Lesbarkeit können wir auch das Folgende machen:

-[kopf | _rest] = [:a, :b, :c]

-kopf #=> :a

-

-# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man

-# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.

-cond do

-  1 + 1 == 3 ->

-    "Ich werde nie aufgerufen."

-  2 * 5 == 12 ->

-    "Ich auch nicht."

-  1 + 2 == 3 ->

-    "Aber ich!"

-end

-

-# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert. 

-cond do

-  1 + 1 == 3 ->

-    "Ich werde nie aufgerufen."

-  2 * 5 == 12 ->

-    "Ich auch nicht."

-  true ->

-    "Aber ich! (dies ist im Grunde ein 'else')"

-end

-

-# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.

-# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,

-# egal ob zuvor ein Wert gefangen wurde.

-try do

-  throw(:hello)

-catch

-  nachricht -> "#{nachricht} gefangen."

-after

-  IO.puts("Ich bin die 'after'-Klausel.")

-end

-#=> Ich bin die 'after'-Klausel.

-# ":hello gefangen"

-

-## ---------------------------

-## -- Module und Funktionen

-## ---------------------------

-

-# Anonyme Funktionen (man beachte den Punkt)

-square = fn(x) -> x * x end

-square.(5) #=> 25

-

-# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben

-# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'

-# eingeführt:

-f = fn

-  x, y when x > 0 -> x + y

-  x, y -> x * y

-end

-

-f.(1, 3)  #=> 4

-f.(-1, 3) #=> -3

-

-# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen

-# Geltungsbereich ('scope') verfügbar.

-is_number(10)    #=> true

-is_list("hello") #=> false

-elem({1,2,3}, 0) #=> 1

-

-# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines

-# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu

-# definieren.

-defmodule Math do

-  def sum(a, b) do

-    a + b

-  end

-

-  def square(x) do

-    x * x

-  end

-end

-

-Math.sum(1, 2)  #=> 3

-Math.square(3) #=> 9

-

-# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'

-# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen

-# werden: elixirc math.ex

-

-# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine

-# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen

-# werden; eine private Funktion kann nur lokal angesprochen werden.

-defmodule PrivateMath do

-  def sum(a, b) do

-    do_sum(a, b)

-  end

-

-  defp do_sum(a, b) do

-    a + b

-  end

-end

-

-PrivateMath.sum(1, 2)    #=> 3

-# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)

-

-# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:

-defmodule Geometry do

-  def area({:rectangle, w, h}) do

-    w * h

-  end

-

-  def area({:circle, r}) when is_number(r) do

-    3.14 * r * r

-  end

-end

-

-Geometry.area({:rectangle, 2, 3}) #=> 6

-Geometry.area({:circle, 3})       #=> 28.25999999999999801048

-# Geometry.area({:circle, "not_a_number"})

-#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1

-

-# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger

-# Bestandteil von Elixir.

-defmodule Recursion do

-  def sum_list([head | tail], acc) do

-    sum_list(tail, acc + head)

-  end

-

-  def sum_list([], acc) do

-    acc

-  end

-end

-

-Recursion.sum_list([1,2,3], 0) #=> 6

-

-# Elixir-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso

-# ist es möglich eigene Attribute hinzuzufügen.

-defmodule MyMod do

-  @moduledoc """

-  Dies ist ein eingebautes Attribut in einem Beispiel-Modul

-  """

-

-  @my_data 100 # Dies ist ein selbst-definiertes Attribut.

-  IO.inspect(@my_data) #=> 100

-end

-

-## ---------------------------

-## -- 'Records' und Ausnahmebehandlung

-## ---------------------------

-

-# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen

-# Namen zuzuweisen.

-defrecord Person, name: nil, age: 0, height: 0

-

-joe_info = Person.new(name: "Joe", age: 30, height: 180)

-#=> Person[name: "Joe", age: 30, height: 180]

-

-# Zugriff auf den Wert von 'name'

-joe_info.name #=> "Joe"

-

-# Den Wert von 'age' überschreiben

-joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]

-

-# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,

-# um Ausnahmen beziehungsweise Fehler zu behandeln. 

-try do

-  raise "Irgendein Fehler."

-rescue

-  RuntimeError -> "Laufzeit-Fehler gefangen."

-  _error -> "Und dies fängt jeden Fehler."

-end

-

-# Alle Ausnahmen haben das Attribut 'message'

-try do

-  raise "ein Fehler"

-rescue

-  x in [RuntimeError] ->

-    x.message

-end

-

-## ---------------------------

-## -- Nebenläufigkeit

-## ---------------------------

-

-# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles

-# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei

-# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen. 

-

-# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die

-# wiederum eine Funktion als Argument entgegen nimmt.

-f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>

-spawn(f) #=> #PID<0.40.0>

-

-# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann

-# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um 

-# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir

-# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem 

-# 'receive'-Mechanismus sichergestellt:

-defmodule Geometry do

-  def area_loop do

-    receive do

-      {:rectangle, w, h} ->

-        IO.puts("Area = #{w * h}")

-        area_loop()

-      {:circle, r} ->

-        IO.puts("Area = #{3.14 * r * r}")

-        area_loop()

-    end

-  end

-end

-

-# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion

-# in der Shell mit, etwa so:

-pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>

-

-# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck

-# erfüllt:

-pid <- {:rectangle, 2, 3}

-#=> Area = 6

-#   {:rectangle,2,3}

-

-pid <- {:circle, 2}

-#=> Area = 12.56000000000000049738

-#   {:circle,2}

-

-# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man

-# die aktuelle pid herausfinden.

-self() #=> #PID<0.27.0>

-

-```

-

-## Referenzen und weitere Lektüre

-

-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)

-* [Elixir Documentation](http://elixir-lang.org/docs/master/)

-* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert

-* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong

+---
+language: Elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+translators:
+    - ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]
+filename: learnelixir-de.ex
+lang: de-de
+---
+
+Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll 
+kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt 
+viele Features mit. 
+
+```ruby
+
+# Einzeilige Kommentare werden mit der Raute gesetzt.
+
+# Es gibt keine mehrzeiligen Kommentare;
+# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander 
+# zu setzen (so wie hier).
+
+# Mit 'iex' ruft man die Elixir-Shell auf.
+# Zum kompilieren von Modulen dient der Befehl 'elixirc'.
+
+# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt
+# installiert wurde.
+
+## ---------------------------
+## -- Basistypen
+## ---------------------------
+
+# Es gibt Nummern:
+3    # Integer
+0x1F # Integer
+3.0  # Float
+
+# Für bessere Lesbarkeit des Codes können Unterstriche "_" als Trennzeichen verwendet werden
+1_000_000 == 1000000  # Integer
+1_000.567 == 1000.567 # Float
+
+# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem 
+# ':'.
+:hello # Atom
+
+# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.
+{1,2,3} # Tupel
+
+# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen
+# werden:
+elem({1, 2, 3}, 0) # => 1
+
+# Listen sind als verkettete Listen implementiert.
+[1, 2, 3] # list
+
+# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:
+[ kopf | rest ] = [1,2,3]
+kopf # => 1
+rest # => [2, 3]
+
+# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'
+# (Musterabgleich) und keine Zuweisung.
+# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.
+# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen
+# werden.
+
+# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht 
+# zusammenpassen. 
+# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an
+# Elementen:
+{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Es gibt außerdem 'binaries', 
+<<1,2,3>> # binary.
+
+# Strings und 'char lists'
+"hello" # String
+'hello' # Char-Liste
+
+# ... und mehrzeilige Strings
+"""
+Ich bin ein 
+mehrzeiliger String.
+"""
+#=> "Ich bin ein\nmehrzeiliger String.\n"
+
+# Alles Strings werden in UTF-8 enkodiert:
+"héllò" #=> "héllò"
+
+# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach
+# Listen.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.
+?a #=> 97
+
+# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+## ---------------------------
+## -- Operatoren
+## ---------------------------
+
+# Einfache Arithmetik
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.
+
+# Für Division mit ganzzahligen Ergebnis gibt es 'div'
+div(10, 2) #=> 5
+
+# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'
+rem(10, 3) #=> 1
+
+# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese
+# Operatoren erwarten einen Boolean als erstes Argument. 
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs 
+# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+
+!true #=> false
+
+# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,
+# `<` und `>` 
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:
+1 < :hello #=> true
+
+# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:
+# number < atom < reference < functions < port < pid < tuple < list < bitstring
+
+# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a
+# total ordering is well defined is important." 
+
+## ---------------------------
+## -- Kontrollstrukturen
+## ---------------------------
+
+# Es gibt die `if`-Verzweigung
+if false do
+  "Dies wird nie jemand sehen..."
+else
+  "...aber dies!"
+end
+
+# ...und ebenso `unless`
+unless true do
+  "Dies wird nie jemand sehen..."
+else
+  "...aber dies!"
+end
+
+# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir
+# arbeiten damit.
+
+# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.
+case {:one, :two} do
+  {:four, :five} ->
+    "Das wird nicht passen"
+  {:one, x} ->
+    "Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."
+  _ ->
+    "Dieser Fall greift immer."
+end
+
+# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert
+# nicht weiter verwendet wird.
+# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:
+[kopf | _] = [1,2,3]
+kopf #=> 1
+
+# Für bessere Lesbarkeit können wir auch das Folgende machen:
+[kopf | _rest] = [:a, :b, :c]
+kopf #=> :a
+
+# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man
+# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.
+cond do
+  1 + 1 == 3 ->
+    "Ich werde nie aufgerufen."
+  2 * 5 == 12 ->
+    "Ich auch nicht."
+  1 + 2 == 3 ->
+    "Aber ich!"
+end
+
+# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert. 
+cond do
+  1 + 1 == 3 ->
+    "Ich werde nie aufgerufen."
+  2 * 5 == 12 ->
+    "Ich auch nicht."
+  true ->
+    "Aber ich! (dies ist im Grunde ein 'else')"
+end
+
+# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.
+# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,
+# egal ob zuvor ein Wert gefangen wurde.
+try do
+  throw(:hello)
+catch
+  nachricht -> "#{nachricht} gefangen."
+after
+  IO.puts("Ich bin die 'after'-Klausel.")
+end
+#=> Ich bin die 'after'-Klausel.
+# ":hello gefangen"
+
+## ---------------------------
+## -- Module und Funktionen
+## ---------------------------
+
+# Anonyme Funktionen (man beachte den Punkt)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben
+# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'
+# eingeführt:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen
+# Geltungsbereich ('scope') verfügbar.
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines
+# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu
+# definieren.
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'
+# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen
+# werden: elixirc math.ex
+
+# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine
+# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen
+# werden; eine private Funktion kann nur lokal angesprochen werden.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger
+# Bestandteil von Elixir.
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Elixir-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso
+# ist es möglich eigene Attribute hinzuzufügen.
+defmodule MyMod do
+  @moduledoc """
+  Dies ist ein eingebautes Attribut in einem Beispiel-Modul
+  """
+
+  @my_data 100 # Dies ist ein selbst-definiertes Attribut.
+  IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- 'Records' und Ausnahmebehandlung
+## ---------------------------
+
+# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen
+# Namen zuzuweisen.
+defrecord Person, name: nil, age: 0, height: 0
+
+joe_info = Person.new(name: "Joe", age: 30, height: 180)
+#=> Person[name: "Joe", age: 30, height: 180]
+
+# Zugriff auf den Wert von 'name'
+joe_info.name #=> "Joe"
+
+# Den Wert von 'age' überschreiben
+joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]
+
+# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,
+# um Ausnahmen beziehungsweise Fehler zu behandeln. 
+try do
+  raise "Irgendein Fehler."
+rescue
+  RuntimeError -> "Laufzeit-Fehler gefangen."
+  _error -> "Und dies fängt jeden Fehler."
+end
+
+# Alle Ausnahmen haben das Attribut 'message'
+try do
+  raise "ein Fehler"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+
+## ---------------------------
+## -- Nebenläufigkeit
+## ---------------------------
+
+# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles
+# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei
+# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen. 
+
+# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die
+# wiederum eine Funktion als Argument entgegen nimmt.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann
+# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um 
+# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir
+# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem 
+# 'receive'-Mechanismus sichergestellt:
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion
+# in der Shell mit, etwa so:
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck
+# erfüllt:
+pid <- {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+pid <- {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man
+# die aktuelle pid herausfinden.
+self() #=> #PID<0.27.0>
+
+```
+
+## Referenzen und weitere Lektüre
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert
+* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong
diff --git a/de-de/javascript-de.html.markdown b/de-de/javascript-de.html.markdown
index f817ee9f..a71d4316 100644
--- a/de-de/javascript-de.html.markdown
+++ b/de-de/javascript-de.html.markdown
@@ -1,525 +1,525 @@
----

-language: javascript

-contributors:

-    - ["Leigh Brenecki", "https://leigh.net.au"]

-translators:

-    - ["ggb", "http://www.ideen-und-soehne.de"]

-filename: learnjavascript-de.js

-lang: de-de

----

-

-(Anmerkungen des Original-Autors:)

-JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprünglich war es als einfachere Skriptsprache für Websites gedacht, ergänzend zu Java, das für komplexere Webanwendungen verwendet wird. Die enge Integration in Websites und der in Browser eingebaute Support der Sprache haben dafür gesorgt, dass JavaScript weit häufiger für Web-Frontends verwendet wird als Java.

-

-Dabei ist JavaScript inzwischen nicht mehr auf Browser beschränkt: Node.js, ein Projekt, das eine eigene Laufzeitumgebung auf Grundlage von Google Chromes V8 mitbringt, wird derzeit immer populärer.

-

-Feedback ist herzlich Willkommen! Der ursprüngliche Autor ist unter [@excitedleigh](https://twitter.com/excitedleigh) oder [l@leigh.net.au](mailto:l@leigh.net.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de).

-

-```js

-// Kommentare werden wie in C gesetzt: Einzeilige Kommentare starten mit zwei 

-// Slashes

-/* während mehrzeilige Kommentare mit einem 

-Slash und einem Stern anfangen und enden */

-

-// Statements können mit einem Semikolon beendet werden

-machWas();

-

-// ...müssen sie aber nicht, weil Semikola automatisch eingefügt werden, wenn 

-// eine neue Zeile beginnt, abgesehen von einigen Ausnahmen.

-machWas()

-

-// Obwohl wir uns für den Anfang nicht um diese Ausnahmen kümmern müssen ist 

-// es besser die Semikola immer zu setzen.

-

-///////////////////////////////////

-// 1. Nummern, Strings und Operationen

-

-// JavaScript hat einen Nummern-Typ (64-bit IEEE 754 double).

-3; // = 3

-1.5; // = 1.5

-

-// Beinahe alle grundlegenden arithmetischen Operationen arbeiten wie erwartet.

-1 + 1; // = 2

-0.1 + 0.2; // = 0.30000000000000004

-10 * 2; // = 20

-35 / 5; // = 7

-

-// Division funktioniert auch mit einem Ergebnis nach dem Komma.

-5 / 2; // = 2.5

-

-// Bit-weise Operationen sind auch möglich; wenn eine Bit-weise Operation 

-// ausgeführt wird, wird die Fließkomma-Zahl in einen 32-bit Integer (mit 

-// Vorzeichen) umgewandelt.

-1 << 2; // = 4

-

-// Die Rangfolge der Operationen kann mit Klammern erzwungen werden.

-(1 + 3) * 2; // = 8

-

-// Es gibt drei spezielle, nicht-reale Nummern-Werte:

-Infinity; // Ergebnis von z. B. 1 / 0

--Infinity; // Ergebnis von z. B. -1 / 0

-NaN; // Ergebnis von z. B. 0 / 0

-

-// Es gibt auch einen Boolean-Typ (für Wahrheitswerte).

-true;

-false;

-

-// Strings werden mit ' oder " erzeugt.

-'abc';

-"Hello, world";

-

-// Für die Negation wird das ! benutzt.

-!true; // = false

-!false; // = true

-

-// Gleichheit wird mit === geprüft.

-1 === 1; // = true

-2 === 1; // = false

-

-// Ungleichheit wird mit !== überprüft.

-1 !== 1; // = false

-2 !== 1; // = true

-

-// Andere Vergleichsoperatoren sind

-1 < 10; // = true

-1 > 10; // = false

-2 <= 2; // = true

-2 >= 2; // = true

-

-// Strings können mit + verbunden 

-"Hello " + "world!"; // = "Hello world!"

-

-// und mit < und > verglichen werden.

-"a" < "b"; // = true

-

-// Für den Vergleich von Werten mit "==" wird eine Typumwandlung erzwungen...

-"5" == 5; // = true

-

-// ...solange man nicht === verwendet.

-"5" === 5; // = false

-

-// Auf einzelne Buchstaben innerhalb eines Strings kann mit der Methode 

-// 'charAt' zugegriffen werden

-"This is a string".charAt(0);  // = "T"

-

-// Die Methode 'substring' gibt Teilbereiche eines Strings zurück

-"Hello world".substring(0, 5); // = "Hello"

-

-// 'length' ist eine Eigenschaft und wird folglich ohne '()' benutzt

-"Hello".length; // = 5

-

-// Es gibt außerdem die Werte 'null' und 'undefined'

-null; // wird verwendet um einen vorsätzlich gewählten 'Nicht'-Wert anzuzeigen

-undefined; // wird verwendet um anzuzeigen, dass der Wert (aktuell) nicht 

-           // verfügbar ist (obwohl genau genommen undefined selbst einen Wert 

-           // darstellt)

-

-// false, null, undefined, NaN, 0 und "" sind 'falsy', d. h. alles andere ist 

-// wahr. Man beachte, dass 0 falsch und "0" wahr ist, obwohl 0 == "0".

-

-///////////////////////////////////

-// 2. Variablen, Arrays und Objekte

-

-// Variablen werden mit dem Schlüsselwort 'var' und einem frei wählbaren 

-// Bezeichner deklariert. JavaScript ist dynamisch typisiert, so dass man einer

-// Variable keinen Typ zuweisen muss. Die Zuweisung verwendet ein einfaches =.

-var einWert = 5;

-

- // Wenn man das Schlüsselwort 'var' weglässt, bekommt man keinen Fehler

-einAndererWert = 10;

-

-// ...aber die Variable wird im globalen Kontext erzeugt, nicht in dem Kontext,

-// in dem sie erzeugt wurde.

-

-// Variablen die erzeugt wurden ohne ihnen einen Wert zuzuweisen, erhalten den

-// Wert 'undefined'.

-var einDritterWert; // = undefined

-

-// Es existiert eine Kurzform, um mathematische Operationen mit Variablen 

-// auszuführen:

-einWert += 5; // äquivalent zu einWert = einWert + 5; einWert ist nun also 10

-einWert *= 10; // einWert ist nach dieser Operation 100

-

-// Und es existiert eine weitere, sogar noch kürzere Form, um 1 zu addieren 

-// oder zu subtrahieren

-einWert++; // nun ist einWert 101

-einWert--; // wieder 100

-

-// Arrays sind geordnete Listen von Werten irgendeines Typs

-var myArray = ["Hello", 45, true];

-

-// Auf einzelne Elemente eines Arrays kann zugegriffen werden, in dem der Index

-// in eckigen Klammern hinter das Array geschrieben werden. Die Indexierung 

-// beginnt bei 0.

-myArray[1]; // = 45

-

-// Arrays haben keine feste Länge

-myArray.push("World");

-myArray.length; // = 4

-

-// und sind veränderlich

-myArray[3] = "Hello";

-

-// Die Objekte in JavaScript entsprechen 'dictionaries' oder 'maps' in anderen 

-// Sprachen: es handelt sich um ungeordnete Schlüssel-Wert-Paare.

-var myObj = { key1: "Hello", key2: "World" };

-

-// Schlüssel sind Strings, aber es werden keine Anführungszeichen benötigt, 

-// sofern es sich um reguläre JavaScript-Bezeichner handelt. Werte können von

-// jedem Typ sein.

-var myObj = { myKey: "myValue", "my other key": 4 };

-

-// Auf Attribute von Objekten kann ebenfalls mit eckigen Klammern zugegriffen

-// werden,

-myObj["my other key"]; // = 4

-

-// ... oder in dem man die Punkt-Notation verwendet, vorausgesetzt es handelt 

-// sich bei dem Schlüssel um einen validen Bezeichner.

-myObj.myKey; // = "myValue"

-

-// Objekte sind veränderlich, Werte können verändert und neue Schlüssel 

-// hinzugefügt werden.

-myObj.myThirdKey = true;

-

-// Der Zugriff auf einen noch nicht definierten Schlüssel, liefert ein 

-// undefined.

-myObj.myFourthKey; // = undefined

-

-///////////////////////////////////

-// 3. Logik und Kontrollstrukturen

-

-// Die if-Struktur arbeitet, wie man es erwartet.

-var count = 1;

-if (count == 3){

-    // wird evaluiert, wenn count gleich 3 ist

-} else if (count == 4) {

-    // wird evaluiert, wenn count gleich 4 ist

-} else {

-    // wird evaluiert, wenn es weder 3 noch 4 ist

-}

-

-// Genauso 'while'.

-while (true) {

-    // Eine unendliche Schleife!

-}

-

-// Do-while-Scheifen arbeiten wie while-Schleifen, abgesehen davon, dass sie 

-// immer mindestens einmal ausgeführt werden.

-var input;

-do {

-    input = getInput();

-} while ( !isValid( input ) )

-

-// Die for-Schleife arbeitet genau wie in C und Java:

-// Initialisierung; Bedingung, unter der die Ausführung fortgesetzt wird; 

-// Iteration.

-for ( var i = 0; i < 5; i++ ) {

-    // wird 5-mal ausgeführt

-}

-

-// '&&' ist das logische und, '||' ist das logische oder

-if (house.size == "big" && house.colour == "blue"){

-    house.contains = "bear";

-    // Die Größe des Hauses ist groß und die Farbe blau.

-}

-if (colour == "red" || colour == "blue"){

-    // Die Farbe ist entweder rot oder blau.

-}

-

-// Die Auswertung von '&&' und '||' erfolgt so, dass abgebrochen wird, wenn die

-// Bedingung erfüllt ist (bei oder) oder nicht-erfüllt ist (bei und). Das ist 

-// nützlich, um einen Default-Wert zu setzen.

-var name = otherName || "default";

-

-// Ein 'switch' Statement prüft Gleichheit mit ===

-// ohne ein 'break' nach jedem Fall

-// werden auch die Fälle nach dem korrekten aufgerufen

-grade = 'B';

-switch (grade) {

-  case 'A':

-    console.log("Great job");

-    break;

-  case 'B':

-    console.log("OK job");

-    break;

-  case 'C':

-    console.log("You can do better");

-    break;

-  default:

-    console.log("Oy vey");

-    break;

-}

-

-///////////////////////////////////

-// 4. Funktionen, Geltungsbereich und Closures

-

-// In JavaScript werden Funktionen mit dem Schlüsselwort 'function' deklariert.

-function myFunction(thing){

-    return thing.toUpperCase();

-}

-myFunction("foo"); // = "FOO"

-

-// Vorsicht: der Ausdruck der den Rückgabewert einer Funktion bildet muss

-// auf der selben Zeile beginnen auf der auch das 'return' Keyword steht

-// Sonst wird hier ein automatisches Semikolon eingefügt und die Funktion

-// gibt 'undefined' zurück

-function myFunction()

-{

-    return // <- Hier wird automatisch ein Semikolon eingefügt

-    {

-        thisIsAn: 'object literal'

-    }

-}

-myFunction(); // = undefined

-

-// In JavaScript sind Funktionen 'Bürger erster Klasse', also können sie wie 

-// Variablen verwendet und als Parameter anderen Funktionen übergeben werden 

-// - zum Beispiel, um einen 'event handler' zu 'beliefern'.

-function myFunction() {

-    // wird ausgeführt, nachdem 5 Sekunden vergangen sind

-}

-setTimeout(myFunction, 5000);

-

-// Funktionen können auch deklariert werden, ohne ihnen einen Namen zuzuweisen.

-// Es ist möglich diese anonymen Funktionen direkt als (oder im) Argument 

-// einer anderen Funktion zu definieren.

-setTimeout(function(){

-    // wird ausgeführt, nachdem 5 Sekunden vergangen sind

-}, 5000);

-

-// JavaScript hat einen Geltungsbereich, der sich auf Funktionen erstreckt: 

-// Funktionen haben ihren eigenen Geltungsbereich, andere Blöcke nicht.

-if(true) {

-    var i = 5;

-}

-i; // = 5 - nicht undefined, wie man es von einer Sprache erwarten würde, die 

-   // ihren Geltungsbereich nach Blöcken richtet

-

-// Daraus ergibt sich ein bestimmtes Muster für sofort-ausführbare, anonyme 

-// Funktionen, die es vermeiden, dass der globale Geltungsbereich von Variablen

-// 'verschmutzt' wird.

-(function(){

-    var temporary = 5;

-    // Auf eine Variable im globalen Geltungsbereich kann zugegriffen werden, 

-    // sofern sie im globalen Objekt definiert ist (in einem Webbrowser ist 

-    // dies immer das 'window'-Objekt, in anderen Umgebungen, bspw. Node.js, 

-    // kann das anders aussehen). 

-    window.permanent = 10;

-})();

-temporary; // wirft einen ReferenceError

-permanent; // = 10

-

-// Eines der mächtigsten Charakteristika von JavaScript sind Closures. Wird 

-// eine Funktion innerhalb einer anderen Funktion definiert, dann hat die 

-// innere Funktion Zugriff auf alle Variablen der äußeren Funktion, sogar dann,

-// wenn die äußere Funktion beendet wurde.

-function sayHelloInFiveSeconds(name){

-    var prompt = "Hello, " + name + "!";

-    function inner(){

-        alert(prompt);

-    }

-    setTimeout(inner, 5000);

-    // setTimeout wird asynchron ausgeführt. Also wird sayHelloInFiveSeconds 

-    // sofort verlassen und setTimeout wird die innere Funktion 'im nachhinein' 

-    // aufrufen. Dennoch: Weil sayHelloInFiveSeconds eine Hülle um die innere 

-    // Funktion bildet, hat die innere Funktion immer noch Zugriff auf die 

-    // Variable prompt.

-}

-sayHelloInFiveSeconds("Adam");  // wird nach 5 Sekunden ein Popup mit der 

-                                // Nachricht "Hello, Adam!" öffnen.

-

-///////////////////////////////////

-// 5. Mehr über Objekte, Konstruktoren und Prototypen

-

-// Objekte können Funktionen enthalten.

-var myObj = {

-    myFunc: function(){

-        return "Hello world!";

-    }

-};

-myObj.myFunc(); // = "Hello world!"

-

-// Wenn Funktionen aufgerufen werden, die zu einem Objekt gehören, können sie 

-// auf das eigene Objekt mit dem Schlüsselwort 'this' zugreifen.

-myObj = {

-    myString: "Hello world!",

-    myFunc: function(){

-        return this.myString;

-    }

-};

-myObj.myFunc(); // = "Hello world!"

-

-// Worauf 'this' gesetzt wird, ist davon abhängig, wie die Funktion aufgerufen 

-// wird, nicht wo sie definiert wurde. Unsere Funktion wird daher nicht 

-// funktionieren, sofern sie außerhalb des Kontextes des Objekts aufgerufen 

-// wird.

-var myFunc = myObj.myFunc;

-myFunc(); // = undefined

-

-// Umgekehrt ist es möglich eine Funktion einem Objekt zuzuweisen und dadurch 

-// Zugriff auf den this-Kontext zu erhalten, sogar dann, wenn die Funktion dem

-// Objekt nach dessen Definition zugewiesen wird.

-var myOtherFunc = function(){

-    return this.myString.toUpperCase();

-}

-myObj.myOtherFunc = myOtherFunc;

-myObj.myOtherFunc(); // = "HELLO WORLD!"

-

-// Mit den Methoden 'call' und 'apply' kann der Kontext eines Funktionsaufrufs

-// verändert werden

-

-var anotherFunc = function(s){

-    return this.myString + s;

-}

-anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"

-

-// 'apply' funktioniert beiahe identisch, erwartet die übergebenen Argumente

-// aber in einem Array

-

-anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"

-

-// Das ist hilfreich wenn man einer Funktion eine beliebige Zahl Argumente

-// übergeben kann

-

-Math.min(42, 6, 27); // = 6

-Math.min([42, 6, 27]); // = NaN (uh-oh!)

-Math.min.apply(Math, [42, 6, 27]); // = 6

-

-// 'call' und 'apply' beeinflussen aber nur den spezifischen Aufruf.

-// Um den Kontext einer Funktion dauerhaft zu ändern wird 'bind' benutzt.

-

-var boundFunc = anotherFunc.bind(myObj);

-boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"

-

-// Mit 'bind' lassen sich Funktionen auch teilweise anwenden / "curryen".

-var product = function(a, b){ return a * b; }

-var doubler = product.bind(this, 2);

-doubler(8); // = 16

-

-// Wenn eine Funktion mit dem Schlüsselwort 'new' aufgerufen wird, dann wird 

-// ein neues Objekt erzeugt. Funktionen, die darauf ausgelegt sind in dieser 

-// Art aufgerufen zu werden, werden Konstruktoren genannt.

-var MyConstructor = function(){

-    this.myNumber = 5;

-}

-myNewObj = new MyConstructor(); // = {myNumber: 5}

-myNewObj.myNumber; // = 5

-

-// Jedes JavaScript-Objekt hat einen Prototyp. Wenn man versucht auf eine 

-// Eigenschaft des Objekts zuzugreifen, das nicht im Objekt selbst existiert,

-// schaut der Interpreter in dessen Prototyp nach.

-

-// Einige JavaScript-Implementierungen erlauben den direkten Zugriff auf den 

-// Prototyp eines Objekts durch die magische Eigenschaft __proto__. Obwohl das

-// nützlich ist, um  Prototypen im Allgemeinen zu erklären, ist das nicht Teil

-// des Standards; zum Standard-Weg der Nutzung von Prototypen kommen wir 

-// später.

-var myObj = {

-    myString: "Hello world!",

-};

-var myPrototype = {

-    meaningOfLife: 42,

-    myFunc: function(){

-        return this.myString.toLowerCase()

-    }

-};

-myObj.__proto__ = myPrototype;

-myObj.meaningOfLife; // = 42

-

-// Das funktioniert auch bei Funktionen.

-myObj.myFunc(); // = "hello world!"

-

-// Sollte die Eigenschaft nicht im Prototypen des Objekts enthalten sein, dann

-// wird im Prototypen des Prototypen nachgesehen und so weiter.

-myPrototype.__proto__ = {

-    myBoolean: true

-};

-myObj.myBoolean; // = true

-

-// Dafür wird nichts hin und her kopiert; jedes Objekt speichert eine Referenz

-// auf seinen Prototypen. Das heißt wenn der Prototyp geändert wird, dann 

-// werden die Änderungen überall sichtbar.

-myPrototype.meaningOfLife = 43;

-myObj.meaningOfLife; // = 43

-

-// Es wurde bereits erwähnt, dass __proto__ nicht zum Standard gehört und es 

-// gibt ebenso keinen Standard-Weg, um den Prototyp eines existierenden Objekts

-// zu ändern. Es gibt dennoch zwei Wege, wie man ein neues Objekt mit einem 

-// gegebenen Prototypen erzeugt.

-

-// Der erste Weg ist die Methode Object.create, die eine jüngere Ergänzung des

-// JavaScript-Standards ist und daher noch nicht in allen Implementierungen 

-// verfügbar.

-var myObj = Object.create(myPrototype);

-myObj.meaningOfLife; // = 43

-

-// Der zweite Weg, der immer funktioniert, hat mit den Konstruktoren zu tun. 

-// Konstruktoren haben eine Eigenschaft, die Prototyp heißt.  Dabei handelt es

-// sich *nicht* um den Prototypen der Konstruktor-Funktion; stattdessen handelt

-// es sich um den Prototypen, der einem neuen Objekt mitgegeben wird, wenn es 

-// mit dem Konstruktor und dem Schlüsselwort 'new' erzeugt wird.

-MyConstructor.prototype = {

-    getMyNumber: function(){

-        return this.myNumber

-    }

-};

-var myNewObj2 = new MyConstructor();

-myNewObj2.getMyNumber(); // = 5

-

-// Alle primitiven Typen, also strings und numbers, haben auch Konstruktoren, 

-// die zu dem Typ äquivalente Wrapper-Objekte erzeugen. 

-var myNumber = 12;

-var myNumberObj = new Number(12);

-myNumber == myNumberObj; // = true

-

-// Genau genommen: Sie sind nicht exakt äquivalent.

-typeof myNumber; // = 'number'

-typeof myNumberObj; // = 'object'

-myNumber === myNumberObj; // = false

-if (0){

-    // Dieser Teil wird nicht ausgeführt, weil 0 'falsy' ist.

-}

-

-// Das Wrapper-Objekt und die regulären, eingebauten Typen, teilen sich einen 

-// Prototyp; so ist es möglich zum Beispiel einem String weitere Funktionen 

-// hinzuzufügen.

-String.prototype.firstCharacter = function(){

-    return this.charAt(0);

-}

-"abc".firstCharacter(); // = "a"

-

-// Diese Tatsache wird häufig bei einer Methode mit dem Namen 'polyfilling'

-// verwendet: Dabei wird ein neues Feature von JavaScript in einer älteren 

-// Untermenge der Sprache integriert, so dass bestimmte Funktionen auch in 

-// älteren Umgebungen und Browsern verwendet werden können.

-

-// Ein Beispiel: Es wurde erwähnt, dass die Methode Object.create nicht in 

-// allen Umgebungen verfügbar ist - wir können sie dennoch verwenden, mit einem

-// 'polyfill':

-if (Object.create === undefined){ // überschreib nichts, was eventuell bereits

-                                  // existiert

-    Object.create = function(proto){

-        // erstelle einen vorübergehenden Konstruktor mit dem richtigen

-        // Prototypen

-        var Constructor = function(){};

-        Constructor.prototype = proto;

-        // verwende es dann, um ein neues Objekt mit einem passenden 

-        // Prototypen zurückzugeben

-        return new Constructor();

-    }

-}

-```

-

-## Zur weiteren Lektüre (englisch)

-

-Das [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) bietet eine ausgezeichnete Dokumentation für die Verwendung von JavaScript im Browser. Es ist außerdem ein Wiki und ermöglicht es damit anderen zu helfen, wenn man selbst ein wenig Wissen angesammelt hat.

-

-MDN's [A re-introduction to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) führt sehr viele der hier vorgestellten Konzepte im Detail aus. 

-

-Dieses Tutorial hat nur die Sprache JavaScript vorgestellt; um mehr über den  Einsatz in Websites zu lernen, ist es ein guter Start etwas über das [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) zu lernen.

-

-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) ist eine tiefgehende Einführung in die kontra-intuitiven Parts der Sprache.

-

-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) ist ein Klassiker unter den Referenzen.

-

-Zusätzlich zu direkten Beiträgen zu diesem Artikel ist der Inhalt in Anlehnung an Louie Dinh's Python-Tutorial auf dieser Seite und das [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) des Mozilla Developer Network entstanden.

+---
+language: javascript
+contributors:
+    - ["Leigh Brenecki", "https://leigh.net.au"]
+translators:
+    - ["ggb", "http://www.ideen-und-soehne.de"]
+filename: learnjavascript-de.js
+lang: de-de
+---
+
+(Anmerkungen des Original-Autors:)
+JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprünglich war es als einfachere Skriptsprache für Websites gedacht, ergänzend zu Java, das für komplexere Webanwendungen verwendet wird. Die enge Integration in Websites und der in Browser eingebaute Support der Sprache haben dafür gesorgt, dass JavaScript weit häufiger für Web-Frontends verwendet wird als Java.
+
+Dabei ist JavaScript inzwischen nicht mehr auf Browser beschränkt: Node.js, ein Projekt, das eine eigene Laufzeitumgebung auf Grundlage von Google Chromes V8 mitbringt, wird derzeit immer populärer.
+
+Feedback ist herzlich Willkommen! Der ursprüngliche Autor ist unter [@excitedleigh](https://twitter.com/excitedleigh) oder [l@leigh.net.au](mailto:l@leigh.net.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de).
+
+```js
+// Kommentare werden wie in C gesetzt: Einzeilige Kommentare starten mit zwei 
+// Slashes
+/* während mehrzeilige Kommentare mit einem 
+Slash und einem Stern anfangen und enden */
+
+// Statements können mit einem Semikolon beendet werden
+machWas();
+
+// ...müssen sie aber nicht, weil Semikola automatisch eingefügt werden, wenn 
+// eine neue Zeile beginnt, abgesehen von einigen Ausnahmen.
+machWas()
+
+// Obwohl wir uns für den Anfang nicht um diese Ausnahmen kümmern müssen ist 
+// es besser die Semikola immer zu setzen.
+
+///////////////////////////////////
+// 1. Nummern, Strings und Operationen
+
+// JavaScript hat einen Nummern-Typ (64-bit IEEE 754 double).
+3; // = 3
+1.5; // = 1.5
+
+// Beinahe alle grundlegenden arithmetischen Operationen arbeiten wie erwartet.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Division funktioniert auch mit einem Ergebnis nach dem Komma.
+5 / 2; // = 2.5
+
+// Bit-weise Operationen sind auch möglich; wenn eine Bit-weise Operation 
+// ausgeführt wird, wird die Fließkomma-Zahl in einen 32-bit Integer (mit 
+// Vorzeichen) umgewandelt.
+1 << 2; // = 4
+
+// Die Rangfolge der Operationen kann mit Klammern erzwungen werden.
+(1 + 3) * 2; // = 8
+
+// Es gibt drei spezielle, nicht-reale Nummern-Werte:
+Infinity; // Ergebnis von z. B. 1 / 0
+-Infinity; // Ergebnis von z. B. -1 / 0
+NaN; // Ergebnis von z. B. 0 / 0
+
+// Es gibt auch einen Boolean-Typ (für Wahrheitswerte).
+true;
+false;
+
+// Strings werden mit ' oder " erzeugt.
+'abc';
+"Hello, world";
+
+// Für die Negation wird das ! benutzt.
+!true; // = false
+!false; // = true
+
+// Gleichheit wird mit === geprüft.
+1 === 1; // = true
+2 === 1; // = false
+
+// Ungleichheit wird mit !== überprüft.
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Andere Vergleichsoperatoren sind
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings können mit + verbunden 
+"Hello " + "world!"; // = "Hello world!"
+
+// und mit < und > verglichen werden.
+"a" < "b"; // = true
+
+// Für den Vergleich von Werten mit "==" wird eine Typumwandlung erzwungen...
+"5" == 5; // = true
+
+// ...solange man nicht === verwendet.
+"5" === 5; // = false
+
+// Auf einzelne Buchstaben innerhalb eines Strings kann mit der Methode 
+// 'charAt' zugegriffen werden
+"This is a string".charAt(0);  // = "T"
+
+// Die Methode 'substring' gibt Teilbereiche eines Strings zurück
+"Hello world".substring(0, 5); // = "Hello"
+
+// 'length' ist eine Eigenschaft und wird folglich ohne '()' benutzt
+"Hello".length; // = 5
+
+// Es gibt außerdem die Werte 'null' und 'undefined'
+null; // wird verwendet um einen vorsätzlich gewählten 'Nicht'-Wert anzuzeigen
+undefined; // wird verwendet um anzuzeigen, dass der Wert (aktuell) nicht 
+           // verfügbar ist (obwohl genau genommen undefined selbst einen Wert 
+           // darstellt)
+
+// false, null, undefined, NaN, 0 und "" sind 'falsy', d. h. alles andere ist 
+// wahr. Man beachte, dass 0 falsch und "0" wahr ist, obwohl 0 == "0".
+
+///////////////////////////////////
+// 2. Variablen, Arrays und Objekte
+
+// Variablen werden mit dem Schlüsselwort 'var' und einem frei wählbaren 
+// Bezeichner deklariert. JavaScript ist dynamisch typisiert, so dass man einer
+// Variable keinen Typ zuweisen muss. Die Zuweisung verwendet ein einfaches =.
+var einWert = 5;
+
+ // Wenn man das Schlüsselwort 'var' weglässt, bekommt man keinen Fehler
+einAndererWert = 10;
+
+// ...aber die Variable wird im globalen Kontext erzeugt, nicht in dem Kontext,
+// in dem sie erzeugt wurde.
+
+// Variablen die erzeugt wurden ohne ihnen einen Wert zuzuweisen, erhalten den
+// Wert 'undefined'.
+var einDritterWert; // = undefined
+
+// Es existiert eine Kurzform, um mathematische Operationen mit Variablen 
+// auszuführen:
+einWert += 5; // äquivalent zu einWert = einWert + 5; einWert ist nun also 10
+einWert *= 10; // einWert ist nach dieser Operation 100
+
+// Und es existiert eine weitere, sogar noch kürzere Form, um 1 zu addieren 
+// oder zu subtrahieren
+einWert++; // nun ist einWert 101
+einWert--; // wieder 100
+
+// Arrays sind geordnete Listen von Werten irgendeines Typs
+var myArray = ["Hello", 45, true];
+
+// Auf einzelne Elemente eines Arrays kann zugegriffen werden, in dem der Index
+// in eckigen Klammern hinter das Array geschrieben werden. Die Indexierung 
+// beginnt bei 0.
+myArray[1]; // = 45
+
+// Arrays haben keine feste Länge
+myArray.push("World");
+myArray.length; // = 4
+
+// und sind veränderlich
+myArray[3] = "Hello";
+
+// Die Objekte in JavaScript entsprechen 'dictionaries' oder 'maps' in anderen 
+// Sprachen: es handelt sich um ungeordnete Schlüssel-Wert-Paare.
+var myObj = { key1: "Hello", key2: "World" };
+
+// Schlüssel sind Strings, aber es werden keine Anführungszeichen benötigt, 
+// sofern es sich um reguläre JavaScript-Bezeichner handelt. Werte können von
+// jedem Typ sein.
+var myObj = { myKey: "myValue", "my other key": 4 };
+
+// Auf Attribute von Objekten kann ebenfalls mit eckigen Klammern zugegriffen
+// werden,
+myObj["my other key"]; // = 4
+
+// ... oder in dem man die Punkt-Notation verwendet, vorausgesetzt es handelt 
+// sich bei dem Schlüssel um einen validen Bezeichner.
+myObj.myKey; // = "myValue"
+
+// Objekte sind veränderlich, Werte können verändert und neue Schlüssel 
+// hinzugefügt werden.
+myObj.myThirdKey = true;
+
+// Der Zugriff auf einen noch nicht definierten Schlüssel, liefert ein 
+// undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Logik und Kontrollstrukturen
+
+// Die if-Struktur arbeitet, wie man es erwartet.
+var count = 1;
+if (count == 3){
+    // wird evaluiert, wenn count gleich 3 ist
+} else if (count == 4) {
+    // wird evaluiert, wenn count gleich 4 ist
+} else {
+    // wird evaluiert, wenn es weder 3 noch 4 ist
+}
+
+// Genauso 'while'.
+while (true) {
+    // Eine unendliche Schleife!
+}
+
+// Do-while-Scheifen arbeiten wie while-Schleifen, abgesehen davon, dass sie 
+// immer mindestens einmal ausgeführt werden.
+var input;
+do {
+    input = getInput();
+} while ( !isValid( input ) )
+
+// Die for-Schleife arbeitet genau wie in C und Java:
+// Initialisierung; Bedingung, unter der die Ausführung fortgesetzt wird; 
+// Iteration.
+for ( var i = 0; i < 5; i++ ) {
+    // wird 5-mal ausgeführt
+}
+
+// '&&' ist das logische und, '||' ist das logische oder
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+    // Die Größe des Hauses ist groß und die Farbe blau.
+}
+if (colour == "red" || colour == "blue"){
+    // Die Farbe ist entweder rot oder blau.
+}
+
+// Die Auswertung von '&&' und '||' erfolgt so, dass abgebrochen wird, wenn die
+// Bedingung erfüllt ist (bei oder) oder nicht-erfüllt ist (bei und). Das ist 
+// nützlich, um einen Default-Wert zu setzen.
+var name = otherName || "default";
+
+// Ein 'switch' Statement prüft Gleichheit mit ===
+// ohne ein 'break' nach jedem Fall
+// werden auch die Fälle nach dem korrekten aufgerufen
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+///////////////////////////////////
+// 4. Funktionen, Geltungsbereich und Closures
+
+// In JavaScript werden Funktionen mit dem Schlüsselwort 'function' deklariert.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Vorsicht: der Ausdruck der den Rückgabewert einer Funktion bildet muss
+// auf der selben Zeile beginnen auf der auch das 'return' Keyword steht
+// Sonst wird hier ein automatisches Semikolon eingefügt und die Funktion
+// gibt 'undefined' zurück
+function myFunction()
+{
+    return // <- Hier wird automatisch ein Semikolon eingefügt
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// In JavaScript sind Funktionen 'Bürger erster Klasse', also können sie wie 
+// Variablen verwendet und als Parameter anderen Funktionen übergeben werden 
+// - zum Beispiel, um einen 'event handler' zu 'beliefern'.
+function myFunction() {
+    // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}
+setTimeout(myFunction, 5000);
+
+// Funktionen können auch deklariert werden, ohne ihnen einen Namen zuzuweisen.
+// Es ist möglich diese anonymen Funktionen direkt als (oder im) Argument 
+// einer anderen Funktion zu definieren.
+setTimeout(function(){
+    // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}, 5000);
+
+// JavaScript hat einen Geltungsbereich, der sich auf Funktionen erstreckt: 
+// Funktionen haben ihren eigenen Geltungsbereich, andere Blöcke nicht.
+if(true) {
+    var i = 5;
+}
+i; // = 5 - nicht undefined, wie man es von einer Sprache erwarten würde, die 
+   // ihren Geltungsbereich nach Blöcken richtet
+
+// Daraus ergibt sich ein bestimmtes Muster für sofort-ausführbare, anonyme 
+// Funktionen, die es vermeiden, dass der globale Geltungsbereich von Variablen
+// 'verschmutzt' wird.
+(function(){
+    var temporary = 5;
+    // Auf eine Variable im globalen Geltungsbereich kann zugegriffen werden, 
+    // sofern sie im globalen Objekt definiert ist (in einem Webbrowser ist 
+    // dies immer das 'window'-Objekt, in anderen Umgebungen, bspw. Node.js, 
+    // kann das anders aussehen). 
+    window.permanent = 10;
+})();
+temporary; // wirft einen ReferenceError
+permanent; // = 10
+
+// Eines der mächtigsten Charakteristika von JavaScript sind Closures. Wird 
+// eine Funktion innerhalb einer anderen Funktion definiert, dann hat die 
+// innere Funktion Zugriff auf alle Variablen der äußeren Funktion, sogar dann,
+// wenn die äußere Funktion beendet wurde.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout wird asynchron ausgeführt. Also wird sayHelloInFiveSeconds 
+    // sofort verlassen und setTimeout wird die innere Funktion 'im nachhinein' 
+    // aufrufen. Dennoch: Weil sayHelloInFiveSeconds eine Hülle um die innere 
+    // Funktion bildet, hat die innere Funktion immer noch Zugriff auf die 
+    // Variable prompt.
+}
+sayHelloInFiveSeconds("Adam");  // wird nach 5 Sekunden ein Popup mit der 
+                                // Nachricht "Hello, Adam!" öffnen.
+
+///////////////////////////////////
+// 5. Mehr über Objekte, Konstruktoren und Prototypen
+
+// Objekte können Funktionen enthalten.
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Wenn Funktionen aufgerufen werden, die zu einem Objekt gehören, können sie 
+// auf das eigene Objekt mit dem Schlüsselwort 'this' zugreifen.
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Worauf 'this' gesetzt wird, ist davon abhängig, wie die Funktion aufgerufen 
+// wird, nicht wo sie definiert wurde. Unsere Funktion wird daher nicht 
+// funktionieren, sofern sie außerhalb des Kontextes des Objekts aufgerufen 
+// wird.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Umgekehrt ist es möglich eine Funktion einem Objekt zuzuweisen und dadurch 
+// Zugriff auf den this-Kontext zu erhalten, sogar dann, wenn die Funktion dem
+// Objekt nach dessen Definition zugewiesen wird.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+// Mit den Methoden 'call' und 'apply' kann der Kontext eines Funktionsaufrufs
+// verändert werden
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+// 'apply' funktioniert beiahe identisch, erwartet die übergebenen Argumente
+// aber in einem Array
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+// Das ist hilfreich wenn man einer Funktion eine beliebige Zahl Argumente
+// übergeben kann
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// 'call' und 'apply' beeinflussen aber nur den spezifischen Aufruf.
+// Um den Kontext einer Funktion dauerhaft zu ändern wird 'bind' benutzt.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+// Mit 'bind' lassen sich Funktionen auch teilweise anwenden / "curryen".
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Wenn eine Funktion mit dem Schlüsselwort 'new' aufgerufen wird, dann wird 
+// ein neues Objekt erzeugt. Funktionen, die darauf ausgelegt sind in dieser 
+// Art aufgerufen zu werden, werden Konstruktoren genannt.
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Jedes JavaScript-Objekt hat einen Prototyp. Wenn man versucht auf eine 
+// Eigenschaft des Objekts zuzugreifen, das nicht im Objekt selbst existiert,
+// schaut der Interpreter in dessen Prototyp nach.
+
+// Einige JavaScript-Implementierungen erlauben den direkten Zugriff auf den 
+// Prototyp eines Objekts durch die magische Eigenschaft __proto__. Obwohl das
+// nützlich ist, um  Prototypen im Allgemeinen zu erklären, ist das nicht Teil
+// des Standards; zum Standard-Weg der Nutzung von Prototypen kommen wir 
+// später.
+var myObj = {
+    myString: "Hello world!",
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Das funktioniert auch bei Funktionen.
+myObj.myFunc(); // = "hello world!"
+
+// Sollte die Eigenschaft nicht im Prototypen des Objekts enthalten sein, dann
+// wird im Prototypen des Prototypen nachgesehen und so weiter.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Dafür wird nichts hin und her kopiert; jedes Objekt speichert eine Referenz
+// auf seinen Prototypen. Das heißt wenn der Prototyp geändert wird, dann 
+// werden die Änderungen überall sichtbar.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// Es wurde bereits erwähnt, dass __proto__ nicht zum Standard gehört und es 
+// gibt ebenso keinen Standard-Weg, um den Prototyp eines existierenden Objekts
+// zu ändern. Es gibt dennoch zwei Wege, wie man ein neues Objekt mit einem 
+// gegebenen Prototypen erzeugt.
+
+// Der erste Weg ist die Methode Object.create, die eine jüngere Ergänzung des
+// JavaScript-Standards ist und daher noch nicht in allen Implementierungen 
+// verfügbar.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Der zweite Weg, der immer funktioniert, hat mit den Konstruktoren zu tun. 
+// Konstruktoren haben eine Eigenschaft, die Prototyp heißt.  Dabei handelt es
+// sich *nicht* um den Prototypen der Konstruktor-Funktion; stattdessen handelt
+// es sich um den Prototypen, der einem neuen Objekt mitgegeben wird, wenn es 
+// mit dem Konstruktor und dem Schlüsselwort 'new' erzeugt wird.
+MyConstructor.prototype = {
+    getMyNumber: function(){
+        return this.myNumber
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+
+// Alle primitiven Typen, also strings und numbers, haben auch Konstruktoren, 
+// die zu dem Typ äquivalente Wrapper-Objekte erzeugen. 
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Genau genommen: Sie sind nicht exakt äquivalent.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // Dieser Teil wird nicht ausgeführt, weil 0 'falsy' ist.
+}
+
+// Das Wrapper-Objekt und die regulären, eingebauten Typen, teilen sich einen 
+// Prototyp; so ist es möglich zum Beispiel einem String weitere Funktionen 
+// hinzuzufügen.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Diese Tatsache wird häufig bei einer Methode mit dem Namen 'polyfilling'
+// verwendet: Dabei wird ein neues Feature von JavaScript in einer älteren 
+// Untermenge der Sprache integriert, so dass bestimmte Funktionen auch in 
+// älteren Umgebungen und Browsern verwendet werden können.
+
+// Ein Beispiel: Es wurde erwähnt, dass die Methode Object.create nicht in 
+// allen Umgebungen verfügbar ist - wir können sie dennoch verwenden, mit einem
+// 'polyfill':
+if (Object.create === undefined){ // überschreib nichts, was eventuell bereits
+                                  // existiert
+    Object.create = function(proto){
+        // erstelle einen vorübergehenden Konstruktor mit dem richtigen
+        // Prototypen
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // verwende es dann, um ein neues Objekt mit einem passenden 
+        // Prototypen zurückzugeben
+        return new Constructor();
+    }
+}
+```
+
+## Zur weiteren Lektüre (englisch)
+
+Das [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) bietet eine ausgezeichnete Dokumentation für die Verwendung von JavaScript im Browser. Es ist außerdem ein Wiki und ermöglicht es damit anderen zu helfen, wenn man selbst ein wenig Wissen angesammelt hat.
+
+MDN's [A re-introduction to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) führt sehr viele der hier vorgestellten Konzepte im Detail aus. 
+
+Dieses Tutorial hat nur die Sprache JavaScript vorgestellt; um mehr über den  Einsatz in Websites zu lernen, ist es ein guter Start etwas über das [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) zu lernen.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) ist eine tiefgehende Einführung in die kontra-intuitiven Parts der Sprache.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) ist ein Klassiker unter den Referenzen.
+
+Zusätzlich zu direkten Beiträgen zu diesem Artikel ist der Inhalt in Anlehnung an Louie Dinh's Python-Tutorial auf dieser Seite und das [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) des Mozilla Developer Network entstanden.
diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
index 1bae332c..3674f2f5 100644
--- a/de-de/make-de.html.markdown
+++ b/de-de/make-de.html.markdown
@@ -1,263 +1,263 @@
----

-category: tool

-tool: 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

-lang: de-de

----

-

-Eine Makefile definiert einen Graphen von Regeln um ein Ziel (oder Ziele)

-zu erzeugen. Es dient dazu, die geringste Menge an Arbeit zu verrichten um

-ein Ziel in Einklang mit dem Quellcode zu bringen. Make wurde berühmterweise

-von Stuart Feldman 1976 übers Wochenende geschrieben. Make ist noch immer

-sehr verbreitet (vorallem im Unix Umfeld) obwohl es bereits sehr viel

-Konkurrenz und Kritik zu Make gibt.

-

-Es gibt eine Vielzahl an Varianten von Make, dieser Artikel beschäftigt sich

-mit der Version GNU Make. Diese Version ist Standard auf Linux.

-

-```make

-

-# Kommentare können so geschrieben werden.

-

-# Dateien sollten Makefile heißen, denn dann können sie als `make <ziel>`

-# aufgerufen werden. Ansonsten muss `make -f "dateiname" <ziel>` verwendet

-# werden.

-

-# Warnung - Es sollten nur TABULATOREN zur Einrückung im Makefile verwendet

-# werden. Niemals Leerzeichen!

-

-#-----------------------------------------------------------------------

-# Grundlagen

-#-----------------------------------------------------------------------

-

-# Eine Regel - Diese Regel wird nur abgearbeitet wenn die Datei file0.txt

-# nicht existiert.

-file0.txt:

-	echo "foo" > file0.txt

-	# Selbst Kommentare in der 'Rezept' Sektion werden an die Shell

-	# weitergegeben. Versuche `make file0.txt` oder einfach `make`

-	# die erste Regel ist die Standard-Regel.

-

-

-# Diese Regel wird nur abgearbeitet, wenn file0.txt aktueller als file1.txt ist.

-file1.txt: file0.txt

-	cat file0.txt > file1.txt

-	# Verwende die selben Quoting-Regeln wie die Shell

-	@cat file0.txt >> file1.txt

-	# @ unterdrückt die Ausgabe des Befehls an stdout.

-	-@echo 'hello'

-	# - bedeutet, dass Make die Abarbeitung fortsetzt auch wenn Fehler

-    # passieren.

-	# Versuche `make file1.txt` auf der Kommandozeile.

-

-# Eine Regel kann mehrere Ziele und mehrere Voraussetzungen haben.

-file2.txt file3.txt: file0.txt file1.txt

-	touch file2.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

-# Voraussetzungen hinzuzufügen.

-

-#-----------------------------------------------------------------------

-# Phony-Ziele

-#-----------------------------------------------------------------------

-

-# Ein Phony-Ziel ist ein Ziel, das keine Datei ist.

-# Es wird nie aktuell sein, daher wird Make immer versuchen, es abzuarbeiten

-all: maker process

-

-# Es ist erlaubt Dinge ausserhalb der Reihenfolge zu deklarieren.

-maker:

-	touch ex0.txt ex1.txt

-

-# Um das Fehlschlagen von Phony-Regeln zu vermeiden wenn eine echte Datei den

-# selben namen wie ein Phony-Ziel hat:

-.PHONY: all maker process

-# Das ist ein spezielles Ziel. Es gibt noch ein paar mehr davon.

-

-# Eine Regel mit einem Phony-Ziel als Voraussetzung wird immer abgearbeitet

-ex0.txt ex1.txt: maker

-

-# Häufige Phony-Ziele sind: all make clean install ...

-

-#-----------------------------------------------------------------------

-# Automatische Variablen & Wildcards

-#-----------------------------------------------------------------------

-

-process: file*.txt	# Eine Wildcard um Dateinamen zu vergleichen

-	@echo $^	# $^ ist eine Variable die eine Liste aller

-			# Voraussetzungen enthält.

-	@echo $@	# Namen des Ziels ausgeben.

-	#(Bei mehreren Ziel-Regeln enthält $@ den Verursacher der Abarbeitung

-	#der Regel.)

-	@echo $<	# Die erste Voraussetzung aus der Liste

-	@echo $?	# Nur die Voraussetzungen, die nicht aktuell sind.

-	@echo $+	# Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich)

-	#@echo $|	# Alle 'order only' Voraussetzungen

-

-# Selbst wenn wir die Voraussetzungen der Regel aufteilen, $^ wird sie finden.

-process: ex1.txt file0.txt

-# ex1.txt wird gefunden werden, aber file0.txt wird dedupliziert.

-

-#-----------------------------------------------------------------------

-# Muster

-#-----------------------------------------------------------------------

-

-# Mit Mustern kann man make beibringen wie Dateien in andere Dateien

-# umgewandelt werden.

-

-%.png: %.svg

-	inkscape --export-png $^

-

-# Muster-Vergleichs-Regeln werden nur abgearbeitet, wenn make entscheidet das

-# Ziel zu erzeugen

-

-# Verzeichnis-Pfade werden normalerweise bei Muster-Vergleichs-Regeln ignoriert.

-# Aber make wird versuchen die am besten passende Regel zu verwenden.

-small/%.png: %.svg

-	inkscape --export-png --export-dpi 30 $^

-

-# Make wird die letzte Version einer Muster-Vergleichs-Regel verwenden, die es

-# findet.

-%.png: %.svg

-	@echo this rule is chosen

-

-# Allerdings wird make die erste Muster-Vergleicher-Regel verwenden, die das

-# Ziel erzeugen kann.

-%.png: %.ps

-	@echo this rule is not chosen if *.svg and *.ps are both present

-

-# Make hat bereits ein paar eingebaute Muster-Vergleichs-Regelen. Zum Beispiel

-# weiß Make wie man aus *.c Dateien *.o Dateien erzeugt.

-

-# Ältere Versionen von Make verwenden möglicherweise Suffix-Regeln anstatt

-# Muster-Vergleichs-Regeln.

-.png.ps:

-	@echo this rule is similar to a pattern rule.

-

-# Aktivieren der Suffix-Regel

-.SUFFIXES: .png

-

-#-----------------------------------------------------------------------

-# Variablen

-#-----------------------------------------------------------------------

-# auch Makros genannt.

-

-# Variablen sind im Grunde genommen Zeichenketten-Typen.

-

-name = Ted

-name2="Sarah"

-

-echo:

-	@echo $(name)

-	@echo ${name2}

-	@echo $name    # Das funktioniert nicht, wird als $(n)ame behandelt.

-	@echo $(name3) # Unbekannte Variablen werden als leere Zeichenketten behandelt.

-

-# Es git 4 Stellen um Variablen zu setzen.

-# In Reihenfolge der Priorität von höchster zu niedrigster:

-# 1: Befehls-Zeilen Argumente

-# 2: Makefile

-# 3: Shell Umbebungs-Variablen - Make importiert diese automatisch.

-# 3: MAke hat einige vordefinierte Variablen.

-

-name4 ?= Jean

-# Setze die Variable nur wenn es eine gleichnamige Umgebungs-Variable noch

-# nicht gibt.

-

-override name5 = David

-# Verhindert, dass Kommando-Zeilen Argumente diese Variable ändern können.

-

-name4 +=grey

-# Werte an eine Variable anhängen (inkludiert Leerzeichen).

-

-# Muster-Spezifische Variablen Werte (GNU Erweiterung).

-echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb

-	# rekursiver Voraussetzungen (ausser wenn es den Graphen zerstören

-	# kann, wenn es zu kompilizert wird!)

-

-# Ein paar Variablen, die von Make automatisch definiert werden.

-echo_inbuilt:

-	echo $(CC)

-	echo ${CXX}

-	echo $(FC)

-	echo ${CFLAGS}

-	echo $(CPPFLAGS)

-	echo ${CXXFLAGS}

-	echo $(LDFLAGS)

-	echo ${LDLIBS}

-

-#-----------------------------------------------------------------------

-# Variablen 2

-#-----------------------------------------------------------------------

-

-# Der erste Typ von Variablen wird bei jeder Verwendung ausgewertet.

-# Das kann aufwendig sein, daher exisitert ein zweiter Typ von Variablen.

-# Diese werden nur einmal ausgewertet. (Das ist eine GNU make Erweiterung)

-

-var := hello

-var2 ::=  $(var) hello

-#:= und ::= sind äquivalent.

-

-# Diese Variablen werden prozedural ausgwertet (in der Reihenfolge in der sie

-# auftauchen), die stehen daher im wiederspruch zum Rest der Sprache!

-

-# Das funktioniert nicht

-var3 ::= $(var4) and good luck

-var4 ::= good night

-

-#-----------------------------------------------------------------------

-# Funktionen

-#-----------------------------------------------------------------------

-

-# Make verfügt über eine Vielzahl von Funktionen.

-

-sourcefiles = $(wildcard *.c */*.c)

-objectfiles = $(patsubst %.c,%.o,$(sourcefiles))

-

-# Das Format ist $(func arg0,arg1,arg2...)

-

-# Ein paar Beispiele

-ls:	* src/*

-	@echo $(filter %.txt, $^)

-	@echo $(notdir $^)

-	@echo $(join $(dir $^),$(notdir $^))

-

-#-----------------------------------------------------------------------

-# Direktiven

-#-----------------------------------------------------------------------

-

-# Inkludiere andere Makefile, sehr praktisch für platformspezifischen Code

-include foo.mk

-

-sport = tennis

-# Konditionale kompiliereung

-report:

-ifeq ($(sport),tennis)

-	@echo 'game, set, match'

-else

-	@echo "They think it's all over; it is now"

-endif

-

-# Es gibt auch ifneq, ifdef, ifndef

-

-foo = true

-

-ifdef $(foo)

-bar = 'hello'

-endif

-```

-

-

-### Mehr Resourcen

-

-+ [gnu make documentation](https://www.gnu.org/software/make/manual/)

-+ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/)

-+ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)

-

+---
+category: tool
+tool: 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
+lang: de-de
+---
+
+Eine Makefile definiert einen Graphen von Regeln um ein Ziel (oder Ziele)
+zu erzeugen. Es dient dazu, die geringste Menge an Arbeit zu verrichten um
+ein Ziel in Einklang mit dem Quellcode zu bringen. Make wurde berühmterweise
+von Stuart Feldman 1976 übers Wochenende geschrieben. Make ist noch immer
+sehr verbreitet (vorallem im Unix Umfeld) obwohl es bereits sehr viel
+Konkurrenz und Kritik zu Make gibt.
+
+Es gibt eine Vielzahl an Varianten von Make, dieser Artikel beschäftigt sich
+mit der Version GNU Make. Diese Version ist Standard auf Linux.
+
+```make
+
+# Kommentare können so geschrieben werden.
+
+# Dateien sollten Makefile heißen, denn dann können sie als `make <ziel>`
+# aufgerufen werden. Ansonsten muss `make -f "dateiname" <ziel>` verwendet
+# werden.
+
+# Warnung - Es sollten nur TABULATOREN zur Einrückung im Makefile verwendet
+# werden. Niemals Leerzeichen!
+
+#-----------------------------------------------------------------------
+# Grundlagen
+#-----------------------------------------------------------------------
+
+# Eine Regel - Diese Regel wird nur abgearbeitet wenn die Datei file0.txt
+# nicht existiert.
+file0.txt:
+	echo "foo" > file0.txt
+	# Selbst Kommentare in der 'Rezept' Sektion werden an die Shell
+	# weitergegeben. Versuche `make file0.txt` oder einfach `make`
+	# die erste Regel ist die Standard-Regel.
+
+
+# Diese Regel wird nur abgearbeitet, wenn file0.txt aktueller als file1.txt ist.
+file1.txt: file0.txt
+	cat file0.txt > file1.txt
+	# Verwende die selben Quoting-Regeln wie die Shell
+	@cat file0.txt >> file1.txt
+	# @ unterdrückt die Ausgabe des Befehls an stdout.
+	-@echo 'hello'
+	# - bedeutet, dass Make die Abarbeitung fortsetzt auch wenn Fehler
+    # passieren.
+	# Versuche `make file1.txt` auf der Kommandozeile.
+
+# Eine Regel kann mehrere Ziele und mehrere Voraussetzungen haben.
+file2.txt file3.txt: file0.txt file1.txt
+	touch file2.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
+# Voraussetzungen hinzuzufügen.
+
+#-----------------------------------------------------------------------
+# Phony-Ziele
+#-----------------------------------------------------------------------
+
+# Ein Phony-Ziel ist ein Ziel, das keine Datei ist.
+# Es wird nie aktuell sein, daher wird Make immer versuchen, es abzuarbeiten
+all: maker process
+
+# Es ist erlaubt Dinge ausserhalb der Reihenfolge zu deklarieren.
+maker:
+	touch ex0.txt ex1.txt
+
+# Um das Fehlschlagen von Phony-Regeln zu vermeiden wenn eine echte Datei den
+# selben namen wie ein Phony-Ziel hat:
+.PHONY: all maker process
+# Das ist ein spezielles Ziel. Es gibt noch ein paar mehr davon.
+
+# Eine Regel mit einem Phony-Ziel als Voraussetzung wird immer abgearbeitet
+ex0.txt ex1.txt: maker
+
+# Häufige Phony-Ziele sind: all make clean install ...
+
+#-----------------------------------------------------------------------
+# Automatische Variablen & Wildcards
+#-----------------------------------------------------------------------
+
+process: file*.txt	# Eine Wildcard um Dateinamen zu vergleichen
+	@echo $^	# $^ ist eine Variable die eine Liste aller
+			# Voraussetzungen enthält.
+	@echo $@	# Namen des Ziels ausgeben.
+	#(Bei mehreren Ziel-Regeln enthält $@ den Verursacher der Abarbeitung
+	#der Regel.)
+	@echo $<	# Die erste Voraussetzung aus der Liste
+	@echo $?	# Nur die Voraussetzungen, die nicht aktuell sind.
+	@echo $+	# Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich)
+	#@echo $|	# Alle 'order only' Voraussetzungen
+
+# Selbst wenn wir die Voraussetzungen der Regel aufteilen, $^ wird sie finden.
+process: ex1.txt file0.txt
+# ex1.txt wird gefunden werden, aber file0.txt wird dedupliziert.
+
+#-----------------------------------------------------------------------
+# Muster
+#-----------------------------------------------------------------------
+
+# Mit Mustern kann man make beibringen wie Dateien in andere Dateien
+# umgewandelt werden.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# Muster-Vergleichs-Regeln werden nur abgearbeitet, wenn make entscheidet das
+# Ziel zu erzeugen
+
+# Verzeichnis-Pfade werden normalerweise bei Muster-Vergleichs-Regeln ignoriert.
+# Aber make wird versuchen die am besten passende Regel zu verwenden.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# Make wird die letzte Version einer Muster-Vergleichs-Regel verwenden, die es
+# findet.
+%.png: %.svg
+	@echo this rule is chosen
+
+# Allerdings wird make die erste Muster-Vergleicher-Regel verwenden, die das
+# Ziel erzeugen kann.
+%.png: %.ps
+	@echo this rule is not chosen if *.svg and *.ps are both present
+
+# Make hat bereits ein paar eingebaute Muster-Vergleichs-Regelen. Zum Beispiel
+# weiß Make wie man aus *.c Dateien *.o Dateien erzeugt.
+
+# Ältere Versionen von Make verwenden möglicherweise Suffix-Regeln anstatt
+# Muster-Vergleichs-Regeln.
+.png.ps:
+	@echo this rule is similar to a pattern rule.
+
+# Aktivieren der Suffix-Regel
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variablen
+#-----------------------------------------------------------------------
+# auch Makros genannt.
+
+# Variablen sind im Grunde genommen Zeichenketten-Typen.
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # Das funktioniert nicht, wird als $(n)ame behandelt.
+	@echo $(name3) # Unbekannte Variablen werden als leere Zeichenketten behandelt.
+
+# Es git 4 Stellen um Variablen zu setzen.
+# In Reihenfolge der Priorität von höchster zu niedrigster:
+# 1: Befehls-Zeilen Argumente
+# 2: Makefile
+# 3: Shell Umbebungs-Variablen - Make importiert diese automatisch.
+# 3: MAke hat einige vordefinierte Variablen.
+
+name4 ?= Jean
+# Setze die Variable nur wenn es eine gleichnamige Umgebungs-Variable noch
+# nicht gibt.
+
+override name5 = David
+# Verhindert, dass Kommando-Zeilen Argumente diese Variable ändern können.
+
+name4 +=grey
+# Werte an eine Variable anhängen (inkludiert Leerzeichen).
+
+# Muster-Spezifische Variablen Werte (GNU Erweiterung).
+echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb
+	# rekursiver Voraussetzungen (ausser wenn es den Graphen zerstören
+	# kann, wenn es zu kompilizert wird!)
+
+# Ein paar Variablen, die von Make automatisch definiert werden.
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variablen 2
+#-----------------------------------------------------------------------
+
+# Der erste Typ von Variablen wird bei jeder Verwendung ausgewertet.
+# Das kann aufwendig sein, daher exisitert ein zweiter Typ von Variablen.
+# Diese werden nur einmal ausgewertet. (Das ist eine GNU make Erweiterung)
+
+var := hello
+var2 ::=  $(var) hello
+#:= und ::= sind äquivalent.
+
+# Diese Variablen werden prozedural ausgwertet (in der Reihenfolge in der sie
+# auftauchen), die stehen daher im wiederspruch zum Rest der Sprache!
+
+# Das funktioniert nicht
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funktionen
+#-----------------------------------------------------------------------
+
+# Make verfügt über eine Vielzahl von Funktionen.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# Das Format ist $(func arg0,arg1,arg2...)
+
+# Ein paar Beispiele
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Direktiven
+#-----------------------------------------------------------------------
+
+# Inkludiere andere Makefile, sehr praktisch für platformspezifischen Code
+include foo.mk
+
+sport = tennis
+# Konditionale kompiliereung
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# Es gibt auch ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+
+### Mehr Resourcen
+
++ [gnu make documentation](https://www.gnu.org/software/make/manual/)
++ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/)
++ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
+