From 0ddb15b6b9e124aaaf2109ba5c2b3ac11b1722bb Mon Sep 17 00:00:00 2001 From: Senuros Date: Thu, 9 Feb 2017 16:24:22 +0100 Subject: [yaml/de] improved on german translation for better understanding (#2533) --- de-de/yaml-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown index a46c30f6..54e299ed 100644 --- a/de-de/yaml-de.html.markdown +++ b/de-de/yaml-de.html.markdown @@ -10,7 +10,7 @@ lang: de-de YAML ist eine Sprache zur Datenserialisierung, die sofort von Menschenhand geschrieben und gelesen werden kann. -YAML ist eine Erweiterung von JSON, mit der Erweiterung von syntaktisch wichtigen Zeilenumbrüche und Einrückung sowie in Python. Anders als in Python erlaubt YAML keine Tabulator-Zeichen. +YAML ist ein Superset von JSON mit der Erweiterung um syntaktisch wichtige Zeilenumbrüche und Einrückungen, ähnlich wie auch in Python. Anders als in Python allerdings erlaubt YAML keine Tabulator-Zeichen. ```yaml # Kommentare in YAML schauen so aus. -- cgit v1.2.3 From 5d6fe5601e040455eb5bc9f2a94bcd31332bdd38 Mon Sep 17 00:00:00 2001 From: ven Date: Thu, 9 Feb 2017 16:24:58 +0100 Subject: #2533 --- de-de/yaml-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown index 54e299ed..25f2edc4 100644 --- a/de-de/yaml-de.html.markdown +++ b/de-de/yaml-de.html.markdown @@ -10,7 +10,7 @@ lang: de-de YAML ist eine Sprache zur Datenserialisierung, die sofort von Menschenhand geschrieben und gelesen werden kann. -YAML ist ein Superset von JSON mit der Erweiterung um syntaktisch wichtige Zeilenumbrüche und Einrückungen, ähnlich wie auch in Python. Anders als in Python allerdings erlaubt YAML keine Tabulator-Zeichen. +YAML ist ein Erweiterung von von JSON mit der Erweiterung um syntaktisch wichtige Zeilenumbrüche und Einrückungen, ähnlich wie auch in Python. Anders als in Python allerdings erlaubt YAML keine Tabulator-Zeichen. ```yaml # Kommentare in YAML schauen so aus. -- cgit v1.2.3 From 318522c1186a60798cc4a93f5921e019351770af Mon Sep 17 00:00:00 2001 From: Eike Broda Date: Wed, 15 Feb 2017 15:21:50 +0100 Subject: Add missing closing parenthesis --- de-de/java-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/java-de.html.markdown b/de-de/java-de.html.markdown index 001c6888..934819f9 100644 --- a/de-de/java-de.html.markdown +++ b/de-de/java-de.html.markdown @@ -13,7 +13,7 @@ lang: de-de Java ist eine Programmiersprache für vielfältige Aufgaben. Sie ist imperative und objektorientiert. Oftmals wird sie für Desktop- Webapplikationen sowie als Programmiersprache im Betriebssystem Android verwendet. -[Weitere Informationen \(Englisch\](http://docs.oracle.com/javase/tutorial/java/) +[Weitere Informationen \(Englisch\)](http://docs.oracle.com/javase/tutorial/java/) ```java // Einzeilige Kommentare starten mit // -- cgit v1.2.3 From 281529b1feb5ad4107dac1b0cdc07a196f4666c8 Mon Sep 17 00:00:00 2001 From: Andy Date: Tue, 4 Jul 2017 21:59:52 +0200 Subject: [scala/de] Backport traits keyword explanation (#2781) --- de-de/scala-de.html.markdown | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown index 456403a2..ddadcd8e 100644 --- a/de-de/scala-de.html.markdown +++ b/de-de/scala-de.html.markdown @@ -538,8 +538,9 @@ res2: Boolean = true scala> b.beissen res3: Boolean = false - -// Traits können auch via Mixins (Schlüsselwort "with") eingebunden werden +// Ein Trait kann auch als Mixin eingebunden werden. Die Klasse erbt vom +// ersten Trait mit dem Schlüsselwort "extends", während weitere Traits +// mit "with" verwendet werden können. trait Bellen { def bellen: String = "Woof" -- cgit v1.2.3 From 12ca184dd7dbc13d5921228164cad31c559bffe9 Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 13:29:56 +0545 Subject: Add language code suffix(#2832) --- de-de/java-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/java-de.html.markdown b/de-de/java-de.html.markdown index 934819f9..e8ac5bda 100644 --- a/de-de/java-de.html.markdown +++ b/de-de/java-de.html.markdown @@ -1,6 +1,6 @@ --- language: java -filename: LearnJavaDe.java +filename: LearnJavaDe-de.java contributors: - ["Jake Prather", "http://github.com/JakeHP"] - ["Jakukyo Friel", "http://weakish.github.io"] -- cgit v1.2.3 From be9e47d810e087d2cd123b99495455a0f3607ace Mon Sep 17 00:00:00 2001 From: Jonas Friedemann Grote Date: Fri, 8 Sep 2017 12:38:30 +0200 Subject: Remove trailing spaces. --- de-de/scala-de.html.markdown | 458 +++++++++++++++++++++---------------------- 1 file changed, 229 insertions(+), 229 deletions(-) (limited to 'de-de') diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown index ddadcd8e..ddce3f6b 100644 --- a/de-de/scala-de.html.markdown +++ b/de-de/scala-de.html.markdown @@ -12,12 +12,12 @@ filename: learnscala-de.scala lang: de-de --- -Scala ist eine funktionale und objektorientierte Programmiersprache -für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben -zu erledigen. Scala hat einen akademischen Hintergrund und wurde an +Scala ist eine funktionale und objektorientierte Programmiersprache +für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben +zu erledigen. Scala hat einen akademischen Hintergrund und wurde an der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt. -```scala +```scala /* Scala Umgebung einrichten: @@ -28,9 +28,9 @@ Scala Umgebung einrichten: scala> -Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter. -Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt -ausgegeben. +Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter. +Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt +ausgegeben. Als nächstes beschäftigen wir uns mit ein paar Scala Basics. */ @@ -42,25 +42,25 @@ Als nächstes beschäftigen wir uns mit ein paar Scala Basics. // Einzeilige Kommentare beginnen mit zwei Slashes /* - Mehrzeilige Kommentare, starten + Mehrzeilige Kommentare, starten mit einem Slash-Stern und enden mit einem Stern-Slash */ -// Einen Wert, und eine zusätzliche neue Zeile ausgeben +// Einen Wert, und eine zusätzliche neue Zeile ausgeben println("Hello world!") println(10) -// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben +// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben print("Hello world") /* - Variablen werden entweder mit var oder val deklariert. - Deklarationen mit val sind immutable, also unveränderlich - Deklarationen mit var sind mutable, also veränderlich - Immutability ist gut. + Variablen werden entweder mit var oder val deklariert. + Deklarationen mit val sind immutable, also unveränderlich + Deklarationen mit var sind mutable, also veränderlich + Immutability ist gut. */ val x = 10 // x ist 10 x = 20 // error: reassignment to val @@ -68,29 +68,29 @@ var y = 10 y = 20 // y ist jetzt 20 /* -Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel -keine Typen an x und y geschrieben haben. -In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der -Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist, -so dass der Typ nicht jedes mal angegeben werden muss. -Einen Typ gibt man bei einer Variablendeklaration wie folgt an: +Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel +keine Typen an x und y geschrieben haben. +In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der +Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist, +so dass der Typ nicht jedes mal angegeben werden muss. +Einen Typ gibt man bei einer Variablendeklaration wie folgt an: */ val z: Int = 10 val a: Double = 1.0 -// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0 +// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0 val b: Double = 10 -// Boolean Werte +// Boolean Werte true false -// Boolean Operationen +// Boolean Operationen !true // false !false // true @@ -98,7 +98,7 @@ true == false // false 10 > 5 // true -// Mathematische Operationen sind wie gewohnt +// Mathematische Operationen sind wie gewohnt 1 + 1 // 2 2 - 1 // 1 @@ -108,44 +108,44 @@ true == false // false 6.0 / 4 // 1.5 -// Die Auswertung eines Ausdrucks in der REPL gibt den Typ -// und das Ergebnis zurück. +// Die Auswertung eines Ausdrucks in der REPL gibt den Typ +// und das Ergebnis zurück. scala> 1 + 7 res29: Int = 8 /* -Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt -von Typ Int ist und einen Wert 0 hat. -"res29" ist ein sequentiell generierter name, um das Ergebnis des -Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein... +Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt +von Typ Int ist und einen Wert 0 hat. +"res29" ist ein sequentiell generierter name, um das Ergebnis des +Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein... */ -"Scala strings werden in doppelten Anführungszeichen eingeschlossen" -'a' // A Scala Char -// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error - -// Für Strings gibt es die üblichen Java Methoden +"Scala strings werden in doppelten Anführungszeichen eingeschlossen" +'a' // A Scala Char +// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error + +// Für Strings gibt es die üblichen Java Methoden "hello world".length "hello world".substring(2, 6) "hello world".replace("C", "3") -// Zusätzlich gibt es noch extra Scala Methoden -// siehe: scala.collection.immutable.StringOps +// Zusätzlich gibt es noch extra Scala Methoden +// siehe: scala.collection.immutable.StringOps "hello world".take(5) "hello world".drop(5) -// String interpolation: prefix "s" +// String interpolation: prefix "s" val n = 45 s"We have $n apples" // => "We have 45 apples" -// Ausdrücke im Innern von interpolierten Strings gibt es auch +// Ausdrücke im Innern von interpolierten Strings gibt es auch val a = Array(11, 9, 6) val n = 100 @@ -154,42 +154,42 @@ s"We have double the amount of ${n / 2.0} in apples." // => "We have double the s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4" -// Formatierung der interpolierten Strings mit dem prefix "f" +// Formatierung der interpolierten Strings mit dem prefix "f" f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25" f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454" -// Raw Strings, ignorieren Sonderzeichen. +// Raw Strings, ignorieren Sonderzeichen. raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r." -// Manche Zeichen müssen "escaped" werden, z.B. -// ein doppeltes Anführungszeichen in innern eines Strings. +// Manche Zeichen müssen "escaped" werden, z.B. +// ein doppeltes Anführungszeichen in innern eines Strings. "They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown"" -// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht -// und Anführungszeichen enthalten kann. +// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht +// und Anführungszeichen enthalten kann. val html = """

Press belo', Joe

""" - + ///////////////////////////////////////////////// // 2. Funktionen ///////////////////////////////////////////////// -// Funktionen werden so definiert -// -// def functionName(args...): ReturnType = { body... } -// -// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck -// in einer Funktion der Rückgabewert. +// Funktionen werden so definiert +// +// def functionName(args...): ReturnType = { body... } +// +// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck +// in einer Funktion der Rückgabewert. def sumOfSquares(x: Int, y: Int): Int = { val x2 = x * x @@ -198,75 +198,75 @@ def sumOfSquares(x: Int, y: Int): Int = { } -// Die geschweiften Klammern können weggelassen werden, wenn -// die Funktion nur aus einem einzigen Ausdruck besteht: +// Die geschweiften Klammern können weggelassen werden, wenn +// die Funktion nur aus einem einzigen Ausdruck besteht: def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y -// Syntax für Funktionsaufrufe: +// Syntax für Funktionsaufrufe: sumOfSquares(3, 4) // => 25 -// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können -// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei -// Variablen, auch bei Funktionen greift: +// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können +// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei +// Variablen, auch bei Funktionen greift: def sq(x: Int) = x * x // Compiler errät, dass der return type Int ist -// Funktionen können default parameter haben: +// Funktionen können default parameter haben: def addWithDefault(x: Int, y: Int = 5) = x + y addWithDefault(1, 2) // => 3 addWithDefault(1) // => 6 -// Anonyme Funktionen sehen so aus: +// Anonyme Funktionen sehen so aus: (x: Int) => x * x -// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen -// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist. -// Beachte den Typ "Int => Int", dies beschreibt eine Funktion, -// welche Int als Parameter erwartet und Int zurückgibt. +// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen +// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist. +// Beachte den Typ "Int => Int", dies beschreibt eine Funktion, +// welche Int als Parameter erwartet und Int zurückgibt. val sq: Int => Int = x => x * x -// Anonyme Funktionen benutzt man ganz normal: +// Anonyme Funktionen benutzt man ganz normal: sq(10) // => 100 -// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird, -// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen, -// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge -// verwendet werden. Diese anonymen Funktionen werden sehr häufig -// verwendet. +// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird, +// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen, +// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge +// verwendet werden. Diese anonymen Funktionen werden sehr häufig +// verwendet. -val addOne: Int => Int = _ + 1 -val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3) -addOne(5) // => 6 -weirdSum(2, 4) // => 16 +val addOne: Int => Int = _ + 1 +val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3) +addOne(5) // => 6 +weirdSum(2, 4) // => 16 -// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung -// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus -// dem innersten def, welches den return Ausdruck umgibt, zurück. -// "return" hat keinen Effekt in anonymen Funktionen: +// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung +// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus +// dem innersten def, welches den return Ausdruck umgibt, zurück. +// "return" hat keinen Effekt in anonymen Funktionen: -def foo(x: Int): Int = { - val anonFunc: Int => Int = { z => - if (z > 5) - return z // Zeile macht z zum return Wert von foo - else - z + 2 // Zeile ist der return Wert von anonFunc - } - anonFunc(x) // Zeile ist der return Wert von foo -} +def foo(x: Int): Int = { + val anonFunc: Int => Int = { z => + if (z > 5) + return z // Zeile macht z zum return Wert von foo + else + z + 2 // Zeile ist der return Wert von anonFunc + } + anonFunc(x) // Zeile ist der return Wert von foo +} ///////////////////////////////////////////////// @@ -280,25 +280,25 @@ val r = 1 to 5 r.foreach(println) r foreach println (5 to 1 by -1) foreach (println) - -// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende -// sind optional, beim Aufruf von Methoden können die Punkte -// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden -// while Schleife +// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende +// sind optional, beim Aufruf von Methoden können die Punkte +// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden + +// while Schleife var i = 0 while (i < 10) { println("i " + i); i += 1 } i // i ausgeben, res3: Int = 10 -// Beachte: while ist eine Schleife im klassischen Sinne - -// Sie läuft sequentiell ab und verändert die loop-Variable. -// While in Scala läuft schneller ab als in Java und die o.g. -// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen +// Beachte: while ist eine Schleife im klassischen Sinne - +// Sie läuft sequentiell ab und verändert die loop-Variable. +// While in Scala läuft schneller ab als in Java und die o.g. +// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen // und zu parellelisieren. -// Ein do while Schleife +// Ein do while Schleife do { println("x ist immer noch weniger wie 10") @@ -306,10 +306,10 @@ do { } while (x < 10) -// Endrekursionen sind ideomatisch um sich wiederholende -// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen -// return Typ, der Compiler kann ihn nicht erraten. -// Unit, in diesem Beispiel. +// Endrekursionen sind ideomatisch um sich wiederholende +// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen +// return Typ, der Compiler kann ihn nicht erraten. +// Unit, in diesem Beispiel. def showNumbersInRange(a: Int, b: Int): Unit = { print(a) @@ -360,7 +360,7 @@ val s = Set(1,1,3,3,7) s: scala.collection.immutable.Set[Int] = Set(1, 3, 7) // Tuple - Speichert beliebige Daten und "verbindet" sie miteinander -// Ein Tuple ist keine Collection. +// Ein Tuple ist keine Collection. (1, 2) (4, 3, 2) @@ -368,15 +368,15 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7) (a, 2, "three") -// Hier ist der Rückgabewert der Funktion ein Tuple -// Die Funktion gibt das Ergebnis, so wie den Rest zurück. +// Hier ist der Rückgabewert der Funktion ein Tuple +// Die Funktion gibt das Ergebnis, so wie den Rest zurück. val divideInts = (x: Int, y: Int) => (x / y, x % y) divideInts(10, 3) -// Um die Elemente eines Tuples anzusprechen, benutzt man diese -// Notation: _._n wobei n der index des Elements ist (Index startet bei 1) +// Um die Elemente eines Tuples anzusprechen, benutzt man diese +// Notation: _._n wobei n der index des Elements ist (Index startet bei 1) val d = divideInts(10, 3) d._1 @@ -388,32 +388,32 @@ d._2 ///////////////////////////////////////////////// /* - Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar - zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in - einem Scala file selten alleine zu finden sind. - Die einzigen Top-Level Konstrukte in Scala sind nämlich: + Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar + zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in + einem Scala file selten alleine zu finden sind. + Die einzigen Top-Level Konstrukte in Scala sind nämlich: - Klassen (classes) - Objekte (objects) - case classes - traits - Diesen Sprachelemente wenden wir uns jetzt zu. + Diesen Sprachelemente wenden wir uns jetzt zu. */ // Klassen -// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen -// anderen Sprachen auch. +// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen +// anderen Sprachen auch. -// erzeugt Klasse mit default Konstruktor +// erzeugt Klasse mit default Konstruktor class Hund scala> val t = new Hund t: Hund = Hund@7103745 -// Der Konstruktor wird direkt hinter dem Klassennamen deklariert. +// Der Konstruktor wird direkt hinter dem Klassennamen deklariert. class Hund(sorte: String) scala> val t = new Hund("Dackel") @@ -421,8 +421,8 @@ t: Hund = Hund@14be750c scala> t.sorte //error: value sorte is not a member of Hund -// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse -// Per var wird aus dem Attribut ein veränderliches Feld der Klasse +// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse +// Per var wird aus dem Attribut ein veränderliches Feld der Klasse class Hund(val sorte: String) scala> val t = new Hund("Dackel") @@ -431,14 +431,14 @@ scala> t.sorte res18: String = Dackel -// Methoden werden mit def geschrieben +// Methoden werden mit def geschrieben def bark = "Woof, woof!" -// Felder und Methoden können public, protected und private sein -// default ist public -// private ist nur innerhalb des deklarierten Bereichs sichtbar +// Felder und Methoden können public, protected und private sein +// default ist public +// private ist nur innerhalb des deklarierten Bereichs sichtbar class Hund { private def x = ... @@ -446,8 +446,8 @@ class Hund { } -// protected ist nur innerhalb des deklarierten und aller -// erbenden Bereiche sichtbar +// protected ist nur innerhalb des deklarierten und aller +// erbenden Bereiche sichtbar class Hund { protected def x = ... @@ -457,12 +457,12 @@ class Dackel extends Hund { } // Object -// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog. -// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so -// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse -// benutzen ohne ein Objekt instanziieren zu müssen. -// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn -// es genauso heisst und in derselben Datei wie die Klasse definiert wurde. +// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog. +// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so +// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse +// benutzen ohne ein Objekt instanziieren zu müssen. +// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn +// es genauso heisst und in derselben Datei wie die Klasse definiert wurde. object Hund { def alleSorten = List("Pitbull", "Dackel", "Retriever") @@ -470,50 +470,50 @@ object Hund { } // Case classes -// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra -// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar -// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B. -// ein companion object mit den entsprechenden Methoden, -// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch -// Getter für unsere Attribute (das Angeben von val entfällt dadurch) +// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra +// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar +// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B. +// ein companion object mit den entsprechenden Methoden, +// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch +// Getter für unsere Attribute (das Angeben von val entfällt dadurch) class Person(val name: String) class Hund(val sorte: String, val farbe: String, val halter: Person) -// Es genügt das Schlüsselwort case vor die Klasse zu schreiben. +// Es genügt das Schlüsselwort case vor die Klasse zu schreiben. case class Person(name: String) case class Hund(sorte: String, farbe: String, halter: Person) -// Für neue Instanzen brauch man kein "new" +// Für neue Instanzen brauch man kein "new" val dackel = Hund("dackel", "grau", Person("peter")) val dogge = Hund("dogge", "grau", Person("peter")) - -// getter + +// getter dackel.halter // => Person = Person(peter) - -// equals + +// equals dogge == dackel // => false - -// copy -// otherGeorge == Person("george", "9876") + +// copy +// otherGeorge == Person("george", "9876") val otherGeorge = george.copy(phoneNumber = "9876") // Traits -// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp -// und Methodensignaturen. Scala erlaubt allerdings das teilweise -// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt. -// Traits können von anderen Traits oder Klassen erben, aber nur von -// parameterlosen. +// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp +// und Methodensignaturen. Scala erlaubt allerdings das teilweise +// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt. +// Traits können von anderen Traits oder Klassen erben, aber nur von +// parameterlosen. trait Hund { def sorte: String @@ -527,16 +527,16 @@ class Bernhardiner extends Hund{ def beissen = false } - -scala> b -res0: Bernhardiner = Bernhardiner@3e57cd70 -scala> b.sorte -res1: String = Bernhardiner -scala> b.bellen -res2: Boolean = true -scala> b.beissen -res3: Boolean = false + +scala> b +res0: Bernhardiner = Bernhardiner@3e57cd70 +scala> b.sorte +res1: String = Bernhardiner +scala> b.bellen +res2: Boolean = true +scala> b.beissen +res3: Boolean = false // Ein Trait kann auch als Mixin eingebunden werden. Die Klasse erbt vom // ersten Trait mit dem Schlüsselwort "extends", während weitere Traits @@ -562,11 +562,11 @@ res0: String = Woof // 6. Pattern Matching ///////////////////////////////////////////////// -// Pattern matching in Scala ist ein sehr nützliches und wesentlich -// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala -// benötigt ein case Statement kein "break", ein fall-through gibt es nicht. -// Mehrere Überprüfungen können mit einem Statement gemacht werden. -// Pattern matching wird mit dem Schlüsselwort "match" gemacht. +// Pattern matching in Scala ist ein sehr nützliches und wesentlich +// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala +// benötigt ein case Statement kein "break", ein fall-through gibt es nicht. +// Mehrere Überprüfungen können mit einem Statement gemacht werden. +// Pattern matching wird mit dem Schlüsselwort "match" gemacht. val x = ... x match { @@ -576,7 +576,7 @@ x match { } -// Pattern Matching kann auf beliebige Typen prüfen +// Pattern Matching kann auf beliebige Typen prüfen val any: Any = ... val gleicht = any match { @@ -588,7 +588,7 @@ val gleicht = any match { } -// und auf Objektgleichheit +// und auf Objektgleichheit def matchPerson(person: Person): String = person match { case Person("George", nummer) => "George! Die Nummer ist " + number @@ -597,7 +597,7 @@ def matchPerson(person: Person): String = person match { } -// Und viele mehr... +// Und viele mehr... val email = "(.*)@(.*)".r // regex def matchEverything(obj: Any): String = obj match { @@ -620,8 +620,8 @@ def matchEverything(obj: Any): String = obj match { } -// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden -// Ganze Funktionen können Patterns sein +// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden +// Ganze Funktionen können Patterns sein val patternFunc: Person => String = { case Person("George", number) => s"George's number: $number" @@ -633,13 +633,13 @@ val patternFunc: Person => String = { // 37. Higher-order functions ///////////////////////////////////////////////// -Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden -als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen -higher-order functions -Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für -die meisten anderen Collection Typen, sowie andere Klassen in Scala -Nennenswerte sind: -"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall" +Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden +als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen +higher-order functions +Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für +die meisten anderen Collection Typen, sowie andere Klassen in Scala +Nennenswerte sind: +"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall" ## List @@ -649,39 +649,39 @@ val resultExists4 = list.exists(isEqualToFour) ## map -// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt -// eine neue Liste - -// Funktion erwartet ein Int und returned ein Int +// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt +// eine neue Liste -val add10: Int => Int = _ + 10 +// Funktion erwartet ein Int und returned ein Int +val add10: Int => Int = _ + 10 -// add10 wird auf jedes Element angewendet + +// add10 wird auf jedes Element angewendet List(1, 2, 3) map add10 // => List(11, 12, 13) -// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden +// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden List(1, 2, 3) map (x => x + 10) -// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion -// verwendet. Er wird an die Variable gebunden. +// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion +// verwendet. Er wird an die Variable gebunden. List(1, 2, 3) map (_ + 10) -// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten, -// kann sogar der Unterstrich weggelassen werden. +// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten, +// kann sogar der Unterstrich weggelassen werden. List("Dom", "Bob", "Natalia") foreach println // filter -// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet -// alle Elemente die auf das Prädikat passen +// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet +// alle Elemente die auf das Prädikat passen List(1, 2, 3) filter (_ > 2) // => List(3) case class Person(name: String, age: Int) @@ -692,19 +692,19 @@ List( // reduce -// reduce nimmt zwei Elemente und kombiniert sie zu einem Element, -// und zwar solange bis nur noch ein Element da ist. +// reduce nimmt zwei Elemente und kombiniert sie zu einem Element, +// und zwar solange bis nur noch ein Element da ist. // foreach -// foreach gibt es für einige Collections +// foreach gibt es für einige Collections val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) aListOfNumbers foreach (x => println(x)) aListOfNumbers foreach println // For comprehensions -// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets. -// Dies ist keine for-Schleife. +// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets. +// Dies ist keine for-Schleife. for { n <- s } yield sq(n) val nSquared2 = for { n <- s } yield sq(n) @@ -716,58 +716,58 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared // 8. Implicits ///////////////////////////////////////////////// -// **ACHTUNG:** +// **ACHTUNG:** // Implicits sind ein sehr mächtiges Sprachfeature von Scala. -// Es sehr einfach -// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am -// besten erst dann benutzen, wenn man versteht wie sie funktionieren. -// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle -// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles -// machen kann. -// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren. +// Es sehr einfach +// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am +// besten erst dann benutzen, wenn man versteht wie sie funktionieren. +// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle +// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles +// machen kann. +// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren. -// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte -// zu "implicit Methods" werden. +// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte +// zu "implicit Methods" werden. implicit val myImplicitInt = 100 implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte) -// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion +// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion myImplicitInt + 2 // => 102 myImplicitFunction("Pitbull").sorte // => "Golden Pitbull" -// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein -// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von -// implicit Funktionsparametern - -// Diese Funktion hat zwei Parameter: einen normalen und einen implicit +// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein +// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von +// implicit Funktionsparametern + +// Diese Funktion hat zwei Parameter: einen normalen und einen implicit def sendGreetings(toWhom: String)(implicit howMany: Int) = s"Hello $toWhom, $howMany blessings to you and yours!" -// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet +// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" -// Wird der implicit Parameter jedoch weggelassen, wird ein anderer -// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im -// lexikalischen Scope und im companion object nach einem implicit Wert, -// der vom Typ passt, oder nach einer implicit Methode mit der er in den -// geforderten Typ konvertieren kann. - -// Hier also: "myImplicitInt", da ein Int gesucht wird +// Wird der implicit Parameter jedoch weggelassen, wird ein anderer +// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im +// lexikalischen Scope und im companion object nach einem implicit Wert, +// der vom Typ passt, oder nach einer implicit Methode mit der er in den +// geforderten Typ konvertieren kann. + +// Hier also: "myImplicitInt", da ein Int gesucht wird sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" -// bzw. "myImplicitFunction" -// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und -// dann wird die Methode aufgerufen +// bzw. "myImplicitFunction" +// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und +// dann wird die Methode aufgerufen "Retriever".sorte // => "Golden Retriever" @@ -780,27 +780,27 @@ sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" import scala.collection.immutable.List -// Importiere alle Unterpackages +// Importiere alle Unterpackages import scala.collection.immutable._ -// Importiere verschiedene Klassen mit einem Statement +// Importiere verschiedene Klassen mit einem Statement import scala.collection.immutable.{List, Map} -// Einen Import kann man mit '=>' umbenennen +// Einen Import kann man mit '=>' umbenennen import scala.collection.immutable.{List => ImmutableList} -// Importiere alle Klasses, mit Ausnahem von.... -// Hier ohne: Map and Set: +// Importiere alle Klasses, mit Ausnahem von.... +// Hier ohne: Map and Set: import scala.collection.immutable.{Map => _, Set => _, _} -// Main +// Main object Application { def main(args: Array[String]): Unit = { @@ -810,14 +810,14 @@ object Application { // I/O -// Eine Datei Zeile für Zeile lesen +// Eine Datei Zeile für Zeile lesen import scala.io.Source for(line <- Source.fromFile("myfile.txt").getLines()) println(line) -// Eine Datei schreiben +// Eine Datei schreiben val writer = new PrintWriter("myfile.txt") writer.write("Schreibe Zeile" + util.Properties.lineSeparator) @@ -826,7 +826,7 @@ writer.close() ``` -## Weiterführende Hinweise +## Weiterführende Hinweise // DE * [Scala Tutorial](https://scalatutorial.wordpress.com) -- cgit v1.2.3 From 147907afc60e9cf1581e6a9dfae5492cf2e203fb Mon Sep 17 00:00:00 2001 From: Jonas Friedemann Grote Date: Fri, 8 Sep 2017 13:54:54 +0200 Subject: Review translation. --- de-de/scala-de.html.markdown | 221 ++++++++++++++++++++++--------------------- 1 file changed, 111 insertions(+), 110 deletions(-) (limited to 'de-de') diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown index ddce3f6b..8b0dc5f0 100644 --- a/de-de/scala-de.html.markdown +++ b/de-de/scala-de.html.markdown @@ -8,6 +8,7 @@ contributors: - ["Dennis Keller", "github.com/denniskeller"] translators: - ["Christian Albrecht", "https://github.com/coastalchief"] + - ["Jonas Grote", "https://github.com/exic"] filename: learnscala-de.scala lang: de-de --- @@ -19,11 +20,11 @@ der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt. ```scala /* -Scala Umgebung einrichten: +Scala-Umgebung einrichten: 1. Scala binaries herunterladen- http://www.scala-lang.org/downloads 2. Unzip/untar in ein Verzeichnis -3. das bin Unterverzeichnis der `PATH` Umgebungsvariable hinzufügen +3. das Unterverzeichnis `bin` der `PATH`-Umgebungsvariable hinzufügen 4. Mit dem Kommando `scala` wird die REPL gestartet und zeigt als Prompt: scala> @@ -31,47 +32,47 @@ scala> Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter. Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt ausgegeben. -Als nächstes beschäftigen wir uns mit ein paar Scala Basics. +Als nächstes beschäftigen wir uns mit ein paar Scala-Grundlagen. */ ///////////////////////////////////////////////// -// 1. Basics +// 1. Grundlagen ///////////////////////////////////////////////// -// Einzeilige Kommentare beginnen mit zwei Slashes +// Einzeilige Kommentare beginnen mit zwei Slashes. /* - Mehrzeilige Kommentare, starten - mit einem Slash-Stern und enden mit einem Stern-Slash + Mehrzeilige Kommentare starten mit einem Slash-Stern + und enden mit einem Stern-Slash. */ -// Einen Wert, und eine zusätzliche neue Zeile ausgeben +// Einen Wert und eine zusätzliche neue Zeile ausgeben: println("Hello world!") println(10) -// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben +// Einen Wert ohne eine zusätzliche neue Zeile ausgeben: print("Hello world") /* Variablen werden entweder mit var oder val deklariert. - Deklarationen mit val sind immutable, also unveränderlich - Deklarationen mit var sind mutable, also veränderlich + Deklarationen mit val sind immutable, also unveränderlich. + Deklarationen mit var sind mutable, also veränderlich. Immutability ist gut. */ val x = 10 // x ist 10 -x = 20 // error: reassignment to val +x = 20 // Error: reassignment to val (Fehler: neue Zuweisung zu einem unveränderlichen Wert) var y = 10 y = 20 // y ist jetzt 20 /* Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel keine Typen an x und y geschrieben haben. -In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der -Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist, +In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt, dass der +Scala Compiler in den meisten Fällen erraten kann, von welchem Typ eine Variable ist, so dass der Typ nicht jedes mal angegeben werden muss. Einen Typ gibt man bei einer Variablendeklaration wie folgt an: */ @@ -79,18 +80,18 @@ val z: Int = 10 val a: Double = 1.0 -// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0 +// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0: val b: Double = 10 -// Boolean Werte +// Boolean-Werte: true false -// Boolean Operationen +// Boolean-Operationen: !true // false !false // true @@ -98,7 +99,7 @@ true == false // false 10 > 5 // true -// Mathematische Operationen sind wie gewohnt +// Mathematische Operationen sind wie gewohnt: 1 + 1 // 2 2 - 1 // 1 @@ -109,73 +110,72 @@ true == false // false // Die Auswertung eines Ausdrucks in der REPL gibt den Typ -// und das Ergebnis zurück. +// und das Ergebnis zurück: scala> 1 + 7 res29: Int = 8 /* Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt -von Typ Int ist und einen Wert 0 hat. -"res29" ist ein sequentiell generierter name, um das Ergebnis des +von Typ Int ist und einen Wert 8 hat. +"res29" ist ein sequentiell generierter Name, um das Ergebnis des Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein... */ "Scala strings werden in doppelten Anführungszeichen eingeschlossen" -'a' // A Scala Char -// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error +'a' // Ein Scala Char +// 'Einzeln ge-quotete strings gibt es nicht!' <= Das erzeugt einen Fehler! -// Für Strings gibt es die üblichen Java Methoden +// Für Strings gibt es die üblichen Java-Methoden: "hello world".length "hello world".substring(2, 6) "hello world".replace("C", "3") -// Zusätzlich gibt es noch extra Scala Methoden +// Zusätzlich gibt es noch extra Scala-Methoden // siehe: scala.collection.immutable.StringOps "hello world".take(5) "hello world".drop(5) -// String interpolation: prefix "s" +// String-Interpolation: prefix "s": val n = 45 -s"We have $n apples" // => "We have 45 apples" +s"Wir haben $n Äpfel" // => "Wir haben 45 Äpfel" -// Ausdrücke im Innern von interpolierten Strings gibt es auch +// Ausdrücke im Innern von interpolierten Strings gibt es auch: val a = Array(11, 9, 6) -val n = 100 -s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old." -s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples." -s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4" +s"Meine zweite Tochter ist ${a(0) - a(2)} Jahre alt." // => "Meine zweite Tochter ist 5 Jahre alt." +s"Wir haben das Doppelte von ${n / 2.0} an Äpfeln." // => "Wir haben das Doppelte von 22.5 an Äpfeln." +s"2 im Quadrat: ${math.pow(2, 2)}" // => "2 im Quadrat: 4" -// Formatierung der interpolierten Strings mit dem prefix "f" +// Formatierung der interpolierten Strings mit dem prefix "f": -f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25" -f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454" +f"5 im Quadrat: ${math.pow(5, 2)}%1.0f" // "5 im Quadrat: 25" +f"Quadratwurzel von 122: ${math.sqrt(122)}%1.4f" // "Quadratwurzel von 122: 11.0454" -// Raw Strings, ignorieren Sonderzeichen. +// Raw Strings ignorieren Sonderzeichen: raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r." // Manche Zeichen müssen "escaped" werden, z.B. -// ein doppeltes Anführungszeichen in innern eines Strings. +// ein doppeltes Anführungszeichen im Innern eines Strings: -"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown"" +"Sie standen vor der \"Rose and Crown\"" // => "Sie standen vor der "Rose and Crown"" // Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht -// und Anführungszeichen enthalten kann. +// und Anführungszeichen enthalten kann: -val html = """
-

Press belo', Joe

+val html = """ +

Drück belo', Joe

""" @@ -184,12 +184,12 @@ val html = """
// 2. Funktionen ///////////////////////////////////////////////// -// Funktionen werden so definiert +// Funktionen werden so definiert: // // def functionName(args...): ReturnType = { body... } // -// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck -// in einer Funktion der Rückgabewert. +// Beachte: Es wird hier kein Schlüsselwort "return" verwendet. +// In Scala ist der letzte Ausdruck in einer Funktion der Rückgabewert. def sumOfSquares(x: Int, y: Int): Int = { val x2 = x * x @@ -209,14 +209,14 @@ def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y sumOfSquares(3, 4) // => 25 -// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können -// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei +// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen) können +// Rückgabetypen auch weggelassen werden, da dieselbe Typ-Inferenz, wie bei // Variablen, auch bei Funktionen greift: def sq(x: Int) = x * x // Compiler errät, dass der return type Int ist -// Funktionen können default parameter haben: +// Funktionen können Default-Parameter haben: def addWithDefault(x: Int, y: Int = 5) = x + y addWithDefault(1, 2) // => 3 @@ -253,7 +253,7 @@ addOne(5) // => 6 weirdSum(2, 4) // => 16 -// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung +// Es gibt ein Schlüsselwort "return" in Scala. Allerdings ist seine Verwendung // nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus // dem innersten def, welches den return Ausdruck umgibt, zurück. // "return" hat keinen Effekt in anonymen Funktionen: @@ -270,10 +270,10 @@ def foo(x: Int): Int = { ///////////////////////////////////////////////// -// 3. Flow Control +// 3. Flusskontrolle ///////////////////////////////////////////////// -// Wertebereiche und Schleifen +// Wertebereiche und Schleifen: 1 to 5 val r = 1 to 5 @@ -281,11 +281,11 @@ r.foreach(println) r foreach println (5 to 1 by -1) foreach (println) -// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende +// Scala ist syntaktisch sehr großzügig; Semikolons am Zeilenende // sind optional, beim Aufruf von Methoden können die Punkte -// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden +// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden. -// while Schleife +// while Schleife: var i = 0 while (i < 10) { println("i " + i); i += 1 } @@ -294,22 +294,22 @@ i // i ausgeben, res3: Int = 10 // Beachte: while ist eine Schleife im klassischen Sinne - // Sie läuft sequentiell ab und verändert die loop-Variable. -// While in Scala läuft schneller ab als in Java und die o.g. +// "while" in Scala läuft schneller ab als in Java und die o.g. // Kombinatoren und Zusammenlegungen sind einfacher zu verstehen // und zu parellelisieren. // Ein do while Schleife do { - println("x ist immer noch weniger wie 10") + println("x ist immer noch weniger als 10") x += 1 } while (x < 10) -// Endrekursionen sind ideomatisch um sich wiederholende -// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen -// return Typ, der Compiler kann ihn nicht erraten. -// Unit, in diesem Beispiel. +// Endrekursionen sind idiomatisch um sich wiederholende +// Aufgaben in Scala zu lösen. Rekursive Funtionen benötigen explizit einen +// Rückgabe-Typ, der Compiler kann ihn nicht erraten. +// Der Rückgabe-Typ in diesem Beispiel ist Unit: def showNumbersInRange(a: Int, b: Int): Unit = { print(a) @@ -331,7 +331,7 @@ val text = if (x == 10) "yeah" else "nope" ///////////////////////////////////////////////// -// 4. Daten Strukturen (Array, Map, Set, Tuples) +// 4. Datenstrukturen (Array, Map, Set, Tuples) ///////////////////////////////////////////////// // Array @@ -344,11 +344,11 @@ a(21) // Exception // Map - Speichert Key-Value-Paare -val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +val m = Map("fork" -> "Gabel", "spoon" -> "Löffel", "knife" -> "Messer") m("fork") m("spoon") m("bottle") // Exception -val safeM = m.withDefaultValue("no lo se") +val safeM = m.withDefaultValue("unbekannt") safeM("bottle") // Set - Speichert Unikate, unsortiert (sortiert -> SortedSet) @@ -369,7 +369,7 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7) // Hier ist der Rückgabewert der Funktion ein Tuple -// Die Funktion gibt das Ergebnis, so wie den Rest zurück. +// Die Funktion gibt das Ergebnis sowie den Rest zurück. val divideInts = (x: Int, y: Int) => (x / y, x % y) divideInts(10, 3) @@ -390,8 +390,8 @@ d._2 /* Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in - einem Scala file selten alleine zu finden sind. - Die einzigen Top-Level Konstrukte in Scala sind nämlich: + einer Scala-Datei selten alleine zu finden sind. + Die einzigen Top-Level-Konstrukte in Scala sind nämlich: - Klassen (classes) - Objekte (objects) @@ -406,7 +406,7 @@ d._2 // Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen // anderen Sprachen auch. -// erzeugt Klasse mit default Konstruktor +// erzeugt Klasse mit default Konstruktor: class Hund scala> val t = new Hund @@ -433,7 +433,7 @@ res18: String = Dackel // Methoden werden mit def geschrieben -def bark = "Woof, woof!" +def bark = "Wuff, wuff!" // Felder und Methoden können public, protected und private sein @@ -460,9 +460,9 @@ class Dackel extends Hund { // Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog. // "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so // ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse -// benutzen ohne ein Objekt instanziieren zu müssen. +// verwenden, ohne ein Objekt instanziieren zu müssen. // Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn -// es genauso heisst und in derselben Datei wie die Klasse definiert wurde. +// es genauso heißt und in derselben Datei wie die Klasse definiert wurde. object Hund { def alleSorten = List("Pitbull", "Dackel", "Retriever") @@ -470,8 +470,9 @@ object Hund { } // Case classes -// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra -// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar +// Fallklassen bzw. Case classes sind Klassen, die normale Klassen um +// zusätzliche Funktionalität erweitern. +// Mit Case-Klassen bekommt man ein paar // Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B. // ein companion object mit den entsprechenden Methoden, // Hilfsmethoden wie toString(), equals() und hashCode() und auch noch @@ -481,13 +482,13 @@ class Person(val name: String) class Hund(val sorte: String, val farbe: String, val halter: Person) -// Es genügt das Schlüsselwort case vor die Klasse zu schreiben. +// Es genügt, das Schlüsselwort case vor die Klasse zu schreiben: case class Person(name: String) case class Hund(sorte: String, farbe: String, halter: Person) -// Für neue Instanzen brauch man kein "new" +// Für neue Instanzen braucht man kein "new": val dackel = Hund("dackel", "grau", Person("peter")) val dogge = Hund("dogge", "grau", Person("peter")) @@ -511,7 +512,7 @@ val otherGeorge = george.copy(phoneNumber = "9876") // Traits // Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp // und Methodensignaturen. Scala erlaubt allerdings das teilweise -// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt. +// Implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt. // Traits können von anderen Traits oder Klassen erben, aber nur von // parameterlosen. @@ -543,7 +544,7 @@ res3: Boolean = false // mit "with" verwendet werden können. trait Bellen { - def bellen: String = "Woof" + def bellen: String = "Wuff" } trait Hund { def sorte: String @@ -556,10 +557,10 @@ class Bernhardiner extends Hund with Bellen{ scala> val b = new Bernhardiner b: Bernhardiner = Bernhardiner@7b69c6ba scala> b.bellen -res0: String = Woof +res0: String = Wuff ///////////////////////////////////////////////// -// 6. Pattern Matching +// 6. Mustervergleich (Pattern Matching) ///////////////////////////////////////////////// // Pattern matching in Scala ist ein sehr nützliches und wesentlich @@ -581,7 +582,7 @@ x match { val any: Any = ... val gleicht = any match { case 2 | 3 | 5 => "Zahl" - case "woof" => "String" + case "wuff" => "String" case true | false => "Boolean" case 45.35 => "Double" case _ => "Unbekannt" @@ -620,8 +621,8 @@ def matchEverything(obj: Any): String = obj match { } -// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden -// Ganze Funktionen können Patterns sein +// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden. +// Ganze Funktionen können Patterns sein: val patternFunc: Person => String = { case Person("George", number) => s"George's number: $number" @@ -630,50 +631,50 @@ val patternFunc: Person => String = { ///////////////////////////////////////////////// -// 37. Higher-order functions +// 7. "Higher-order"-Funktionen ///////////////////////////////////////////////// -Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden -als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen -higher-order functions -Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für -die meisten anderen Collection Typen, sowie andere Klassen in Scala -Nennenswerte sind: -"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall" +// Scala erlaubt, dass Methoden und Funktionen wiederum Funtionen und Methoden +// als Aufrufparameter oder Rückgabewert verwenden. Diese Methoden heißen +// higher-order functions. +// Es gibt zahlreiche higher-order-Funtionen nicht nur für Listen, auch für +// die meisten anderen Collection-Typen, sowie andere Klassen in Scala. +// Nennenswerte sind: +// "filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall" -## List +// List -def isGleichVier(a:Int) = a == 4 +def istGleichVier(a:Int) = a == 4 val list = List(1, 2, 3, 4) val resultExists4 = list.exists(isEqualToFour) -## map +// map // map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt // eine neue Liste -// Funktion erwartet ein Int und returned ein Int +// Funktion erwartet einen Int und gibt einen Int zurück: val add10: Int => Int = _ + 10 -// add10 wird auf jedes Element angewendet +// add10 wird auf jedes Element angewendet: List(1, 2, 3) map add10 // => List(11, 12, 13) -// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden +// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden: List(1, 2, 3) map (x => x + 10) // Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion -// verwendet. Er wird an die Variable gebunden. +// verwendet. Er wird an die Variable gebunden: List(1, 2, 3) map (_ + 10) -// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten, +// Wenn der anonyme Block und die Funktion beide EIN Argument erwarten, // kann sogar der Unterstrich weggelassen werden. List("Dom", "Bob", "Natalia") foreach println @@ -681,7 +682,7 @@ List("Dom", "Bob", "Natalia") foreach println // filter // filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet -// alle Elemente die auf das Prädikat passen +// alle Elemente, die auf das Prädikat passen: List(1, 2, 3) filter (_ > 2) // => List(3) case class Person(name: String, age: Int) @@ -693,7 +694,7 @@ List( // reduce // reduce nimmt zwei Elemente und kombiniert sie zu einem Element, -// und zwar solange bis nur noch ein Element da ist. +// und zwar so lange, bis nur noch ein Element da ist. // foreach // foreach gibt es für einige Collections @@ -718,12 +719,12 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared // **ACHTUNG:** // Implicits sind ein sehr mächtiges Sprachfeature von Scala. -// Es sehr einfach +// Es sehr einfach, // sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am -// besten erst dann benutzen, wenn man versteht wie sie funktionieren. +// besten erst dann benutzen, wenn sie verstehen, wie sie funktionieren. // Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle -// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles -// machen kann. +// vorkommen und man auch mit einer Bibliothek, die Implicits benutzt, sonst +// nichts sinnvolles machen kann. // Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren. // Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte @@ -754,10 +755,10 @@ def sendGreetings(toWhom: String)(implicit howMany: Int) = sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" -// Wird der implicit Parameter jedoch weggelassen, wird ein anderer -// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im -// lexikalischen Scope und im companion object nach einem implicit Wert, -// der vom Typ passt, oder nach einer implicit Methode mit der er in den +// Wird der implicit-Parameter jedoch weggelassen, wird ein anderer +// implicit-Wert vom gleichen Typ genommen. Der Compiler sucht im +// lexikalischen Scope und im companion object nach einem implicit-Wert, +// der vom Typ passt, oder nach einer implicit-Methode, mit der er in den // geforderten Typ konvertieren kann. // Hier also: "myImplicitInt", da ein Int gesucht wird @@ -766,14 +767,14 @@ sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" // bzw. "myImplicitFunction" -// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und -// dann wird die Methode aufgerufen +// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, +// dann wird die Methode aufgerufen: "Retriever".sorte // => "Golden Retriever" ///////////////////////////////////////////////// -// 19. Misc +// 9. Misc ///////////////////////////////////////////////// // Importe @@ -804,7 +805,7 @@ import scala.collection.immutable.{Map => _, Set => _, _} object Application { def main(args: Array[String]): Unit = { - // Sachen kommen hierhin + // Zeugs hier rein. } } -- cgit v1.2.3 From 5a1816bca9cfe20e76d3584e77d11aa64e1f254a Mon Sep 17 00:00:00 2001 From: Jonas Friedemann Grote Date: Fri, 8 Sep 2017 13:57:12 +0200 Subject: Fix formatting. --- de-de/scala-de.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown index 8b0dc5f0..eb3770e9 100644 --- a/de-de/scala-de.html.markdown +++ b/de-de/scala-de.html.markdown @@ -829,11 +829,11 @@ writer.close() ## Weiterführende Hinweise -// DE +### DE * [Scala Tutorial](https://scalatutorial.wordpress.com) * [Scala Tutorial](http://scalatutorial.de) -// EN +### EN * [Scala for the impatient](http://horstmann.com/scala/) * [Twitter Scala school](http://twitter.github.io/scala_school/) * [The scala documentation](http://docs.scala-lang.org/) -- cgit v1.2.3 From a392fec7345bc1570207ca06ff36fd6feb3771fe Mon Sep 17 00:00:00 2001 From: Jonas Friedemann Grote Date: Sun, 10 Sep 2017 13:37:06 +0200 Subject: Extend review. --- de-de/scala-de.html.markdown | 64 ++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 32 deletions(-) (limited to 'de-de') diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown index eb3770e9..a8344e6a 100644 --- a/de-de/scala-de.html.markdown +++ b/de-de/scala-de.html.markdown @@ -40,22 +40,22 @@ Als nächstes beschäftigen wir uns mit ein paar Scala-Grundlagen. // 1. Grundlagen ///////////////////////////////////////////////// -// Einzeilige Kommentare beginnen mit zwei Slashes. +// Einzeilige Kommentare beginnen mit zwei Schrägstrichen. /* - Mehrzeilige Kommentare starten mit einem Slash-Stern - und enden mit einem Stern-Slash. + Mehrzeilige Kommentare starten mit Schrägstrich und Stern + und enden mit Stern und Schrägstrich. */ // Einen Wert und eine zusätzliche neue Zeile ausgeben: -println("Hello world!") +println("Hallo Welt!") println(10) // Einen Wert ohne eine zusätzliche neue Zeile ausgeben: -print("Hello world") +print("Hallo Welt") /* Variablen werden entweder mit var oder val deklariert. @@ -128,16 +128,16 @@ Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein... // Für Strings gibt es die üblichen Java-Methoden: -"hello world".length -"hello world".substring(2, 6) -"hello world".replace("C", "3") +"Hallo Welt".length +"Hallo Welt".substring(2, 6) +"Hallo Welt".replace("C", "3") // Zusätzlich gibt es noch extra Scala-Methoden // siehe: scala.collection.immutable.StringOps -"hello world".take(5) -"hello world".drop(5) +"Hallo Welt".take(5) +"Hallo Welt".drop(5) // String-Interpolation: prefix "s": @@ -296,7 +296,7 @@ i // i ausgeben, res3: Int = 10 // Sie läuft sequentiell ab und verändert die loop-Variable. // "while" in Scala läuft schneller ab als in Java und die o.g. // Kombinatoren und Zusammenlegungen sind einfacher zu verstehen -// und zu parellelisieren. +// und zu parallelisieren. // Ein do while Schleife @@ -331,7 +331,7 @@ val text = if (x == 10) "yeah" else "nope" ///////////////////////////////////////////////// -// 4. Datenstrukturen (Array, Map, Set, Tuples) +// 4. Datenstrukturen (Array, Map, Set, Tupel) ///////////////////////////////////////////////// // Array @@ -359,8 +359,8 @@ s(1) //true val s = Set(1,1,3,3,7) s: scala.collection.immutable.Set[Int] = Set(1, 3, 7) -// Tuple - Speichert beliebige Daten und "verbindet" sie miteinander -// Ein Tuple ist keine Collection. +// Tupel - Speichert beliebige Daten und "verbindet" sie miteinander +// Ein Tupel ist keine Collection. (1, 2) (4, 3, 2) @@ -368,14 +368,14 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7) (a, 2, "three") -// Hier ist der Rückgabewert der Funktion ein Tuple +// Hier ist der Rückgabewert der Funktion ein Tupel // Die Funktion gibt das Ergebnis sowie den Rest zurück. val divideInts = (x: Int, y: Int) => (x / y, x % y) divideInts(10, 3) -// Um die Elemente eines Tuples anzusprechen, benutzt man diese +// Um die Elemente eines Tupels anzusprechen, benutzt man diese // Notation: _._n wobei n der index des Elements ist (Index startet bei 1) val d = divideInts(10, 3) @@ -603,21 +603,21 @@ def matchPerson(person: Person): String = person match { val email = "(.*)@(.*)".r // regex def matchEverything(obj: Any): String = obj match { // Werte: - case "Hello world" => "Got the string Hello world" + case "Hallo Welt" => "string Hallo Welt gefunden" // Typen: - case x: Double => "Got a Double: " + x - // Conditions: - case x: Int if x > 10000 => "Got a pretty big number!" - // Case Classes: - case Person(name, number) => s"Got contact info for $name!" + case x: Double => "Double gefunden: " + x + // Bedingungen: + case x: Int if x > 10000 => "Ziemlich große Zahl gefunden!" + // Case-Klassen: + case Person(name, number) => s"Kontaktinformationen für $name gefunden!" // RegEx: - case email(name, domain) => s"Got email address $name@$domain" - // Tuples: - case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c" + case email(name, domain) => s"E-Mail-Adresse $name@$domain gefunden" + // Tupel: + case (a: Int, b: Double, c: String) => s"Tupel gefunden: $a, $b, $c" // Strukturen: - case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c" - // Patterns kann man ineinander schachteln: - case List(List((1, 2, "YAY"))) => "Got a list of list of tuple" + case List(1, b, c) => s"Liste aus drei Elementen gefunden, startend mit 1: 1, $b, $c" + // Pattern kann man ineinander schachteln: + case List(List((1, 2, "YAY"))) => "Liste von Tupeln gefunden" } @@ -747,12 +747,12 @@ myImplicitFunction("Pitbull").sorte // => "Golden Pitbull" // Diese Funktion hat zwei Parameter: einen normalen und einen implicit def sendGreetings(toWhom: String)(implicit howMany: Int) = - s"Hello $toWhom, $howMany blessings to you and yours!" + s"Hallo $toWhom, $howMany Segenswünsche für Sie und Ihre Angehörigen!" // Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet -sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" +sendGreetings("John")(1000) // => "Hallo John, 1000 Segenswünsche für Sie und Ihre Angehörigen!" // Wird der implicit-Parameter jedoch weggelassen, wird ein anderer @@ -763,7 +763,7 @@ sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours! // Hier also: "myImplicitInt", da ein Int gesucht wird -sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" +sendGreetings("Jane") // => "Hallo Jane, 100 Segenswünsche für Sie und Ihre Angehörigen!" // bzw. "myImplicitFunction" @@ -774,7 +774,7 @@ sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" ///////////////////////////////////////////////// -// 9. Misc +// 9. Sonstiges ///////////////////////////////////////////////// // Importe -- cgit v1.2.3 From 3c38bb8197a281f2ea5967e3f807736ba5bb5c50 Mon Sep 17 00:00:00 2001 From: Abel Salgado Romero Date: Thu, 21 Sep 2017 18:51:50 +0200 Subject: [asciidoc/en][asciidoc/de][asciidoc/is][asciidoc/pt] fixed wrong AsciiDoc section levels --- de-de/asciidoc-de.html.markdown | 4 ---- 1 file changed, 4 deletions(-) (limited to 'de-de') diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown index 1a8cdd5a..60f8fa61 100644 --- a/de-de/asciidoc-de.html.markdown +++ b/de-de/asciidoc-de.html.markdown @@ -84,10 +84,6 @@ Abteilungstitel ===== Level 4
-====== Level 5
- -======= Level 6 - ``` Listen -- cgit v1.2.3 From bd9452488493fa89c8520d070b345ba83722c930 Mon Sep 17 00:00:00 2001 From: Monschichi Date: Fri, 22 Sep 2017 22:41:13 +0200 Subject: fixed missing brackets for print brackets where missing for print in python3 de-de --- de-de/python3-de.html.markdown | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'de-de') diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown index ef1786c8..33897225 100644 --- a/de-de/python3-de.html.markdown +++ b/de-de/python3-de.html.markdown @@ -146,7 +146,7 @@ bool({}) #=> False #################################################### # Textausgabe ist sehr einfach -print "Ich bin Python. Schön, dich kennenzulernen!" +print("Ich bin Python. Schön, dich kennenzulernen!") # Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren. some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm @@ -307,11 +307,11 @@ some_var = 5 # Hier eine if-Anweisung. Die Einrückung ist in Python wichtig! # gibt "some_var ist kleiner als 10" aus if some_var > 10: - print "some_var ist viel größer als 10." + print("some_var ist viel größer als 10.") elif some_var < 10: # Dieser elif-Absatz ist optional. - print "some_var ist kleiner als 10." + print("some_var ist kleiner als 10.") else: # Das hier ist auch optional. - print "some_var ist tatsächlich 10." + print("some_var ist tatsächlich 10.") """ @@ -334,7 +334,7 @@ Ausgabe: 3 """ for i in range(4): - print i + print(i) """ "range(unten, oben)" gibt eine Liste von der unteren Zahl bis zur oberen Zahl aus @@ -357,7 +357,7 @@ Ausgabe: """ x = 0 while x < 4: - print x + print(x) x += 1 # Kurzform für x = x + 1 # Ausnahmebehandlung mit einem try/except-Block @@ -418,7 +418,7 @@ list(filled_dict.keys()) #=> ["one", "two", "three"] # Mit def neue Funktionen erstellen def add(x, y): - print "x ist %s und y ist %s" % (x, y) + print("x ist %s und y ist %s" % (x, y)) return x + y # Werte werden mit return zurückgegeben # Funktionen mit Parametern aufrufen @@ -444,8 +444,8 @@ keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} # Wir können beides gleichzeitig machem, wenn wir wollen def all_the_args(*args, **kwargs): - print args - print kwargs + print(args) + print(kwargs) """ all_the_args(1, 2, a=3, b=4) Ausgabe: (1, 2) @@ -532,10 +532,10 @@ class Human(object): # Eine Instanz einer Klasse erstellen i = Human(name="Ian") -print i.say("hi") # gibt "Ian: hi" aus +print(i.say("hi")) # gibt "Ian: hi" aus j = Human("Joel") -print j.say("hello") #gibt "Joel: hello" aus +print(j.say("hello")) #gibt "Joel: hello" aus # Rufen wir mal unsere Klassenmethode auf i.get_species() #=> "H. sapiens" @@ -555,12 +555,12 @@ Human.grunt() #=> "*grunt*" # Wir können Module importieren import math -print math.sqrt(16) #=> 4 +print(math.sqrt(16)) #=> 4 # Wir können auch nur spezielle Funktionen eines Moduls importieren from math import ceil, floor -print ceil(3.7) #=> 4.0 -print floor(3.7) #=> 3.0 +print(ceil(3.7)) #=> 4.0 +print(floor(3.7)) #=> 3.0 # Wir können auch alle Funktionen eines Moduls importieren # Warnung: Dies wird nicht empfohlen -- cgit v1.2.3 From d01e5242e16c522becc1b04f9692d2556f94c4f1 Mon Sep 17 00:00:00 2001 From: Damian Rzeszot Date: Mon, 9 Oct 2017 12:01:15 +0200 Subject: swift | fix style guidelines --- de-de/swift-de.html.markdown | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'de-de') diff --git a/de-de/swift-de.html.markdown b/de-de/swift-de.html.markdown index b58a72d3..43b8c32a 100644 --- a/de-de/swift-de.html.markdown +++ b/de-de/swift-de.html.markdown @@ -440,13 +440,13 @@ if let circle = myEmptyCircle { // Wie Klassen auch können sie Methoden haben enum Suit { - case Spades, Hearts, Diamonds, Clubs + case spades, hearts, diamonds, clubs func getIcon() -> String { switch self { - case .Spades: return "♤" - case .Hearts: return "♡" - case .Diamonds: return "♢" - case .Clubs: return "♧" + case .spades: return "♤" + case .hearts: return "♡" + case .diamonds: return "♢" + case .clubs: return "♧" } } } @@ -455,7 +455,7 @@ enum Suit { // Enum-Werte können vereinfacht geschrieben werden, es muss nicht der Enum-Typ // genannt werden, wenn die Variable explizit deklariert wurde -var suitValue: Suit = .Hearts +var suitValue: Suit = .hearts // Nicht-Integer-Enums brauchen direkt zugewiesene "Rohwerte" enum BookName: String { -- cgit v1.2.3 From 9a9e52b54bf9bc6ebeefc996452f5944a234557f Mon Sep 17 00:00:00 2001 From: Damian Rzeszot Date: Mon, 9 Oct 2017 12:02:29 +0200 Subject: swift | fix style guidelines --- de-de/swift-de.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/swift-de.html.markdown b/de-de/swift-de.html.markdown index 43b8c32a..c21b7e36 100644 --- a/de-de/swift-de.html.markdown +++ b/de-de/swift-de.html.markdown @@ -459,10 +459,10 @@ var suitValue: Suit = .hearts // Nicht-Integer-Enums brauchen direkt zugewiesene "Rohwerte" enum BookName: String { - case John = "John" - case Luke = "Luke" + case john = "John" + case luke = "Luke" } -print("Name: \(BookName.John.rawValue)") +print("Name: \(BookName.john.rawValue)") // Enum mit assoziierten Werten enum Furniture { -- cgit v1.2.3 From e8ee66c854b8833fcb0fd76b5e9ace6ae8379397 Mon Sep 17 00:00:00 2001 From: Damian Rzeszot Date: Mon, 9 Oct 2017 12:03:27 +0200 Subject: swift | fix style guidelines --- de-de/swift-de.html.markdown | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'de-de') diff --git a/de-de/swift-de.html.markdown b/de-de/swift-de.html.markdown index c21b7e36..08f72a35 100644 --- a/de-de/swift-de.html.markdown +++ b/de-de/swift-de.html.markdown @@ -467,23 +467,23 @@ print("Name: \(BookName.john.rawValue)") // Enum mit assoziierten Werten enum Furniture { // mit Int assoziiert - case Desk(height: Int) + case desk(height: Int) // mit String und Int assoziiert - case Chair(String, Int) - + case chair(String, Int) + func description() -> String { switch self { - case .Desk(let height): + case .desk(let height): return "Desk with \(height) cm" - case .Chair(let brand, let height): + case .chair(let brand, let height): return "Chair of \(brand) with \(height) cm" } } } -var desk: Furniture = .Desk(height: 80) +var desk: Furniture = .desk(height: 80) print(desk.description()) // "Desk with 80 cm" -var chair = Furniture.Chair("Foo", 40) +var chair = Furniture.chair("Foo", 40) print(chair.description()) // "Chair of Foo with 40 cm" -- cgit v1.2.3 From 340a7b6d7812ef5ba1903983a7cd3f5cc3385288 Mon Sep 17 00:00:00 2001 From: Marko Cubela Date: Sat, 14 Oct 2017 11:43:53 +0200 Subject: add more commit examples --- de-de/git-de.html.markdown | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'de-de') diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown index 61f7bb67..a0ed120f 100644 --- a/de-de/git-de.html.markdown +++ b/de-de/git-de.html.markdown @@ -205,6 +205,12 @@ Speichert die aktuellen Inhalte des Index in einen neuen *Commit*. Dieser Commit ```bash # Commit mit Beschreibung erstellen. $ git commit -m "Added multiplyNumbers() function to HelloWorld.c" + +# Alle veränderten oder gelöschten Dateien außer neue Dateien werden gestaged und dann wird ein Commit erstellt. +$ git commit -a -m "Modified foo.php and removed bar.php" + +# Ändert den letzten Commit (der letzte Commit wird mit einem neuen Commit ersetzt) +$ git commit --amend -m "Correct message" ``` ### diff -- cgit v1.2.3 From b5a681fd6b159a5aece7e318ce01637fff3965f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20J=C3=BCrges?= Date: Wed, 18 Oct 2017 18:20:12 +0200 Subject: dynamic programming de translation --- de-de/dynamic-programming-de.html.markdown | 54 ++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 de-de/dynamic-programming-de.html.markdown (limited to 'de-de') diff --git a/de-de/dynamic-programming-de.html.markdown b/de-de/dynamic-programming-de.html.markdown new file mode 100644 index 00000000..d663400f --- /dev/null +++ b/de-de/dynamic-programming-de.html.markdown @@ -0,0 +1,54 @@ +--- +category: Algorithms & Data Structures +name: Dynamic Programming +contributors: + - ["Akashdeep Goel", "http://github.com/akashdeepgoel"] +translators: + - ["Henrik Jürges", "http://github.com/santifa"] +lang: de-de +--- + +# Dynamische Programmierung + +## Einführung +Dynamische Programmierung ist eine leistungsfähige Technik, die zur Lösung einer bestimmten Klasse von Problemen verwendet wird. +Die Idee ist sehr einfach, wenn Sie ein Problem mit der gegebenen Eingabe gelöst haben, dann speichern Sie das Ergebnis für die spätere Referenz, um zu vermeiden, das gleiche Problem noch einmal zu lösen. + +Denken Sie immer daran! +"Diejenigen, die sich nicht an die Vergangenheit erinnern können, sind dazu verdammt, sie zu wiederholen." + +## Wege zur Lösung solcher Probleme + +1. *Top-Down*: Lösen Sie das gegebene Problem, indem Sie es aufteilen. Wenn Sie sehen, dass das Problem bereits gelöst ist, geben Sie einfach die gespeicherte Antwort zurück. Wenn es nicht gelöst wurde, lösen Sie es und speichern Sie die Antwort. Dieser Ansatz ist leicht zu verfolgen und sehr intuitiv. Er wird als Memoization bezeichnet. + +2. *Bottom-Up*: Analysieren Sie das Problem und beobachten Sie, in welcher Reihenfolge die Teilprobleme gelöst werden können. Beginnen Sie mit der Lösung vom trivialen Teilproblem bis zum gegebenen Problem. Dabei wird sichergestellt, dass die Teilprobleme vor der Problemlösung gelöst werden. Dies wird als Dynamische Programmierung bezeichnet. + +## Ein Beispiel für Dynamische Programmierung + +Das Problem mit der längsten ansteigenden Subsequenz besteht darin, die längste ansteigende Subsequenz einer gegebenen Sequenz zu finden. +Gegeben die Sequenz `S= {a1, a2, a3, a3, a4,..............., an-1, an }`, müssen wir die größte Teilmenge finden, so daß für alle `j` und `i`, `j a[j] and LS[i] Date: Wed, 18 Oct 2017 18:23:39 +0200 Subject: fixed line length --- de-de/dynamic-programming-de.html.markdown | 49 ++++++++++++++++++++++-------- 1 file changed, 36 insertions(+), 13 deletions(-) (limited to 'de-de') diff --git a/de-de/dynamic-programming-de.html.markdown b/de-de/dynamic-programming-de.html.markdown index d663400f..801d2514 100644 --- a/de-de/dynamic-programming-de.html.markdown +++ b/de-de/dynamic-programming-de.html.markdown @@ -11,28 +11,51 @@ lang: de-de # Dynamische Programmierung ## Einführung -Dynamische Programmierung ist eine leistungsfähige Technik, die zur Lösung einer bestimmten Klasse von Problemen verwendet wird. -Die Idee ist sehr einfach, wenn Sie ein Problem mit der gegebenen Eingabe gelöst haben, dann speichern Sie das Ergebnis für die spätere Referenz, um zu vermeiden, das gleiche Problem noch einmal zu lösen. +Dynamische Programmierung ist eine leistungsfähige Technik, die zur Lösung +einer bestimmten Klasse von Problemen verwendet wird. +Die Idee ist sehr einfach, wenn Sie ein Problem mit der gegebenen Eingabe +gelöst haben, dann speichern Sie das Ergebnis für die spätere Referenz, um zu +vermeiden, das gleiche Problem noch einmal zu lösen. Denken Sie immer daran! -"Diejenigen, die sich nicht an die Vergangenheit erinnern können, sind dazu verdammt, sie zu wiederholen." +"Diejenigen, die sich nicht an die Vergangenheit erinnern können, +sind dazu verdammt, sie zu wiederholen." ## Wege zur Lösung solcher Probleme -1. *Top-Down*: Lösen Sie das gegebene Problem, indem Sie es aufteilen. Wenn Sie sehen, dass das Problem bereits gelöst ist, geben Sie einfach die gespeicherte Antwort zurück. Wenn es nicht gelöst wurde, lösen Sie es und speichern Sie die Antwort. Dieser Ansatz ist leicht zu verfolgen und sehr intuitiv. Er wird als Memoization bezeichnet. +1. *Top-Down*: Lösen Sie das gegebene Problem, indem Sie es aufteilen. +Wenn Sie sehen, dass das Problem bereits gelöst ist, geben Sie einfach die +gespeicherte Antwort zurück. Wenn es nicht gelöst wurde, lösen Sie es und +speichern Sie die Antwort. Dieser Ansatz ist leicht zu verfolgen und sehr +intuitiv. Er wird als Memoization bezeichnet. -2. *Bottom-Up*: Analysieren Sie das Problem und beobachten Sie, in welcher Reihenfolge die Teilprobleme gelöst werden können. Beginnen Sie mit der Lösung vom trivialen Teilproblem bis zum gegebenen Problem. Dabei wird sichergestellt, dass die Teilprobleme vor der Problemlösung gelöst werden. Dies wird als Dynamische Programmierung bezeichnet. +2. *Bottom-Up*: Analysieren Sie das Problem und beobachten Sie, in welcher +Reihenfolge die Teilprobleme gelöst werden können. Beginnen Sie mit der +Lösung vom trivialen Teilproblem bis zum gegebenen Problem. Dabei wird +sichergestellt, dass die Teilprobleme vor der Problemlösung gelöst werden. +Dies wird als Dynamische Programmierung bezeichnet. ## Ein Beispiel für Dynamische Programmierung -Das Problem mit der längsten ansteigenden Subsequenz besteht darin, die längste ansteigende Subsequenz einer gegebenen Sequenz zu finden. -Gegeben die Sequenz `S= {a1, a2, a3, a3, a4,..............., an-1, an }`, müssen wir die größte Teilmenge finden, so daß für alle `j` und `i`, `j Date: Sun, 22 Oct 2017 17:23:46 +0200 Subject: [pyqt/de] Translate pyqt to german --- de-de/pyqt-de.html.markdown | 89 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 de-de/pyqt-de.html.markdown (limited to 'de-de') diff --git a/de-de/pyqt-de.html.markdown b/de-de/pyqt-de.html.markdown new file mode 100644 index 00000000..93ee20d4 --- /dev/null +++ b/de-de/pyqt-de.html.markdown @@ -0,0 +1,89 @@ +--- +category: tool +tool: PyQT +filename: learnpyqt-de.py +contributors: + - ["Nathan Hughes", "https://github.com/sirsharpest"] +translators: + - ["Dennis Keller", "https://github.com/denniskeller"] +lang: de-de +--- + +**Qt** ist eine weit bekanntes Framework mit den man plattformunabhängige Programme schreiben kann, +die auf verschiedenen Sotfware und Hardware Plattformen laufen mit kleinen oder keinen Änderungen im Code. +Dabei besitzen sie trozdem die Power und Geschwindigkeit von nativen Anwendungen. +**Qt** wurde ursprünglich in *C++** geschrieben. + +Das ist eine Adaption von dem C++ Intro für QT von [Aleksey Kholovchuk](https://github.com/vortexxx192), +manche der Codebeispiele sollte in der selben Funktionalität resultieren. +Diese Version wurde in pyqt erstellt. + +```python +import sys +from PyQt4 import QtGui + +def window(): + # Erschafft ein Anwendungsobjekt. + app = QtGui.QApplication(sys.argv) + # Erschafft ein Widget, auf dem unser Label platziert wird. + w = QtGui.QWidget() + # Fügt ein Label zu dem Widget hinzu. + b = QtGui.QLabel(w) + # Setzt einen Text für das Label. + b.setText("Hello World!") + # Setzt die Größe und die Platzierungsinfomationen. + w.setGeometry(100, 100, 200, 50) + b.move(50, 20) + # Setzt unserem Fenster einen schönen Titel. + w.setWindowTitle("PyQt") + # Lässt alles anzeigen. + w.show() + # Führe alles aus, nachdem wir alles aufgebaut haben. + sys.exit(app.exec_()) + +if __name__ == '__main__': + window() + +``` + +Damit wir weitere fortgeschrittene Funktionen in **pyqt** verwenden können, +müssen wir anfangen zusätzliche Elemente zu bauen. +Hier zeigen wir wie man eine Dialog Popup Box einführt. +Diese ist nützlich, um den Benutzer eine Entscheidung zu bestätigen oder um Informationen anzuzeigen. + +```Python +import sys +from PyQt4.QtGui import * +from PyQt4.QtCore import * + + +def window(): + app = QApplication(sys.argv) + w = QWidget() + # Erschafft einen Knopf und fügt das Widget w hinzu + b = QPushButton(w) + b.setText("drücke mich") + b.move(50, 50) + # Wenn b gedrückt wird, wird diese Funktion aufgerufen. + # Bemerke das Fehlen von () bei dem Funktionsaufruf. + b.clicked.connect(showdialog) + w.setWindowTitle("PyQt Dialog") + w.show() + sys.exit(app.exec_()) + +# Diese Funktion soll ein Dialogfenster mit einem Knopf erschaffen. +# Der Knopf wartet bis er geklickt wird und beendet das Programm +def showdialog(): + d = QDialog() + b1 = QPushButton("ok", d) + b1.move(50, 50) + d.setWindowTitle("Dialog") + # Diese Modalität sagt dem Popup, dass es den Parent blocken soll, solange es aktiv ist. + d.setWindowModality(Qt.ApplicationModal) + # Beim klicken möchte ich, dass der gesamte Prozess beendet wird. + b1.clicked.connect(sys.exit) + d.exec_() + +if __name__ == '__main__': + window() +``` -- cgit v1.2.3 From aa94772b921ececf488810167e4949b10a1705ce Mon Sep 17 00:00:00 2001 From: Dennis Keller Date: Sun, 22 Oct 2017 17:43:50 +0200 Subject: [qt/de] Translate qt to german --- de-de/qt-de.html.markdown | 175 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100644 de-de/qt-de.html.markdown (limited to 'de-de') diff --git a/de-de/qt-de.html.markdown b/de-de/qt-de.html.markdown new file mode 100644 index 00000000..480030fe --- /dev/null +++ b/de-de/qt-de.html.markdown @@ -0,0 +1,175 @@ +--- +category: tool +tool: Qt Framework +language: c++ +filename: learnqt-de.cpp +contributors: + - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] +translators: + - ["Dennis Keller", "https://github.com/denniskeller"] +lang: de-de +--- + +**Qt** ist ein weithin bekanntes Framework zum Entwickeln von cross-platform Software, +die auf verschiedenen Hard- und Softwareplatformen mit wenig oder keinen Veränderungen im Code läuft. +Dabei besitzt man die Power und Geschiwindigkeit von nativen Anwendungen. +Obwohl **Qt** ursprünglich in *C++* geschrieben wurde, +gibt es verschiedene Ports für andere Sprachen: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc. + +**Qt** eignet sich hervorragend zum Erstellen von Anwendungen mit grafischer Benutzeroberfläche (GUI). +Dieses Tutorial zeigt, wie man das in *C++* macht. + +```c++ +/* + * Lass uns klassisch starten + */ + +// Alle Header vom Qt Framework starten mit dem Großbuchstaben 'Q'. +#include +#include + +int main(int argc, char *argv[]) { + // Erstellt ein Objekt um applikationsweit die Resourcen zu managen. + QApplication app(argc, argv); + + // Erstellt ein Line edit Widget und zeigt es auf dem Bildschirm + QLineEdit lineEdit("Hello world!"); + lineEdit.show(); + + // Startet die Event Loop der Anwendung. + return app.exec(); +} +``` + +Die GUI bezogene Teile von **Qt** bestehen aus *Widgets* und den *Verbindungen* +dazwischen. + +[Lies mehr über Widgets](http://doc.qt.io/qt-5/qtwidgets-index.html) + +```c++ +/* + * Lass uns Label und einen Button machen. + * Ein Label soll auftauchen, wenn der Button gedrückt wird. + * + * Der Qt Code spricht für sich selbst. + */ + +#include +#include +#include +#include +#include + +int main(int argc, char *argv[]) { + QApplication app(argc, argv); + + QDialog dialogWindow; + dialogWindow.show(); + + // Füge ein vertikales Layout hinzu + QVBoxLayout layout; + dialogWindow.setLayout(&layout); + + QLabel textLabel("Danke für das Knopf drücken"); + layout.addWidget(&textLabel); + textLabel.hide(); + + QPushButton button("Drück mich"); + layout.addWidget(&button); + + // Zeigt verstecktes Label, wenn der Button gedrückt wird. + QObject::connect(&button, &QPushButton::pressed, + &textLabel, &QLabel::show); + + return app.exec(); +} +``` + +Beachte den *QObject::connect* Teil. Diese Methode wird verwendet, +um *Signale* eines Objekts mit den *Slots* eines Objektes zu verbinden. + +**Signale** werden ausgegeben, wenn bestimmte Dinge mit Objekten passieren. +Beispielsweise wird das *pressed* Signal ausgegeben, +wenn der Benutzer auf das QPushButton Objekt drückt. + +**Slots** sind Aktionen, die als Reaktion auf empfangene Signale ausgeführt werden können. + +[Lies mehr über Slots und Signale](http://doc.qt.io/qt-5/signalsandslots.html) + + +Als Nächstes lernen wir, dass wir nicht nur Standard Widgets verwenden können, +sondern auch ihr Verhalten mithilfe von Vererbung verändern können. +Lass uns einen Button erschaffen, der zählt, wie häufig er gedrückt wird. +Dafür definieren wir unsere eigene Klasse *CounterLabel*. +Diese muss wegen der speziellen Qt Architektur in einer seperaten Datei deklariert werden. + +```c++ +// counterlabel.hpp + +#ifndef COUNTERLABEL +#define COUNTERLABEL + +#include + +class CounterLabel : public QLabel { + Q_OBJECT // Qt definiertes Makro, welches in jedem modifizierten Widget vorhanden sein muss. + +public: + CounterLabel() : counter(0) { + setText("Zähler wurde noch nicht erhöht."); // Methode von QLabel + } + +public slots: + // Aktion, die ausgeführt wird, wenn der Button gedrückt wird. + void increaseCounter() { + setText(QString("Zähler Wert: %1").arg(QString::number(++counter))); + } + +private: + int counter; +}; + +#endif // Zähllabel +``` + +```c++ +// main.cpp +// Fast das Gleiche, wie das vorherige Beispiel + +#include +#include +#include +#include +#include +#include "counterlabel.hpp" + +int main(int argc, char *argv[]) { + QApplication app(argc, argv); + + QDialog dialogWindow; + dialogWindow.show(); + + QVBoxLayout layout; + dialogWindow.setLayout(&layout); + + CounterLabel counterLabel; + layout.addWidget(&counterLabel); + + QPushButton button("Drück mich nochmal."); + layout.addWidget(&button); + QObject::connect(&button, &QPushButton::pressed, + &counterLabel, &CounterLabel::increaseCounter); + + return app.exec(); +} +``` + +Das wars! Natürlich ist das Qt Framework erheblich größer, als der der Teil der in diesem Tutorial behandelt wurde. +Das heißt, es gibt viel zu lesen und zu üben. + +## Further reading + +- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html) +- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html) + +Viel Erfolg und viel Spaß! -- cgit v1.2.3 From 8dedecc999b17eee78b6f405bcc50a8d1316ec32 Mon Sep 17 00:00:00 2001 From: Dennis Keller Date: Sun, 22 Oct 2017 17:54:53 +0200 Subject: [edn/de] Translate edn to german --- de-de/edn-de.html.markdown | 112 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 de-de/edn-de.html.markdown (limited to 'de-de') diff --git a/de-de/edn-de.html.markdown b/de-de/edn-de.html.markdown new file mode 100644 index 00000000..4f452d7e --- /dev/null +++ b/de-de/edn-de.html.markdown @@ -0,0 +1,112 @@ +--- +language: edn +filename: learnedn-de.edn +contributors: + - ["Jason Yeo", "https://github.com/jsyeo"] + - ["Jonathan D Johnston", "https://github.com/jdjohnston"] +translators: + - ["Dennis Keller", "https://github.com/denniskeller"] +lang: de-de +--- + +Extensible Data Notation (EDN) ist ein Format für serialisierte Daten. + +EDN ist ein Subset der von Clojure verwendeten Syntax. Das Lesen von Daten, die durch EDN definiert werden, ist +sicherer als das, was durch die vollständige Clojure-Syntax definiert wird, insbesondere von nicht +vertrauenswürdigen Quellen. EDN ist beschränkt auf Daten, kein Code. Es ist ähnlich in seinen Zielen zu JSON. +Obwohl es mehr in Clojure verwendet wird, gibt es verschiedene Implementationen von EDN in vielen +verschiedenen anderen Sprachen. + +Der Hauptvorteil von EDN im Gegensatz zu JSON und YAML ist, dass es erweiterbar ist. +Wir werden später sehen wie es erweitert werden kann. + +```clojure +; Kommentare starten mit einem Semikolon. +; Alles nach dem Semikolon wird ignoriert. + +;;;;;;;;;;;;;;;;;;; +;;; Basistypen ;;; +;;;;;;;;;;;;;;;;;;; + +nil ; auch bekannt in anderen Sprachen als null + +; Booleans +true +false + +; Strings werden in Gänsefüßchen eingeschlossen. +"hungarian breakfast" +"farmer's cheesy omelette" + +; Charaktere werden einem Backslash vorangestellt +\g \r \a \c \e + +; Schlüsselwörter beginnen mit einenm Doppelpunkt. Sie verhalten sich wie Enums. +; Ähnlich, wie Symbole in Ruby. +:eggs +:cheese +:olives + +; Symbole werden verwendet um Identifier zu repräsentieren. Sie beginnen mit einem #. +; Du kannst einen Namespace für Symbole nutzen, wenn du / verwendest. Egal was / vorangestellt wird +; ist der Namespace dieses Namens. +#spoon +#kitchen/spoon ; nicht das selbe, wie #spoon +#kitchen/fork +#github/fork ; damit kannst du nicht essen + +; Integers und Floats +42 +3.14159 + +; Listen sind Sequenzen von Werten +(:bun :beef-patty 9 "yum!") + +; Vektoren erlauben zufälligen Zugriff +[:gelato 1 2 -2] + +; Maps sind assoziative Datenstrukturen, die einen Schlüssel mit einem Wert verbinden. +{:eggs 2 + :lemon-juice 3.5 + :butter 1} + +; Du bist nicht beschränkt ausschließlich Schlüsselwörter als Schlüssel zu verwenden. +{[1 2 3 4] "tell the people what she wore", + [5 6 7 8] "the more you see the more you hate"} + +; Du kannst Kommas für eine bessere Lesbarkeit verwenden. Sie werden wie Leerraum behandelt. +; Sets sind Sammlungen, die eindeutige Elemente enthalten. +#{:a :b 88 "huat"} + +;;;;;;;;;;;;;;;;;;;;;;;;; +;;; makierte Elemente ;;; +;;;;;;;;;;;;;;;;;;;;;;;;; + +; EDN kann erweitert werden, indem Elemente mit # Symbolen makiert werden. + +#MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10} + +; Lass mich das mit einem Clojure Beispiel erklären. +; Angenommen ich möchte dieses Stück EDM in einen MenuItem record umwandeln. +(defrecord MenuItem [name rating]) + +; Um EDN in clojure Werte umzuwandeln, muss ich den eingebauten EDN Leser +;edn/read-string verwenden + +(edn/read-string "{:eggs 2 :butter 1 :flour 5}") +; -> {:eggs 2 :butter 1 :flour 5} + +; Definiere die Leserfunktion, um markierte Elemente zu transformieren +; und übergebe eine Map, die Tags den Lesefunktionen als edn / read-string zuweisen + +(edn/read-string {:readers {'MyYelpClone/MenuItem map->menu-item}} + "#MyYelpClone/MenuItem {:name \"eggs-benedict\" :rating 10}") +; -> #user.MenuItem{:name "eggs-benedict", :rating 10} + +``` + +# Referenzen + +- [EDN spec](https://github.com/edn-format/edn) +- [Implementationen](https://github.com/edn-format/edn/wiki/Implementations) +- [makierte Elemente](http://www.compoundtheory.com/clojure-edn-walkthrough/) -- cgit v1.2.3 From 8d311de256f3813d6a83f8bb07a3495cd643d7cc Mon Sep 17 00:00:00 2001 From: Dennis Keller Date: Sun, 22 Oct 2017 18:01:59 +0200 Subject: [nix/de] Translate nix to german --- de-de/nix-de.html.markdown | 358 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 358 insertions(+) create mode 100644 de-de/nix-de.html.markdown (limited to 'de-de') diff --git a/de-de/nix-de.html.markdown b/de-de/nix-de.html.markdown new file mode 100644 index 00000000..8c78ffbc --- /dev/null +++ b/de-de/nix-de.html.markdown @@ -0,0 +1,358 @@ +--- +language: nix +filename: learnnix-de.nix +contributors: + - ["Chris Martin", "http://chris-martin.org/"] +translators: + - ["Dennis Keller", "https://github.com/denniskeller"] +lang: de-de +--- + +Nix ist eine simple funktionale Programmiersprache, die für den +[Nix package manager](https://nixos.org/nix/) und +[NixOS](https://nixos.org/) entwickelt wurde. + +Du kannst Nix Ausdrücke evaluieren mithilfe von +[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate) +oder [`nix-repl`](https://github.com/edolstra/nix-repl). + +``` +with builtins; [ + + # Kommentare + #========================================= + + # Inline Kommentare sehen so aus. + + /* Multizeilen Kommentare + sehen so aus. */ + + + # Booleans + #========================================= + + (true && false) # Und + #=> false + + (true || false) # Oder + #=> true + + (if 3 < 4 then "a" else "b") # Bedingungen + #=> "a" + + + # Integers + #========================================= + + # Integers sind die einzigen numerischen Typen. + + 1 0 42 (-3) # Einige integers + + (4 + 6 + 12 - 2) # Addition + #=> 20 + + (7 / 2) # Division + #=> 3 + + + # Strings + #========================================= + + "String Literale sind in Gänsefüßchen." + + " + String Literale können mehrere + Zeilen umspannen. + " + + '' + Dies wird als Literal mit eingerückten String bezeichnet. + Es entfernt intelligent führende Leerzeichen. + '' + + '' + a + b + '' + #=> "a\n b" + + ("ab" + "cd") # String Konkatenation + #=> "abcd" + + # Mit Antiquotation kannst du Werte in Strings einbetten. + ("Dein Homeverzeichnis ist ${getEnv "HOME"}") + #=> "Dein Homeverzeichnis ist /home/alice" + + + # Paths + #========================================= + + # Nix besitzt einen primitven Datentyp für Pfade + /tmp/tutorials/learn.nix + + # Ein relativer Pfad wird beim Parsing zu einem absoluten Pfad aufgelöst, + # relativ zu der Datei in der es auftritt. + tutorials/learn.nix + #=> /the-base-path/tutorials/learn.nix + + # Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine + # Datei im selben Verzeichnis benötigt ein ./ Präfix. + ./learn.nix + #=> /the-base-path/learn.nix + + # Der / Operator muss von Leerraum umgeben sein wenn du dividieren möchtest. + 7/2 # Das ist ein Pfadliteral + (7 / 2) # Das ist ein Integerliteral + + + # Importe + #========================================= + + # Eine nix Datei besitzt einen einzelnen top-level Ausdruck mit keinen freien Variablen. + # Ein Import-Ausdruck wird zum Wert der Datei, die importiert wird, ausgewertet. + (import /tmp/foo.nix) + + # Importe können ebenso mit Strings spezifiziert werden. + (import "/tmp/foo.nix") + + # Import Pfade müssen absolut sein. Pfadliterale + # sind automatisch aufgelöst, das ist ein Ordnung. + (import ./foo.nix) + + # Jedoch passiert dies nicht mit Strings. + (import "./foo.nix") + #=> error: string ‘foo.nix’ doesn't represent an absolute path + + + # Let + #========================================= + + # `let` Blöcke erlauben es uns Werte zu Variablen zu binden. + (let x = "a"; in + x + x + x) + #=> "aaa" + + # Bindungen können auf sich gegenseitig verweisen. Die Reihenfolge spielt + # keine Rolle. + (let y = x + "b"; + x = "a"; in + y + "c") + #=> "abc" + + # Innere Bindungen überschatten Äußere. + (let a = 1; in + let a = 2; in + a) + #=> 2 + + + # Funktionen + #========================================= + + (n: n + 1) # Funktion, die 1 addiert + + ((n: n + 1) 5) # Dieselbe Funktion angewendet auf 5. + #=> 6 + + # Es gibt keine spezielle Syntax für benannte Funktionen, aber sie + # können mit `let` Blöcken, wie jeder andere Wert auch, gebunden werden. + (let succ = (n: n + 1); in succ 5) + #=> 6 + + # Eine Funktion hat genau ein Argument. + # Mehrere Argumente können erreicht werden mithilfe von Currying. + ((x: y: x + "-" + y) "a" "b") + #=> "a-b" + + # Benannte Funktionsargumente gibt es auch. Diese werden wir einführen, nachdem wir uns Sets + # angeschaut haben. + + # Listen + #========================================= + + # Listen werden durck eckige Klammern gekennzeichnet. + + (length [1 2 3 "x"]) + #=> 4 + + ([1 2 3] ++ [4 5]) + #=> [1 2 3 4 5] + + (concatLists [[1 2] [3 4] [5]]) + #=> [1 2 3 4 5] + + (head [1 2 3]) + #=> 1 + (tail [1 2 3]) + #=> [2 3] + + (elemAt ["a" "b" "c" "d"] 2) + #=> "c" + + (elem 2 [1 2 3]) + #=> true + (elem 5 [1 2 3]) + #=> false + + (filter (n: n < 3) [1 2 3 4]) + #=> [ 1 2 ] + + + # Sets + #========================================= + + # Ein "Set" ist eine ungeordnete Zuordnung mit Stringschlüsseln. + { foo = [1 2]; bar = "x"; } + + # Der . Operator nimmt einen Wert aus dem Set. + { a = 1; b = 2; }.a + #=> 1 + + # Der ? Operator testet, ob der Schlüssel in dem Set vorhanden ist. + ({ a = 1; b = 2; } ? a) + #=> true + ({ a = 1; b = 2; } ? c) + #=> false + + # Der // Operator mergt zwei Sets. + ({ a = 1; } // { b = 2; }) + #=> { a = 1; b = 2; } + + # Werte auf der rechten Seite überschrieben die Werte auf der linken Seite. + ({ a = 1; b = 2; } // { a = 3; c = 4; }) + #=> { a = 3; b = 2; c = 4; } + + # Das Schlüsselwort rec bezeichenet ein "rekursives Set", in der sich Attribute + # aufeinander beziehen können. + (let a = 1; in { a = 2; b = a; }.b) + #=> 1 + (let a = 1; in rec { a = 2; b = a; }.b) + #=> 2 + + # Verschachetelte Sets können stückweise definiert werden. + { + a.b = 1; + a.c.d = 2; + a.c.e = 3; + }.a.c + #=> { d = 2; e = 3; } + + # Die Nachkommen eines Attributs können in diesem Feld nicht zugeordnet werden, wenn + # das Attribut selbst nicht zugeweisen wurde. + { + a = { b = 1; }; + a.c = 2; + } + #=> error: attribute ‘a’ already defined + + + # With + #========================================= + + # Der Körper eines Sets Blocks wird mit der Zurodnung eines Satzes an die Variablen gebunden. + (with { a = 1; b = 2; }; + a + b) + # => 3 + + # Innere Bindungen überschatten äußere Bindungen. + (with { a = 1; b = 2; }; + (with { a = 5; }; + a + b)) + #=> 7 + + # Die erste Linie diese Tutorials startet mit "with builtins;", + # weil builtins ein Set mit allen eingebauten + # Funktionen (length, head, tail, filter, etc.) umfasst. + # Das erspart uns beispielseweise "builtins.length" zu schreiben, + # anstatt nur "length". + + + # Set patterns + #========================================= + + # Sets sind nützlich, wenn du mehrere Werte einer Funktion + # übergeben musst. + (args: args.x + "-" + args.y) { x = "a"; y = "b"; } + #=> "a-b" + + # Dies kann mit Hilfe von Set patterns deutlicher geschrieben werden. + ({x, y}: x + "-" + y) { x = "a"; y = "b"; } + #=> "a-b" + + # Standardmäßig schlägt das Muster bei Sets mit zusätzlichen Schlüsseln fehl. + ({x, y}: x + "-" + y) { x = "a"; y = "b"; z = "c"; } + #=> error: anonymous function called with unexpected argument ‘z’ + + # Durch Hinzufügen von ", ..." können zusätzliche Schlüssel ignoriert werden. + ({x, y, ...}: x + "-" + y) { x = "a"; y = "b"; z = "c"; } + #=> "a-b" + + + # Errors + #========================================= + + # `throw` bewirkt, dass die Auswertung mit einer Fehlermeldung abgebrochen wird. + (2 + (throw "foo")) + #=> error: foo + + # `tryEval` fängt geworfene Fehler. + (tryEval 42) + #=> { success = true; value = 42; } + (tryEval (2 + (throw "foo"))) + #=> { success = false; value = false; } + + # `abort` ist ähnlich wie throw, aber es ist fatal. Es kann nicht gefangen werden. + (tryEval (abort "foo")) + #=> error: evaluation aborted with the following error message: ‘foo’ + + # `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst + # löst es eine abfangbare Exception aus. + (assert 1 < 2; 42) + #=> 42 + (assert 1 > 2; 42) + #=> error: assertion failed at (string):1:1 + (tryEval (assert 1 > 2; 42)) + #=> { success = false; value = false; } + + + # Impurity + #========================================= + + # Da die Wiederholbarkeit von Builds für den Nix Packetmangager entscheidend ist, + # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar + # unreine Elemente. + # Du kannst auf Umgebungsvarialben verweisen. + (getEnv "HOME") + #=> "/home/alice" + + # Die trace Funktion wird zum Debugging verwendet. Sie gibt das erste Argument zu stderr aus + # und evaluiert das zweite Argument. + (trace 1 2) + #=> trace: 1 + #=> 2 + + # Du kannst Dateien in den Nix store schreiben. Obwohl unrein, kannst du dir relativ sicher sein, + # dass es sicher ist, da der Dateiname aus dem Hash des Inhalts abgeleitet wird. + # Du kannst Dateien von überall lesen. In diesem Beispiel schreiben wir Dateien in den Store + # und lesen wieder davon. + (let filename = toFile "foo.txt" "hello!"; in + [filename (builtins.readFile filename)]) + #=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ] + + # Außerdem können wir Dateien in den Nix Store downloaden. + (fetchurl "https://example.com/package-1.2.3.tgz") + #=> "/nix/store/2drvlh8r57f19s9il42zg89rdr33m2rm-package-1.2.3.tgz" + +] +``` + +### Weitere Resourcen + +* [Nix Manual - Nix expression language] + (https://nixos.org/nix/manual/#ch-expression-language) + +* [James Fisher - Nix by example - Part 1: The Nix expression language] + (https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55) + +* [Susan Potter - Nix Cookbook - Nix By Example] + (http://funops.co/nix-cookbook/nix-by-example/) -- cgit v1.2.3 From 10bd172129c2df170c6609a5d209fed8417f76b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20J=C3=BCrges?= Date: Mon, 23 Oct 2017 18:12:14 +0200 Subject: Translated LOLCODE to german --- de-de/LOLCODE-de.html.markdown | 188 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 188 insertions(+) create mode 100644 de-de/LOLCODE-de.html.markdown (limited to 'de-de') diff --git a/de-de/LOLCODE-de.html.markdown b/de-de/LOLCODE-de.html.markdown new file mode 100644 index 00000000..155c5657 --- /dev/null +++ b/de-de/LOLCODE-de.html.markdown @@ -0,0 +1,188 @@ +--- +language: LOLCODE +filename: learnLOLCODE.lol +contributors: + - ["abactel", "https://github.com/abactel"] +translators: + - ["Henrik Jürges", "http://github.com/santifa"] +lang: de-de +--- + +LOLCODE ist eine esoterische Programmiersprache die die Sprache der [lolcats](https://upload.wikimedia.org/wikipedia/commons/a/ab/Lolcat_in_folder.jpg?1493656347257) nachahmt. + +``` +BTW Das ist ein Kommentar +BTW Das Programm muss mit `HAI ` beginnen und mit `KTHXBYE` enden. + +HAI 1.3 +CAN HAS STDIO? BTW Standard Header importieren + +OBTW + ========================================================================== + ============================== Grundlegendes ============================= + ========================================================================== +TLDR + +BTW Texte anzeigen: +VISIBLE "HELLO WORLD" + +BTW Variablen deklarieren: +I HAS A MESSAGE ITZ "CATZ ARE GOOD" +VISIBLE MESSAGE + +OBTW + Variablen sind dynamisch typisiert und der Typ muss nicht explizit + angegeben werden. Die möglichen Typen sind: +TLDR + +I HAS A STRING ITZ "DOGZ ARE GOOOD" BTW Typ ist YARN +I HAS A INTEGER ITZ 42 BTW Typ ist NUMBR +I HAS A FLOAT ITZ 3.1415 BTW Typ ist NUMBAR +I HAS A BOOLEAN ITZ WIN BTW Typ ist TROOF +I HAS A UNTYPED BTW Typ ist NOOB + +BTW Eingaben von Nutzern: +I HAS A AGE +GIMMEH AGE +BTW Die Variable wird als YARN gespeichert und kann in eine +BTW NUMBR konvertiert werden: +AGE IS NOW A NUMBR + +OBTW + ========================================================================== + ================================== MATHE ================================= + ========================================================================== +TLDR + +BTW LOLCODE benutzt polnische Notation für Mathe. + +BTW grundlegende mathematische Notationen: + +SUM OF 21 AN 33 BTW 21 + 33 +DIFF OF 90 AN 10 BTW 90 - 10 +PRODUKT OF 12 AN 13 BTW 12 * 13 +QUOSHUNT OF 32 AN 43 BTW 32 / 43 +MOD OF 43 AN 64 BTW 43 modulo 64 +BIGGR OF 23 AN 53 BTW max(23, 53) +SMALLR OF 53 AN 45 BTW min(53, 45) + +BTW binäre Notation: + +BOTH OF WIN AN WIN BTW und: WIN if x=WIN, y=WIN +EITHER OF FAIL AN WIN BTW oder: FAIL if x=FAIL, y=FAIL +WON OF WIN AN FAIL BTW exklusives oder: FAIL if x=y +NOT FAIL BTW unäre Negation: WIN if x=FAIL +ALL OF WIN AN WIN MKAY BTW beliebige Stelligkeit bei AND +ANY OF WIN AN FAIL MKAY BTW beliebige Stelligkeit bei OR + +BTW Vergleiche: + +BOTH SAEM "CAT" AN "DOG" BTW WIN wenn x == y +DIFFRINT 732 AN 184 BTW WIN wenn x != y +BOTH SAEM 12 AN BIGGR OF 12 AN 4 BTW x >= y +BOTH SAEM 43 AN SMALLR OF 43 AN 56 BTW x <= y +DIFFRINT 64 AN SMALLR OF 64 AN 2 BTW x > y +DIFFRINT 75 AN BIGGR OF 75 AN 643 BTW x < y + +OBTW + ========================================================================== + ============================= Flusskontrolle ============================= + ========================================================================== +TLDR + +BTW If/then Statement: +I HAS A ANIMAL +GIMMEH ANIMAL +BOTH SAEM ANIMAL AN "CAT", O RLY? + YA RLY + VISIBLE "YOU HAV A CAT" + MEBBE BOTH SAEM ANIMAL AN "MAUS" + VISIBLE "NOM NOM NOM. I EATED IT." + NO WAI + VISIBLE "AHHH IS A WOOF WOOF" +OIC + +BTW Case Statement: +I HAS A COLOR +GIMMEH COLOR +COLOR, WTF? + OMG "R" + VISIBLE "RED FISH" + GTFO + OMG "Y" + VISIBLE "YELLOW FISH" + BTW Weil hier kein `GTFO` ist wird auch das nächste Statement überprüft + OMG "G" + OMG "B" + VISIBLE "FISH HAS A FLAVOR" + GTFO + OMGWTF + VISIBLE "FISH IS TRANSPARENT OHNO WAT" +OIC + +BTW For Schleife: +I HAS A TEMPERATURE +GIMMEH TEMPERATURE +TEMPERATURE IS NOW A NUMBR +IM IN YR LOOP UPPIN YR ITERATOR TIL BOTH SAEM ITERATOR AN TEMPERATURE + VISIBLE ITERATOR +IM OUTTA YR LOOP + +BTW While Schleife: +IM IN YR LOOP NERFIN YR ITERATOR WILE DIFFRINT ITERATOR AN -10 + VISIBLE ITERATOR +IM OUTTA YR LOOP + +OBTW + ========================================================================= + ================================ Strings ================================ + ========================================================================= +TLDR + +BTW Zeilenumbrüche: +VISIBLE "FIRST LINE :) SECOND LINE" + +BTW Tabulatoren: +VISIBLE ":>SPACES ARE SUPERIOR" + +BTW Bell (macht beep): +VISIBLE "NXT CUSTOMER PLS :o" + +BTW Anführungszeichen in Strings: +VISIBLE "HE SAID :"I LIKE CAKE:"" + +BTW Doppelpunkte in Strings : +VISIBLE "WHERE I LIVE:: CYBERSPACE" + +OBTW + ========================================================================= + =============================== Funktionen ============================== + ========================================================================= +TLDR + +BTW Definieren einer neuen Funktion: +HOW IZ I SELECTMOVE YR MOVE BTW `MOVE` ist ein Argument + BOTH SAEM MOVE AN "ROCK", O RLY? + YA RLY + VISIBLE "YOU HAV A ROCK" + NO WAI + VISIBLE "OH NO IS A SNIP-SNIP" + OIC + GTFO BTW Gibt NOOB zurück +IF U SAY SO + +BTW Eine Funktion deklarieren und einen Wert zurückgeben: +HOW IZ I IZYELLOW + FOUND YR "YELLOW" +IF U SAY SO + +BTW Eine Funktion aufrufen: +I IZ IZYELLOW MKAY + +KTHXBYE +``` + +## Weiterführende Informationen: + +- [LCI compiler](https://github.com/justinmeza/lci) +- [Official spec](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md) -- cgit v1.2.3 From be1381f6bbcedff978027c80c4a1e579748cb769 Mon Sep 17 00:00:00 2001 From: Senrion Date: Tue, 24 Oct 2017 07:52:54 +0200 Subject: [edn/de] fixing typos --- de-de/edn-de.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/edn-de.html.markdown b/de-de/edn-de.html.markdown index 4f452d7e..2434d1bd 100644 --- a/de-de/edn-de.html.markdown +++ b/de-de/edn-de.html.markdown @@ -41,7 +41,7 @@ false ; Charaktere werden einem Backslash vorangestellt \g \r \a \c \e -; Schlüsselwörter beginnen mit einenm Doppelpunkt. Sie verhalten sich wie Enums. +; Schlüsselwörter beginnen mit einem Doppelpunkt. Sie verhalten sich wie Enums. ; Ähnlich, wie Symbole in Ruby. :eggs :cheese @@ -79,7 +79,7 @@ false #{:a :b 88 "huat"} ;;;;;;;;;;;;;;;;;;;;;;;;; -;;; makierte Elemente ;;; +;;; markierte Elemente ;;; ;;;;;;;;;;;;;;;;;;;;;;;;; ; EDN kann erweitert werden, indem Elemente mit # Symbolen makiert werden. @@ -91,7 +91,7 @@ false (defrecord MenuItem [name rating]) ; Um EDN in clojure Werte umzuwandeln, muss ich den eingebauten EDN Leser -;edn/read-string verwenden +; edn/read-string verwenden (edn/read-string "{:eggs 2 :butter 1 :flour 5}") ; -> {:eggs 2 :butter 1 :flour 5} -- cgit v1.2.3 From 3a41a6006ff421b45ae46a521b900216ac28daf7 Mon Sep 17 00:00:00 2001 From: SmuSmu Date: Thu, 26 Oct 2017 10:15:32 +0200 Subject: html-de.html.markdown removed a Double Point. improved usage part to follow english original --- de-de/html-de.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/html-de.html.markdown b/de-de/html-de.html.markdown index 2ee18129..0bf58f9c 100644 --- a/de-de/html-de.html.markdown +++ b/de-de/html-de.html.markdown @@ -9,7 +9,7 @@ lang: de-de --- HTML steht für HyperText Markup Language (Hypertext-Auszeichnungssprache). -Sie ist eine Sprache, um Seiten für das World Wide Web zu schreiben.. +Sie ist eine Sprache, um Seiten für das World Wide Web zu schreiben. Es ist eine Auszeichnugssprache, die es uns ermöglicht Webseiten mithilfe des Codes zu schreiben, der kennzeichnet wie Text und Daten angezeigt werden sollen. Eigentlich sind HTML Dateien nur einfache Textdateien. Was sind das für Auszeichnungen? Es ist eine Methode, um die Daten der Website zu organisieren mithilfe von Start- und Endtags. Diese Auszeichnung dient dazu dem Text Bedeutung zu geben, welchen sie umschließt. @@ -111,7 +111,7 @@ Dieser Artikel ist bedacht darauf, nur HTML Syntax und nützliche Tipps zu geben ## Verwendung -HTML Dateien enden mit `.html`. +HTML Dateien enden mit `.html` oder mit `.htm`. Der Mime Typ ist meist `text/html`. ## Um mehr zu lernen -- cgit v1.2.3 From 59dc72ceac36b0e6d9785d332570f45553b67b00 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 30 Oct 2017 05:43:23 +0100 Subject: [nix/de] fixed some typos --- de-de/nix-de.html.markdown | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'de-de') diff --git a/de-de/nix-de.html.markdown b/de-de/nix-de.html.markdown index 8c78ffbc..79b60d20 100644 --- a/de-de/nix-de.html.markdown +++ b/de-de/nix-de.html.markdown @@ -58,7 +58,7 @@ with builtins; [ # Strings #========================================= - "String Literale sind in Gänsefüßchen." + "String Literale sind in Anführungszeichen." " String Literale können mehrere @@ -87,7 +87,7 @@ with builtins; [ # Paths #========================================= - # Nix besitzt einen primitven Datentyp für Pfade + # Nix besitzt einen primitiven Datentyp für Pfade /tmp/tutorials/learn.nix # Ein relativer Pfad wird beim Parsing zu einem absoluten Pfad aufgelöst, @@ -170,7 +170,7 @@ with builtins; [ # Listen #========================================= - # Listen werden durck eckige Klammern gekennzeichnet. + # Listen werden durch eckige Klammern gekennzeichnet. (length [1 2 3 "x"]) #=> 4 @@ -218,18 +218,18 @@ with builtins; [ ({ a = 1; } // { b = 2; }) #=> { a = 1; b = 2; } - # Werte auf der rechten Seite überschrieben die Werte auf der linken Seite. + # Werte auf der rechten Seite überschreiben die Werte auf der linken Seite. ({ a = 1; b = 2; } // { a = 3; c = 4; }) #=> { a = 3; b = 2; c = 4; } - # Das Schlüsselwort rec bezeichenet ein "rekursives Set", in der sich Attribute + # Das Schlüsselwort rec bezeichenet ein "rekursives Set", in dem sich Attribute # aufeinander beziehen können. (let a = 1; in { a = 2; b = a; }.b) #=> 1 (let a = 1; in rec { a = 2; b = a; }.b) #=> 2 - # Verschachetelte Sets können stückweise definiert werden. + # Verschachtelte Sets können stückweise definiert werden. { a.b = 1; a.c.d = 2; @@ -238,7 +238,7 @@ with builtins; [ #=> { d = 2; e = 3; } # Die Nachkommen eines Attributs können in diesem Feld nicht zugeordnet werden, wenn - # das Attribut selbst nicht zugeweisen wurde. + # das Attribut selbst nicht zugewiesen wurde. { a = { b = 1; }; a.c = 2; @@ -249,7 +249,7 @@ with builtins; [ # With #========================================= - # Der Körper eines Sets Blocks wird mit der Zurodnung eines Satzes an die Variablen gebunden. + # Der Körper eines Sets Blocks wird mit der Zuordnung eines Satzes an die Variablen gebunden. (with { a = 1; b = 2; }; a + b) # => 3 @@ -263,7 +263,7 @@ with builtins; [ # Die erste Linie diese Tutorials startet mit "with builtins;", # weil builtins ein Set mit allen eingebauten # Funktionen (length, head, tail, filter, etc.) umfasst. - # Das erspart uns beispielseweise "builtins.length" zu schreiben, + # Das erspart uns beispielsweise "builtins.length" zu schreiben, # anstatt nur "length". @@ -318,10 +318,10 @@ with builtins; [ # Impurity #========================================= - # Da die Wiederholbarkeit von Builds für den Nix Packetmangager entscheidend ist, + # Da die Wiederholbarkeit von Builds für den Nix Packetmanager entscheidend ist, # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar # unreine Elemente. - # Du kannst auf Umgebungsvarialben verweisen. + # Du kannst auf Umgebungsvariablen verweisen. (getEnv "HOME") #=> "/home/alice" @@ -331,7 +331,7 @@ with builtins; [ #=> trace: 1 #=> 2 - # Du kannst Dateien in den Nix store schreiben. Obwohl unrein, kannst du dir relativ sicher sein, + # Du kannst Dateien in den Nix Store schreiben. Obwohl unrein, kannst du dir relativ sicher sein, # dass es sicher ist, da der Dateiname aus dem Hash des Inhalts abgeleitet wird. # Du kannst Dateien von überall lesen. In diesem Beispiel schreiben wir Dateien in den Store # und lesen wieder davon. @@ -339,14 +339,14 @@ with builtins; [ [filename (builtins.readFile filename)]) #=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ] - # Außerdem können wir Dateien in den Nix Store downloaden. + # Außerdem können wir Dateien in den Nix Store herunterladen. (fetchurl "https://example.com/package-1.2.3.tgz") #=> "/nix/store/2drvlh8r57f19s9il42zg89rdr33m2rm-package-1.2.3.tgz" ] ``` -### Weitere Resourcen +### Weitere Ressourcen * [Nix Manual - Nix expression language] (https://nixos.org/nix/manual/#ch-expression-language) -- cgit v1.2.3 From 96436a33de166bef190cc59abef4be4e9004f131 Mon Sep 17 00:00:00 2001 From: Stephan Fuhrmann Date: Mon, 13 Nov 2017 15:59:58 +0100 Subject: Fix for wrong/mixed parenthesis usage. --- de-de/make-de.html.markdown | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown index 22c14a69..bc5c7bcb 100644 --- a/de-de/make-de.html.markdown +++ b/de-de/make-de.html.markdown @@ -2,6 +2,7 @@ language: 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 @@ -58,7 +59,7 @@ file2.txt file3.txt: file0.txt file1.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 +# Leere Rezepte zählen nicht und können dazu verwendet werden weitere # Voraussetzungen hinzuzufügen. #----------------------------------------------------------------------- @@ -182,9 +183,9 @@ echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb # Ein paar Variablen die von Make automatisch definiert werden. echo_inbuilt: echo $(CC) - echo ${CXX)} + echo ${CXX} echo $(FC) - echo ${CFLAGS)} + echo ${CFLAGS} echo $(CPPFLAGS) echo ${CXXFLAGS} echo $(LDFLAGS) -- cgit v1.2.3 From 3d847f5efeda8190f58a14ab17682e99340f894f Mon Sep 17 00:00:00 2001 From: Rene Meissner Date: Tue, 27 Feb 2018 12:55:14 +0100 Subject: Update go-de.html.markdown --- de-de/go-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown index 817cb4ae..9409e181 100644 --- a/de-de/go-de.html.markdown +++ b/de-de/go-de.html.markdown @@ -94,7 +94,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ // Arrays haben bei Kompile-Zeit festgelegte Größen var a4 [4]int // Ein Array mit 4 ints, alle mit Initialwert 0 - a3 := [...]int{3, 1, 5} // Ein Array mit 4 ints, Initialwerte wie angezeigt + a3 := [...]int{3, 1, 5} // Ein Array mit 3 ints, Initialwerte wie angezeigt // "slices" haben eine dynamische Größe. Arrays und Slices haben beide ihre // Vorzüge, aber slices werden viel häufiger verwendet -- cgit v1.2.3 From f4c124a9168b5864f9d6b211f9d8ece1c498468d Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Sat, 3 Mar 2018 12:21:26 +0545 Subject: Same filename with english version fix --- de-de/LOLCODE-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/LOLCODE-de.html.markdown b/de-de/LOLCODE-de.html.markdown index 155c5657..57eb0ff8 100644 --- a/de-de/LOLCODE-de.html.markdown +++ b/de-de/LOLCODE-de.html.markdown @@ -1,6 +1,6 @@ --- language: LOLCODE -filename: learnLOLCODE.lol +filename: learnLOLCODE-de.lol contributors: - ["abactel", "https://github.com/abactel"] translators: -- cgit v1.2.3 From caa8993076365c3e650e82a3c5c970dca25ed4c4 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Sun, 4 Mar 2018 19:48:44 -0800 Subject: Assorted fixes --- de-de/markdown-de.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/markdown-de.html.markdown b/de-de/markdown-de.html.markdown index 2c838660..cccf5e68 100644 --- a/de-de/markdown-de.html.markdown +++ b/de-de/markdown-de.html.markdown @@ -14,7 +14,7 @@ Syntax, in der sich Dokumente leicht schreiben *und* lesen lassen. Außerdem sollte Markdown sich leicht nach HTML (und in andere Formate) konvertieren lassen. -```markdown +```md puts item end - + Hermann hatte nicht die leiseste Ahnung, was dieses `go_to()` bedeuten könnte! -- cgit v1.2.3 From 6a4647490122c5dd6b8e1de03b382ce5294dbbfe Mon Sep 17 00:00:00 2001 From: caminsha <31421093+caminsha@users.noreply.github.com> Date: Sat, 6 Apr 2019 11:57:33 +0200 Subject: [asciidoc/de] Added commas --- de-de/asciidoc-de.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown index 24100e0b..e3f64a00 100644 --- a/de-de/asciidoc-de.html.markdown +++ b/de-de/asciidoc-de.html.markdown @@ -88,7 +88,7 @@ Abteilungstitel Listen -Um eine Aufzählung zu erstellen verwendest du Sternchen. +Um eine Aufzählung zu erstellen, verwendest du Sternchen. ``` * foo @@ -96,7 +96,7 @@ Um eine Aufzählung zu erstellen verwendest du Sternchen. * baz ``` -Um eine nummerierte Liste zu erstellen verwendest du Punkte. +Um eine nummerierte Liste zu erstellen, verwendest du Punkte. ``` . item 1 @@ -104,7 +104,7 @@ Um eine nummerierte Liste zu erstellen verwendest du Punkte. . item 3 ``` -Um Listen zu verschachteln musst du zusätzliche Sternchen beziehungsweise Punkte hinzufügen. Dies ist bis zu fünf Mal möglich. +Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise Punkte hinzufügen. Dies ist bis zu fünf Mal möglich. ``` * foo 1 -- cgit v1.2.3 From c0c2272be0275fd2fa935751c6f86eb41e8cef12 Mon Sep 17 00:00:00 2001 From: Rakasch Date: Sat, 6 Apr 2019 20:18:14 +0200 Subject: =?UTF-8?q?Kap.=205+6=20aktualisiert,=20Kap=206.1,=206.2,=207=20hi?= =?UTF-8?q?nzugef=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Kapitel 6.1, 6.2 und 7 aus der englischen Version übernommen. Kapitel 5 und 6 getauscht, um der englischen Version zu entsprechen. Texte der Kapitel 5 und 6 Kapitel um fehlende Teile erweitert. --- de-de/python-de.html.markdown | 359 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 319 insertions(+), 40 deletions(-) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index d3e0fc26..ee77683e 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -386,25 +386,73 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] [add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] [x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Module +#################################################### + +# Wir können Module importieren +import math +print math.sqrt(16) #=> 4.0 + +# Wir können auch nur spezielle Funktionen eines Moduls importieren +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Wir können auch alle Funktionen eines Moduls importieren +# Warnung: Dies wird nicht empfohlen +from math import * + +# Wir können Modulnamen abkürzen +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Module sind in Python nur gewöhnliche Dateien. Wir +# können unsere eigenen schreiben und importieren. Der Name des +# Moduls ist der Dateiname. + +# Wir können herausfinden, welche Funktionen und Attribute in einem +# Modul definiert sind. +import math +dir(math) + +# Wenn Sie ein Python-Skript namens math.py im selben Ordner +# wie Ihr aktuelles Skript haben, wird die Datei math.py +# anstelle des integrierten Python-Moduls geladen. +# Dies geschieht, weil der lokale Ordner Vorrang +# vor den in Python integrierten Bibliotheken hat. + + #################################################### -## 5. Klassen +## 6. Klassen #################################################### -# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten. +# Wir verwenden das Schlüsselwort "class" um eine Klasse zu erzeugen. class Human(object): # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt species = "H. sapiens" - # Ein simpler Konstruktor + # Ein simpler Konstruktor, wird aufgerufen, wenn diese Klasse instanziiert wird. + # Beachten Sie, dass die doppelten vorangestellten und nachgestellten + # Unterstriche Objekte oder Attribute bezeichnen, die von Python verwendet werden, + # aber in benutzergesteuerten Namespaces leben. + # Methoden (oder Objekte oder Attribute) wie: __init__, __str__, __repr__ usw. + # werden als Sondermethoden (oder manchmal als Dundermethoden bezeichnet) bezeichnet. + # Sie sollten solche Namen nicht selbst erfinden. def __init__(self, name): # Wir weisen das Argument name dem name-Attribut der Instanz zu self.name = name - # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument. + # Eine Instanzmethode. Alle Methoden erhalten "self" als erstes Argument. def say(self, msg): return "%s: %s" % (self.name, msg) + # Eine weitere Instanzmethode + def sing(self): + return 'yo... yo... microphone check... one two... one two...' + # Eine Klassenmethode wird von allen Instanzen geteilt. # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen @classmethod @@ -416,56 +464,287 @@ class Human(object): def grunt(): return "*grunt*" + # Eine Eigenschaft (Property) ist wie ein Getter. +    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen. +    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben. + @property + def age(self): + return self._age + +    # Damit kann die Eigenschaft festgelegt werden + @age.setter + def age(self, age): + self._age = age + +    # Damit kann die Eigenschaft gelöscht werden + @age.deleter + def age(self): + del self._age + +# Wenn ein Python-Interpreter eine Quelldatei liest, führt er den gesamten Code aus. +# Diese __name__-Prüfung stellt sicher, dass dieser Codeblock nur ausgeführt wird, +# wenn dieses Modul das Hauptprogramm ist. +if __name__ == '__main__': + # Eine Instanz einer Klasse erstellen + i = Human(name="Ian") + i.say("hi") # "Ian: hi" + j = Human("Joel") + j.say("hello") # "Joel: hello" + # i und j sind Instanzen des Typs Mensch, oder anders ausgedrückt: Sie sind Objekte des Menschen + + # Rufen wir unsere Klassenmethode auf + i.say(i.get_species()) # "Ian: H. sapiens" + + # Ändern wir das gemeinsame Attribut + Human.species = "H. neanderthalensis" + i.say(i.get_species()) # => "Ian: H. neanderthalensis" + j.say(j.get_species()) # => "Joel: H. neanderthalensis" + + # Aufruf der statischen Methode + print(Human.grunt()) # => "*grunt*" + + # Kann keine statische Methode mit Instanz des Objekts aufrufen, + # da i.grunt () automatisch "self" (das Objekt i) als Argument verwendet + print(i.grunt()) # => TypeError: grunt() takes 0 positional arguments but 1 was given + + # Die Eigenschaft für diese Instanz aktualisieren + i.age = 42 + # die Eigenschaft auslesen + i.say(i.age) # => "Ian: 42" + j.say(j.age) # => "Joel: 0" + # die Eigenschaft löschen + del i.age + # i.age # => würde einen AttributeError werfen + +#################################################### +## 6.1 Inheritance +#################################################### + +# Vererbung ermöglicht die Definition neuer untergeordneter Klassen, +# die Methoden und Variablen von ihrer übergeordneten Klasse erben. + +# Wenn Sie die oben definierte Human-Klasse als Basis- oder Elternklasse verwenden, +# können Sie eine untergeordnete Klasse, Superhero, definieren, die die Klassenvariablen +# wie "species", "name" und "age" sowie Methoden wie "sing" und "grunzen" aus der Klasse Human erbt. +# Die Untergeordnete Klasse kann aber auch eigene Eigenschaften haben. + +# Um von der Modularisierung per Datei zu profitieren, können Sie die Klassen +# in ihren eigenen Dateien platzieren, z. B. human.py + +# Um Funktionen aus anderen Dateien zu importieren, verwenden Sie das folgende Format +# from "Dateiname-ohne-Erweiterung" impotr "Funktion-oder-Klasse" + +from human import Human + +# Geben Sie die übergeordnete(n) Klasse(n) als Parameter für die Klassendefinition an +class Superhero(Human): + + # Wenn die untergeordnete Klasse alle Definitionen des übergeordneten Elements + # ohne Änderungen erben soll, können Sie einfach das Schlüsselwort "pass" + # (und nichts anderes) verwenden. In diesem Fall wird jedoch auskommentiert, + # um eine eindeutige untergeordnete Klasse zuzulassen: + # pass + + # Kindklassen können die Attribute ihrer Eltern überschreiben + species = 'Superhuman' + + # Kinder erben automatisch den Konstruktor ihrer übergeordneten Klasse + # einschließlich ihrer Argumente, können aber auch zusätzliche Argumente oder + # Definitionen definieren und ihre Methoden zB den Klassenkonstruktor überschreiben. + # Dieser Konstruktor erbt das Argument "name" von der Klasse "Human" und + # fügt die Argumente "superpowers" und "movie" hinzu: + def __init__(self, name, movie=False, + superpowers=["super strength", "bulletproofing"]): + + # zusätzliche Klassenattribute hinzufügen: + self.fictional = True + self.movie = movie + # Beachten Sie die veränderlichen Standardwerte, da die Standardwerte gemeinsam genutzt werden + self.superpowers = superpowers + + # Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse + # zugreifen, die vom untergeordneten Objekt überschrieben werden, + # in diesem Fall die Methode __init__. +        # Dies ruft den Konstruktor der übergeordneten Klasse auf: + super().__init__(name) + + # überschreiben der "sing" Methode + def sing(self): + return 'Dun, dun, DUN!' + + # eine zusätzliche Instanzmethode hinzufügen + def boast(self): + for power in self.superpowers: + print("I wield the power of {pow}!".format(pow=power)) + +if __name__ == '__main__': + sup = Superhero(name="Tick") + + # Instanztypprüfungen + if isinstance(sup, Human): + print('I am human') + if type(sup) is Superhero: + print('I am a superhero') + + # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird. +    # Dieses Attribut ist dynamisch und kann aktualisiert werden. + print(Superhero.__mro__) # => (, + # => , ) + + # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut + print(sup.get_species()) # => Superhuman + + # Ruft die überschriebene Methode auf + print(sup.sing()) # => Dun, dun, DUN! + + # Ruft die Methode von Human auf + sup.say('Spoon') # => Tick: Spoon + + # Aufruf einer Methode, die nur in Superhero existiert + sup.boast() # => I wield the power of super strength! + # => I wield the power of bulletproofing! + + # Vererbtes Klassenattribut + sup.age = 31 + print(sup.age) # => 31 + + # Attribut, das nur in Superhero existiert + print('Am I Oscar eligible? ' + str(sup.movie)) + +#################################################### +## 6.2 Multiple Inheritance +#################################################### -# Eine Instanz einer Klasse erstellen -i = Human(name="Ian") -print i.say("hi") # gibt "Ian: hi" aus +# Eine weitere Klassendefinition +# bat.py -j = Human("Joel") -print j.say("hello") #gibt "Joel: hello" aus +class Bat: -# Rufen wir mal unsere Klassenmethode auf -i.get_species() #=> "H. sapiens" + species = 'Baty' -# Ändern wir mal das gemeinsame Attribut -Human.species = "H. neanderthalensis" -i.get_species() #=> "H. neanderthalensis" -j.get_species() #=> "H. neanderthalensis" + def __init__(self, can_fly=True): + self.fly = can_fly -# Aufruf der statischen Methode -Human.grunt() #=> "*grunt*" + # This class also has a say method + def say(self, msg): + msg = '... ... ...' + return msg + # And its own method as well + def sonar(self): + return '))) ... (((' +if __name__ == '__main__': + b = Bat() + print(b.say('hello')) + print(b.fly) + +# Und noch eine andere Klassendefinition, die von Superhero und Bat erbt +# superhero.py +from superhero import Superhero +from bat import Bat + +# Definieren Sie Batman als eine Kindklasse, das von Superheld und Bat erbt +class Batman(Superhero, Bat): + + def __init__(self, *args, **kwargs): + # In der Regel müssen Sie super aufrufen, um Attribute zu erben: + # super (Batman, selbst) .__ init__ (* args, ** kwargs) + # Allerdings handelt es sich hier um Mehrfachvererbung, und super() + # funktioniert nur mit der nächsten Basisklasse in der MRO-Liste. + # Stattdessen rufen wir explizit __init__ für alle Vorfahren auf. + # Die Verwendung von *args und **kwargs ermöglicht die saubere Übergabe von + # Argumenten, wobei jedes übergeordnete Element eine Schicht der Zwiebel "abschält". + Superhero.__init__(self, 'anonymous', movie=True, + superpowers=['Wealthy'], *args, **kwargs) + Bat.__init__(self, *args, can_fly=False, **kwargs) + # überschreibt den Wert für das Namensattribut + self.name = 'Sad Affleck' + + def sing(self): + return 'nan nan nan nan nan batman!' + +if __name__ == '__main__': + sup = Batman() + + # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, + # die sowohl von getattr() als auch von super() verwendet wird. + # Dieses Attribut ist dynamisch und kann aktualisiert werden. + print(Batman.__mro__) # => (, + # => , + # => , + # => , ) + + # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut + print(sup.get_species()) # => Superhuman + + # Ruft die überschriebene Methode auf + print(sup.sing()) # => nan nan nan nan nan batman! + + # Ruft die Methode von Human auf, weil die Reihenfolge der Vererbung wichtig ist + sup.say('I agree') # => Sad Affleck: I agree + + # Aufrufmethode, die nur im 2. Vorfahren existiert + print(sup.sonar()) # => ))) ... ((( + + # Vererbtes Klassenattribut + sup.age = 100 + print(sup.age) # => 100 + + # Vererbtes Attribut vom 2. Vorfahren, dessen Standardwert überschrieben wurde. + print('Can I fly? ' + str(sup.fly)) # => Can I fly? False + + #################################################### -## 6. Module -#################################################### - -# Wir können Module importieren -import math -print math.sqrt(16) #=> 4.0 +## 7. Fortgeschrittenes +#################################################### + +# Generatoren helfen Ihnen, lazy Code zu erstellen. +def double_numbers(iterable): + for i in iterable: + yield i + i + +# Generatoren sind speichereffizient, da sie nur die Daten laden, +# die zur Verarbeitung des nächsten Werts in der iterierbaren Komponente +# erforderlich sind. Dadurch können sie ansonsten unzulässig große Wertebereiche ausführen. +# HINWEIS: `range` ersetzt` xrange` in Python 3. +for i in double_numbers(range(1, 900000000)): # `range` ist ein Generator. + print(i) + if i >= 30: + break + +# Genauso wie Sie ein 'list comprehension' (Listen Abstraktion) erstellen können, können Sie auch 'generator comprehension' (Generator Abstraktion) erstellen. +values = (-x for x in [1,2,3,4,5]) +for x in values: + print(x) # prints -1 -2 -3 -4 -5 to console/terminal + +# Sie können eine Generator Abstraktion auch direkt in eine Liste umwandeln (casten). +values = (-x for x in [1,2,3,4,5]) +gen_to_list = list(values) +print(gen_to_list) # => [-1, -2, -3, -4, -5] -# Wir können auch nur spezielle Funktionen eines Moduls importieren -from math import ceil, floor -print ceil(3.7) #=> 4.0 -print floor(3.7) #=> 3.0 +# Decorators +# In diesem Beispiel umschliesst "beg" "say". Wenn say_please True ist, wird die zurückgegebene Nachricht geändert. +from functools import wraps -# Wir können auch alle Funktionen eines Moduls importieren -# Warnung: Dies wird nicht empfohlen -from math import * +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Please! I am poor :(") + return msg -# Wir können Modulnamen abkürzen -import math as m -math.sqrt(16) == m.sqrt(16) #=> True + return wrapper -# Module sind in Python nur gewöhnliche Dateien. Wir -# können unsere eigenen schreiben und importieren. Der Name des -# Moduls ist der Dateiname. +@beg +def say(say_please=False): + msg = "Can you buy me a beer?" + return msg, say_please -# Wir können auch die Funktionen und Attribute eines -# Moduls herausfinden. -import math -dir(math) +print(say()) # Can you buy me a beer? +print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( ``` -- cgit v1.2.3 From 6be11a3b47395c6b14f2dc0b6469f83146372c58 Mon Sep 17 00:00:00 2001 From: LamdaLamdaLamda <25778959+LamdaLamdaLamda@users.noreply.github.com> Date: Mon, 20 May 2019 13:14:17 +0200 Subject: [C++/de] added. (#3527) * Added [C++/de] * [C++/de] filename fixed. * [C++/de] language code in filename added * [C++/de] file duplicate removed --- de-de/c++-de.html.markdown | 1160 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1160 insertions(+) create mode 100644 de-de/c++-de.html.markdown (limited to 'de-de') diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown new file mode 100644 index 00000000..23cc26a8 --- /dev/null +++ b/de-de/c++-de.html.markdown @@ -0,0 +1,1160 @@ +--- +language: c++ +filename: learncpp-de.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] + - ["Geoff Liu", "http://geoffliu.me"] + - ["Connor Waters", "http://github.com/connorwaters"] + - ["Ankush Goyal", "http://github.com/ankushg07"] + - ["Jatin Dhankhar", "https://github.com/jatindhankhar"] + - ["Maximilian Sonnenburg", "https://github.com/LamdaLamdaLamda"] +--- + +C++ ist eine Systemprogrammiersprache die, + +[laut dem Begründer Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote) +entworfen wurde um, + +- "besseres C" zu sein +- Datenabstraktion zu unterstützen +- Objektorientierung zu unterstützen +- generische Programmierung zu unterstützen + +Durch seinen Syntax kann sie durchaus schwieriger und komplexer als neuere Sprachen sein. +Sie ist weit verbeitet, weil sie in Maschinen-Code compiliert, welches direkt vom Prozessor ausgeführt +werden kann und somit eine strikte Kontrolle über die Hardware bietet und gleichzeitig +High-Level-Features wie generics, exceptions und Klassen enthält. (wie C) +Diese Kombination aus Geschwindigkeit und Funktionalität bildet C++ und ist eine der +weitverbreitesten Programmiersprachen. + +```c++ +////////////////// +// Vergleich zu C +////////////////// + +// C++ ist fast eine Untermenge von C and teilt sich grundsätzlich den +// Syntax für Variablen Deklarationen, primitiven Typen und Funktionen. + +// Wie in C ist der Programmeinsprungpunkt eine Funktion, welche "main" genannt wird und +// einen Ineteger als Rückgabetyp besitzt. +// Dieser Wert fungiert als Beendigungsstatus des Programms. +// Siehe: https://de.wikipedia.org/wiki/Return_Code für weitere Informationen +int main(int argc, char** argv) +{ + // Kommandozeilen Argumente werden genauso wie in C über argc und argv übergeben + // argc entspricht der Anzahl von Argumenten und argv ist ein Array von C-style + // strings (char*), welche die Argumente repräsentieren. + // Das erste Argument ist der Name des Programms welches aufgerufen wird. + // Argc und argv können, wenn nicht benötigt, weg gelassen werden, indem + // die Funktionssignatur "int main()" verwendet wird. + + // Ein Rückgabewert von 0 repräsentiert die erfolgreiche Ausführung. + return 0; +} + +// C++ unterscheidet sich in einigen Punkten: + +// In C++ sind Zeichen-Literale chars +sizeof('c') == sizeof(char) == 1 + +// In C sind Zeichen-Literale ints +sizeof('c') == sizeof(int) + +// C++ verwendet striktes prototyping +void func(); // Funktion ohne Argumente + +// In C +void func(); // Funktion mit beliebiger Anzahl von Argumenten + +// Verwende nullptr, anstatt von NULL!!! +int* ip = nullptr; + +// C standard headers sind in C++ verfügbar. +// C header enden mit .h, während +// C++ header das Präfix "c" besitzen und kein ".h" Suffix verwenden. + +// Die C++ Standard Version: +#include + +// Die C Standard Version: +#include + +int main() +{ + printf("Hello, world!\n"); + return 0; +} + +/////////////////////// +// Funktionsüberladung +/////////////////////// + +// C++ unterstützt Funktionsüberladung +// Jede Funktion kann unterschiedliche Parameter erhalten. +void print(char const* myString) +{ + printf("String %s\n", myString); +} + +void print(int myInt) +{ + printf("My int is %d", myInt); +} + +int main() +{ + print("Hello"); // Wird aufgelöst zu "void print(const char*)" + print(15); // Wird aufgelöst zu "void print(int)" +} + +///////////////////////////// +// Standard Funktionsargumente +///////////////////////////// + +// Argumente können per Standard für eine Funktion gesetzt werden, +// wenn diese beim Aufruf nicht bereitgestellt werden. + +void doSomethingWithInts(int a = 1, int b = 4) +{ + // führe Anweisungen mit "ints" aus. +} + +int main() +{ + doSomethingWithInts(); // a = 1, b = 4 + doSomethingWithInts(20); // a = 20, b = 4 + doSomethingWithInts(20, 5); // a = 20, b = 5 +} + +// Standard-Argumente müssen am Ende der Liste der Argumente stehen. +void invalidDeclaration(int a = 1, int b) // Fehler! +{ +} + + +///////////// +// Namespaces (Namesräume) +///////////// + +// Namespaces stellen einen getrennten Gültigkeitsbereich für Variablen, +// Funktionen und andere Deklarationen zur Verfügung. +// Namespaces können geschachtelt werden. +namespace First +{ + namespace Nested + { + void foo() + { + printf("This is First::Nested::foo\n"); + } + } // Ende des Namespaces "Nested" +} // Ende des Namespaces "First" + +namespace Second +{ + void foo() + { + printf("This is Second::foo\n"); + } +} + +void foo() +{ + printf("This is global foo\n"); +} + +int main() +{ + // Fügt all Symbole aus dem namespace Second in den aktuellen Gültigkeitsbereich (scope). + // "foo()" wird nun nicht länger funktionieren, da es nun doppeldeutig ist, ob foo aus + // dem namespace foo oder darüberliegenden aufgerufen wird. + using namespace Second; + + Second::foo(); // Gibt "This is Second::foo" aus. + First::Nested::foo(); // Gibt "This is First::Nested::foo" aus. + ::foo(); // Gibt "This is global foo" aus. +} + +/////////////// +// Eingabe/Ausgabe +/////////////// + +// C++ verwendet für die Eingabe und Ausgabe streams. +// cin, cout und cerr repräsentieren stdin, stdout und stderr. +// << ist der Einfügeoperator und >> ist der Extraktionsoperator. + +#include // Include für Eingabe/Ausgabe (I/O) streams + +using namespace std; // Streams befinden sich im std namespace (standard library) + +int main() +{ + int myInt; + + // Ausgabe auf stdout (oder Terminal/Bildschirm) + cout << "Enter your favorite number:\n"; + + // Empfängt Eingabe + cin >> myInt; + + // cout kann ebenfalls formatiert werden + cout << "Your favorite number is " << myInt << "\n"; + // Gibt "Your favorite number is " aus + + cerr << "Used for error messages"; +} + +////////// +// Zeichenketten (Strings) +////////// + +// Strings in C++ sind Objekte und haben diverse member-functions +#include + +using namespace std; // Strings sind ebenfalls im namespace std (Standard Bibliothek) + +string myString = "Hello"; +string myOtherString = " World"; + +// + wird für das Anhängen von strings verwendet. +cout << myString + myOtherString; // "Hello World" + +cout << myString + " You"; // "Hello You" + +// C++ strings sind mutable. +myString.append(" Dog"); +cout << myString; // "Hello Dog" + + +///////////// +// Referenzen +///////////// + +// Zusätzlich zu Pointern, wie jene in C. +// C++ besitzt _Referenzen_. +// Diese sind Pointer-Typen, welche nicht erneut zugewiesen werden können +// und nicht Null sein können. +// Sie besitzen den selben Synthax wie Variablen. +// Für die Dereferenzierung ist kein * notwendig und +// & (die Adresse) wird nicht für die Zuweisung verwendet. + +using namespace std; + +string foo = "I am foo"; +string bar = "I am bar"; + + +string& fooRef = foo; // Erzeugt eine Referenz auf foo. +fooRef += ". Hi!"; // Verändert foo durch die Referenz +cout << fooRef; // Gibt "I am foo. Hi!" aus. + + +// Weist "fooRef" nicht erneut zu. Dies ist dasselbe, wie "foo = bar" und +// foo == "I am bar" +// nach dieser Zeile +cout << &fooRef << endl; // Gibt die Adresse von foo aus +fooRef = bar; +cout << &fooRef << endl; // Gibt ebenfalls die Adresse von foo aus +cout << fooRef; // Gibt "I am bar" aus + +// Die Adresse von fooRef verbleibt die selbe, sie verweist immer noch auf foo + + +const string& barRef = bar; // Erzeugt konstante Referenz auf bar. +// Wie in C, können konstante Werte ( und Pointer bzw. Referenzen) nicht verändert werden. + +barRef += ". Hi!"; // Fehler: konstante Referenzen können nicht verändert werden. + +// Hinweis: bevor wir genauer Referenzen besprechen, schauen wir uns zuerst ein Konzept an +// welches als "temporäres Objekt" bezeichnet wird. Gehen wir von folgenden Code aus: +string tempObjectFun() { ... } +string retVal = tempObjectFun(); + +// Was passiert nun in der zweiten Zeile: +// - ein String Objekt wird von tempObjectFun zurückgegeben +// - ein neuer String wird mit dem zurückgegebenen Objekt als Argument für den Konstruktor erzeugt. +// - das zurückgegebene Objekt wird zerstört +// Das zurückgegbene Objekt wird temporäres Objekt genannt. Temporäre Objekte werden erzeugt +// wann immer eine Funktion ein Objekt zurückgibt. Zerstört werden diese am Ende der Auswertung des Ausdrucks +// (dies schreibt der Standard vor, aber Compiler sind berechtigt dieses Verhalten zu ändern. Siehe "return value optimization" +// für Details). Wie in diesem Code: +foo(bar(tempObjectFun())) + +// Nehmen wir an foo und bar existieren. Das Objekt wird von "tempObjectFun" zurückgegeben, +// wird an bar übergeben und ist zerstört bevor foo aufgerufen wird. + +// Zurück zu Referenzen. Die Ausnahme, dass die "am Ende des Ausdrucks" Regel ist gültig, +// wenn das temporäre Objekt an eine konstante Referenz gebunden ist, in welchem Fall das +// Leben auf den aktuellen Gültigkeitsbereich erweitert wird. + +void constReferenceTempObjectFun() { + // constRef erhält das temporäre Objekt und ist gültig bis ans Ende der Funktion + const string& constRef = tempObjectFun(); + ... +} + +// Eine andere Art von Referenzen wird in C++11 eingeführt und ist speziell für +// temporäre Objekte. Es ist nicht möglich Variablen des Typs zu besitzen, aber +// Vorrechte bei der Auflösung. +void someFun(string& s) { ... } // Reguläre Referenz +void someFun(string&& s) { ... } // Referenz auf ein temporäres Objekt + +string foo; +someFun(foo); // Ruft die Funktion mit der regulären Referenz auf +someFun(tempObjectFun()); // Ruft die Funktion mit der temporären Referenz auf + +// Zum Beispiel existieren diese zwei Varianten von Konstruktoren für +// std::basic_string: +basic_string(const basic_string& other); +basic_string(basic_string&& other); + +// Nehmen wir an, wir erzeugen einen neuen String eines temporären Objekts (welches später +// zerstört wird), hierbei existiert ein effizienterer Konstruktor. Dieses Konzept wird +// als "move semantics" bezeichnet (bewegen eines Objekts in ein anderes in C++). + +///////////////////// +// Enumerations (Aufzählungstypen) +///////////////////// + +// Enums sind eine einfachere Art und Weise einen Wert einer Konstante zu zuweisen. +// Häufig wird dies verwendet, um den Code lesbarer zu gestalten bzw. zu visualisieren. +enum ECarTypes +{ + Sedan, + Hatchback, + SUV, + Wagon +}; + +ECarTypes GetPreferredCarType() +{ + return ECarTypes::Hatchback; +} + +// Mit C++11 existiert eine einfache Möglichkeit einem Typ dem Enum zu zuweisen. Dies +// kann durchaus sinnvoll bei der Serialisierung von Daten sein, oder bei der Konvertierung +// zwischen Typen bzw. Konstanten. +enum ECarTypes : uint8_t +{ + Sedan, // 0 + Hatchback, // 1 + SUV = 254, // 254 + Hybrid // 255 +}; + +void WriteByteToFile(uint8_t InputValue) +{ + // Serialisierung von InputValue in eine Datei +} + +void WritePreferredCarTypeToFile(ECarTypes InputCarType) +{ + // Das enum wird implizit zu einem "uint8_t" konvertiert. Bedingt dadurch, dass + // es sich um ein enum handelt. + WriteByteToFile(InputCarType); +} + +// Nicht immer ist es gewünscht, dass enums zu einem Integer oder zu einem anderen +// enum umgewandelt werden. Daher ist es möglich eine enum-Klasse zu erzeugen, welche +// nicht implizit umgewandelt wird. +enum class ECarTypes : uint8_t +{ + Sedan, // 0 + Hatchback, // 1 + SUV = 254, // 254 + Hybrid // 255 +}; + +void WriteByteToFile(uint8_t InputValue) +{ + // Serialisierung von InputValue in eine Datei +} + +void WritePreferredCarTypeToFile(ECarTypes InputCarType) +{ + // Wird nicht kompilieren, da ECarTypes ein "uint8_t" ist, da das enum + // als "enum class" deklariert wurde! + WriteByteToFile(InputCarType); +} + +////////////////////////////////////////// +// Klassen und objekorientierte Programmierung +////////////////////////////////////////// + +// Erstes Beispiel einer Klasse +#include + +// Deklaration einer Klasse. +// Klassen werden üblicherweise im header (.h oder .hpp) deklariert. +class Dog +{ + // Member Variablen und Funktionen sind private per default (standard). + std::string name; + int weight; + +// Alle nachfolgenden member sind "public" bis +// "private:" oder "protected:" auftritt. +public: + + // Standard Konstruktor + Dog(); + + // Member-Funktonensdeklaration (Implementierung folgt) + // Bemerkung: std::string statt der Verwendung von namespace std; + // "using namespace" sollte niemals in einem header verwendet werden. + void setName(const std::string& dogsName); + + void setWeight(int dogsWeight); + + // Funktionen, die Objekte nicht ändern sollte mit const deklariert werden. + // Funktionen müssen explizit als "virtual" deklariert werden, um in einer + // abgeleiteten Klassen überschrieben zu werden. + // Aus performance Gründen sind Funktionen nicht per default virtual. + virtual void print() const; + + // Funktionen können ebenfalls im class body definiert werden. + // Derart definierte Funktionen sind automatisch "inline". + void bark() const { std::cout << name << " barks!\n"; } + + // Neben Konstruktoren, bietet C++ Destruktoren. + // Diese werden aufgerufen, wenn ein Objekt freigegeben wird oder + // seinen Wertebereich verlässt. + // Dies ermöglicht mächtige Paradigmen, wie auch RAII. + // Destruktoren sollten virtual sein, wenn eine Klasse von ihr + // abgeleitet wird. Ist dieser nicht virtual, dann wird der + // Destruktor der abgeleiteten Klasse nicht aufgerufen, insofern + // das Objekt durch eine Referenz/Pointer der Basisklasse entfernt wird. + virtual ~Dog(); + +}; // Ein Semikolon schließt die Definition der Klasse ab. + +// Klassen-Member-Funktionen sind üblicherweise in der .cpp Datei implmentiert. +Dog::Dog() +{ + std::cout << "A dog has been constructed\n"; +} + +// Objekte sollten als Referenz übergeben werden und wenn diese nicht +// verändert werden sollen, sollte das Objekt als const Referenz übergeben werden. +void Dog::setName(const std::string& dogsName) +{ + name = dogsName; +} + +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; +} + +// "Virtual" wird nur bei der Deklaration benötigt und nicht bei der Definition. +void Dog::print() const +{ + std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; +} + +Dog::~Dog() +{ + std::cout << "Goodbye " << name << "\n"; +} + +int main() +{ + Dog myDog; // Ausgabe: "A dog has been constructed" + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.print(); // Ausgabe: "Dog is Barkley and weighs 10 kg" + return 0; +} // Ausgabe: "Goodbye Barkley" + +// Vererbung: + +// Diese Klasse erbt alles was public bzw. protected ist von der Dog-Klasse +// und darüber hinaus auch private Methoden/Attribute, jedoch kann auf diese +// nicht direkt zugegriffen werden. Lediglich über public/procted getter/setter. +class OwnedDog : public Dog { + +public: + void setOwner(const std::string& dogsOwner); + + // Überschreibt das Verhalten der "print" Funktion für alle "OwnedDogs". + // Siehe: http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping + // für eine grundlegende Einführung in "Subtype Polymorphismus". + // Das "override" Schlüsselwort ist optional, aber stellt sicher, dass die + // Methode der Basisklasse tatsächlich überschrieben wurde. + void print() const override; + +private: + std::string owner; +}; + +// Die zugehörige .cpp Datei +void OwnedDog::setOwner(const std::string& dogsOwner) +{ + owner = dogsOwner; +} + +void OwnedDog::print() const +{ + Dog::print(); // Ruft die "print" Funktion der Basisklasse auf. + std::cout << "Dog is owned by " << owner << "\n"; + // Ausgaben: "Dog is and weights " + // "Dog is owned by " +} + +////////////////////////////////////////// +// Initialisierung und Operatorüberladung +////////////////////////////////////////// + +// In C++ können Operatoren wie: +, -, *, / etc. überladen werden. +// Dies wird umgesetzt, indem eine entsprechende Funktion definiert wird, +// welche immer dann aufgerufen wird, sobald der Operator verwendet wird. +#include +using namespace std; + +class Point +{ +public: + // Member Variablen können mit einem default Wert initialisiert werden. + double x = 0; + double y = 0; + + // Definition des Standard Konstruktor, welcher nichts tut + // außer den Punkt auf den default Wert (0,0) zu setzen. + Point() { }; + + // Die nachfolgende Syntax ist bekannt als "initialization list" + // und ist eine gängige Art Klassen-Member zu initialisieren. + Point (double a, double b) : + x(a), + y(b) + { /* Außschließliche Initialisierung der Werte */ } + + // Überladung des "+" Operator. + Point operator+(const Point& rhs) const; + + // Überladung des "+=" Operator + Point& operator+=(const Point& rhs); + + // Sinnhaft wäre es an dieser Stelle den "-" und "-=" Operator + // ebenfalls zu überladen. +}; + +Point Point::operator+(const Point& rhs) const +{ + // Erzeugung eines neuen Punkts, welcher die Summe aus sich + // selbst und "rhs" bildet + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () +{ + Point up (0,1); + Point right (1,0); + + // Ruft den + Operator mit den entsprechenden Parametern auf. + Point result = up + right; + // Ausgabe: "Result is upright (1,1)" + cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + return 0; +} + +///////////////////// +// Templates +///////////////////// + +// Templates in C++ werden in erster Linie dafür verwendet generisch zu programmieren. +// Sie unterstützen explizite und partielle Spezialisierung und darüber hinaus können +// sie für funktionale Klassen verwendet werden. +// Tatsächlich bilden templates die Turing-Vollständigkeit +// (universelle Programmierbarkeit) ab. + + +// Zu Beginn ein einführendes Beispiel der generischen Programmierung. +// Die Definition einer Klasse bzw. Funktion, welche mit dem Typ T parametriert wird. +template +class Box +{ +public: + // T repräsentiert an dieser Stelle einen beliebigen Typen. + void insert(const T&) { ... } +}; + +// Während der Kompilierung generiert der Kompiler Kopien für jedes Template, wobei +// hierbei die Parameter substituiert werden. Somit muss bei jedem Aufruf die gesamte +// Definition der Klasse zur Verfügung stehen. Aus diesem Grund wird ein Template +// komplett im header definiert. + +// Erzeugung einer Template-Klasse auf dem stack: +Box intBox; + +// eine der zu erwartenden Verwendungen: +intBox.insert(123); + +// Verschachtelungen von Templates sind möglich. +Box > boxOfBox; +boxOfBox.insert(intBox); + +// Bis C++11 war es erforderlich ein Leerzeichen zwischen '>' einzufügen, +// andernfalls wurde es als '>>' geparsed (right shift). + +// Manchmal ist folgende Notation anzutreffen: +// template +// Das 'class' Schlüsselwort und das 'typename' Schlüsselwort +// sind fast identisch hinsichtlich der Funktionalität. Weitere +// Informationen auf: http://en.wikipedia.org/wiki/Typename + +// Eine template-Funktion: +template +void barkThreeTimes(const T& input) +{ + input.bark(); + input.bark(); + input.bark(); +} + +// Hierbei ist zu beachten, dass an dieser Stelle nichts über den Typen des Parameters +// definiert wurde. Der Kompiler wird bei jedem Aufruf bzw. jeder Erzeugung den Typen +// prüfen. Somit funktioniert die zuvor definiert Funktion für jeden Typ 'T', die die +// const Methode 'bark' implementiert hat. + +Dog fluffy; +fluffy.setName("Fluffy") +barkThreeTimes(fluffy); // Gibt "Fluffy barks" dreimal aus. + +// Template Parameter müssen keine Klassen sein. +template +void printMessage() +{ + cout << "Learn C++ in " << Y << " minutes!" << endl; +} + +// Des Weiteren können templates aus Effizienzgründen genauer spezifiziert werden. +// Selbstverständlich sind reale-Problemen, welche genauer spezifiziert werden nicht +// derart trivial. Auch wenn alle Parameter explizit definiert wurden, muss die +// Funktion oder Klasse als template deklariert werden. +template<> +void printMessage<10>() +{ + cout << "Learn C++ faster in only 10 minutes!" << endl; +} + +printMessage<20>(); // Gibt "Learn C++ in 20 minutes!" aus. +printMessage<10>(); // Gibt "Learn C++ faster in only 10 minutes!" aus. + + +///////////////////// +// Ausnahme Behandlungen (Exception-Handling) +///////////////////// + +// Die Standard Bibliothek bietet einige Exceptions. +// Siehe: http://en.cppreference.com/w/cpp/error/exception. +// Grundsätzlich können alle Typen als Exception geworfen werden. +#include +#include + +// Alle Exceptions, die in dem "try" Block geworfen werden, können mittels +// "catch" abgefangen werden. +try +{ + // Exceptions sollten nicht auf dem heap mithilfe + // von "new" allokiert werden. + throw std::runtime_error("A problem occurred"); +} + +// Exceptions sollten als const Referenz abgefangen werden +// insofern diese Objekte sind. +catch (const std::exception& ex) +{ + std::cout << ex.what(); +} + +// Abfangen aller Exceptions, welche zuvor nicht abgefangen wurden. +catch (...) +{ + std::cout << "Unknown exception caught"; + throw; // Erneutes werfen der exception +} + +/////// +// RAII +/////// + +// RAII steht für "Resource Acquisition Is Initialization". +// Oft wird dies als eines der wichtigsten Paradigmen in C++ betrachtet. +// RAII beschreibt das Konzept, dass der Konstruktor für ein Objekt +// die Ressourcen akquiriert und der Destruktor diese freigibt. + +// Zum Verständnis, warum dies sinnvoll ist, nachfolgend +// ein einführendes Beispiel: +void doSomethingWithAFile(const char* filename) +{ + // Wir nehmen an, dass nichts schiefgehen wird. + FILE* fh = fopen(filename, "r"); // Öffnen der Datei im read-mode. + + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + + fclose(fh); // Schließen des file-handle. +} + +// Unglücklicherweise ist die Fehlerbehandlung äußerst kompliziert. +// Sollte fopen fehlschlagen und "doSomethingWithTheFile" bzw. +// "doSomethingElseWithIt", geben diese einen Fehlercode zurück. +// (Exceptions sind eine bevorzugte Möglichkeit Fehler abzufangen +// , allerdings bei einigen Programmierern, besonders solchen die einen C +// background besitzen, ein unbeliebtes Mittel zur Fehlerbehandlung). +// Nun müssen wir jeden Aufruf auf mögliche auftretende Fehler überprüfen. +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Öffnet die Datei im read-mode + if (fh == nullptr) // Der Pointer ist bei einem Fehler NULL . + return false; // Benachrichtigt den Aufrufer über den Fehler. + + // Wir nehmen an, dass jede Funktion false zurückgibt, in einem Fehlerfall + if (!doSomethingWithTheFile(fh)) + { + fclose(fh); // File handle schließen. + return false; // Fehler "melden". + } + + if (!doSomethingElseWithIt(fh)) + { + fclose(fh); // File handle schließen. + return false; // Fehler "melden". + } + + fclose(fh); // File handle schließen. + return true; // Erfolg "melden". +} + +// C-Programmierer handhaben dies häufig durch goto-Anweisungen: +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + return false; + + if (!doSomethingWithTheFile(fh)) + goto failure; + + if (!doSomethingElseWithIt(fh)) + goto failure; + + fclose(fh); // File handle schließen. + return true; // Erfolg "melden". + +failure: + fclose(fh); + return false; // Fehler "melden". +} + +// Insofern Funktionen Fehler durch exceptions indizieren, +// ist dies "sauberer", aber immer noch suboptimal. +void doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Öffnet die Datei im read-mode + if (fh == nullptr) + throw std::runtime_error("Could not open the file."); + + try + { + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + } + catch (...) + { + // Im Fehlerfall sollte sichergestellt sein, dass die + // Datei geschlossen wird. + fclose(fh); + throw; // Erneutes werfen der Exception + } + + fclose(fh); // Schließen der Datei +} + +// Folgendes ist mit der C++ file stream Klasse (fstream) zu vergleichen. +// fstream verwendet den Destruktor, um die Datei zu schließen. +// Der obige Destruktor wird automatisch aufgerufen, sobald das Objekt +// den Gültigkeitsbereich verlässt. +void doSomethingWithAFile(const std::string& filename) +{ + // ifstream entspricht der Kurzform von "input file stream". + std::ifstream fh(filename); // Öffnen der Datei + + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + +} // Die Datei wird automatisch vom Destruktor geschlossen. + +// Diese Vorgehensweise bietet massive Vorteile: +// 1. Egal was passiert, die Ressource (das Datei-Handle) wird aufgelöst, +// insofern der Destruktor korrekt beschrieben wurde. Es ist möglich +// zu vergessen das Datei-Handle zu schließen, was zu einem "leak" der +// entsprechenden Ressource führt. +// 2. Der Code selbst ist wesentlich "sauberer". +// Der Destruktor wird das Datei-Handle im Hintergrund schließen und der +// Programmierer muss sich darum keinerlei Sorgen machen. +// 3. Der Code ist "exception sicher". +// Egal wo die exception geworfen wird, das Aufäumen wird definitv vollzogen. + +// Der gesamte idiomatische C++ Code verwendet RAII für alle Ressourcen. +// Weitere Beispiele: +// - Speicher verwenden "unique_ptr" und "shared_ptr". +// - Container - verkettete Listen (linked list), vector (selbst organisierende +// Arrays), hash maps, etc., entfernen deren Inhalt, wenn diese außerhalb des +// Gültigkeitsbereichs laufen. +// - Mutex´s verwenden lock_guard und unique_lock. + +///////////////////// +// Container +///////////////////// + +// Die Container der Standard Tenplate Bibliothek beinhaltet einige vordefinierter templates. +// Diese verwalten die Speicherbereiche für die eigenen Elemente und stellen Member-Funktionen +// für den Zugriff und die Maniplulation bereit. + +// Beispielhafte Container: + +// Vector (dynamisches array) +// Erlaubt das Definieren von Arrays oder Listen zur Laufzeit +#include +string val; +vector my_vector; // Initialisierung des Vectors. +cin >> val; +my_vector.push_back(val); // Fügt den Wert "val" zum Vektor "my_vector" hinzu. +my_vector.push_back(val); // Fügt den Wert "val" zum Vektor "my_vector" hinzu (nun zwei Elemente). + +// Für die Iteration über Vektoren stehen zwei Methodiken zu Verfügung: +// Entweder die klassische Iteration über den Index: +for (int i = 0; i < my_vector.size(); i++) +{ + cout << my_vector[i] << endl; // Zugriff auf die Elemente des Vektors über den [] Operator +} + +// Oder die Verwendung von Iteratoren: +vector::iterator it; // Initialisierng des Iterators. +for (it = my_vector.begin(); it != my_vector.end(); ++it) +{ + cout << *it << endl; +} + +// Set (Mengen) +// Sets sind Container, welche einzigartige Elemente beinhalten die einer +// spezifischen Ordnung folgen. + +#include +set ST; // Initialisierung des Sets mit einem Integer Datentyp. +ST.insert(30); // Einfügen des Werts 30 in das Set ST +ST.insert(10); // Einfügen des Werts 10 in das Set ST +ST.insert(20); // Einfügen des Werts 20 in das Set ST +ST.insert(30); // Einfügen des Werts 30 in das Set ST +// Folgende Elemente befinden sich nun in dem Set: +// 10 20 30 + +// Entfernen eines Elements: +ST.erase(20); + +// Set ST: 10 30 +// Für das iterieren verwenden wir Iteratoren: +set::iterator it; + +for(it=ST.begin();it +map mymap; // Initialisierung der Map: char -> Key, int -> Value. + +mymap.insert(pair('A',1)); // Einfügen des Werts "1" für den Key "A". + +mymap.insert(pair('Z',26)); // Einfügen des Werts "26" für den Key "Z". + +// Das Iterieren über Maps: +map::iterator it; +for (it=mymap.begin(); it!=mymap.end(); ++it) + std::cout << it->first << "->" << it->second << '\n'; + +// Ausgabe: +// A->1 +// Z->26 + +// Für das Finden des dazugehörigen Value des Keys. +it = mymap.find('Z'); +cout << it->second; + +// Ausabe: 26 + +// Bemerkung: für "hash maps" sollten die "unordered_map´s" verwendet werden. Diese +// sind effizienter und benötigen keine Reihenfolge. "unordered_maps" sind ab +// C++11 verfügbar. + +// Container für nicht-primitve Datentypen benötigen Vergleichsfunktionen im Objekt selbst, +// oder als Funktionspointer. Primitive Datentypen besitzen default-Vergleichsfunktionen. +// Allerdings können diese überschrieben werden. +class Foo +{ +public: + int j; + Foo(int a) : j(a) {} +}; + +struct compareFunction +{ + bool operator()(const Foo& a, const Foo& b) const + { + return a.j < b.j; + } +}; + +// Folgender Code ist nicht valide, könnte aber von einigen Compilern +// als valide angesehen werden: +// std::map fooMap; +std::map fooMap; +fooMap[Foo(1)] = 1; +fooMap.find(Foo(1)); // Wahr + + +/////////////////////////////////////// +// Lambda Ausdrücke (C++11 und höher) +/////////////////////////////////////// + +// Lambdas sind eine gängige Methodik um anonyme Funktionen an dem +// Ort der Verwendung zu definieren. Darüber hinaus auch bei der +// Verwendung von Funktionen als Argument einer Funktion. + +// Nehmen wir an es soll ein Vektor von "pairs" (Paaren) mithilfe +// des zweiten Werts des "pairs" sortiert werden. + +vector > tester; +tester.push_back(make_pair(3, 6)); +tester.push_back(make_pair(1, 9)); +tester.push_back(make_pair(5, 0)); + +// Übergabe des Lambda-Ausdrucks als drittes Argument für die nachfolgende Sortierfunktion. +sort(tester.begin(), tester.end(), [](const pair& lhs, const pair& rhs) +{ + return lhs.second < rhs.second; +}); + +// Beachte den Syntax von Lambda-Ausdrücken. +// Die [] im Lambda Ausdruck werden für die Variablen verwendet. +// Diese so genannte "Capture List" definiert, was außerhalb des Lambdas +// innerhalb der Funktion verfügbar sein soll und in welcher Form. +// Dies kann folgendes sein: +// 1. ein Wert [x] +// 2. eine Referenz [&x] +// 3. eine beliebige Variable, welche sich im Gültigkeitsbereich durch +// die Referenz [&] befindet. +// 4. wie bei 3. aber mithilfe des Werts [=] +// Beispiel: + +vector dog_ids; + +for(int i = 0; i < 3; i++) +{ + dog_ids.push_back(i); +} + +int weight[3] = {30, 50, 10}; + +// Nehmen wir an wir möchten die "dog_ids" gemäß des Gewichts des Hundes sortieren. +// So sollten sich die "dog_ids" wie folgt verhalten: [2, 0, 1] + +// Hier werden Lambdas praktisch: +sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs) +{ + return weight[lhs] < weight[rhs]; +}); + + +// Weiterführender Link über Lambda-Ausdrücke: +// http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11 + +/////////////////////////////// +// Range For (C++11 und höher) +/////////////////////////////// + +// Range-For Schleifen können verwendet werden, um über Container zu iterieren. +int arr[] = {1, 10, 3}; + +for(int elem: arr) +{ + cout << elem << endl; +} + +// Insofern "auto" verwendet wird, muss der Typ nicht weiter beachtet werden. + +for(auto elem: arr) +{ + // Anweisungen ... +} + +///////////////////// +// Weiteres: +///////////////////// + +// Einige Aspekte von C++ sind für Neueinsteiger häufig überraschend (aber auch für +// C++ Veteranen). +// Der nachfolgende Abschnitt ist leider nicht vollständig: +// C++ ist eine der Sprachen, bei der es ein leichtes ist sich selbst ins Bein zu schießen. + +// Private-Methoden können überschrieben werden +class Foo +{ + virtual void bar(); +}; + +class FooSub : public Foo +{ + virtual void bar(); // Überschreibt Foo::bar! +}; + + +// 0 == false == NULL +bool* pt = new bool; +*pt = 0; // Setzt den Wert des Pointers 'pt' auf false. +pt = 0; // Setzt 'pt' auf den "null-pointer". Keine Compiler-Warnung. + +// nullptr sollte dieses Problem nicht lösen: +int* pt2 = new int; +*pt2 = nullptr; // Kompiliert nicht. +pt2 = nullptr; // Setzt pt2 auf null. + +// Eine Ausnahme bilden bools. +// Dies erlaubt es "null-pointer" zu testen: if(!ptr) +// Die Konsequenz ist jedoch, dass dem nullptr ein bool zugewiesen werden kann. +*pt = nullptr; // Kompiliert auch wenn '*pt' ein bool ist! + + +// '=' != '=' != '='! +// Ruft Foo::Foo(const Foo&) auf, oder den Kopierkonstruktor +Foo f2; +Foo f1 = f2; + +// Ruft Foo::Foo(const Foo&) auf, aber kopiert lediglich den "Foo" Teil von +// "fooSub". Alle zusätzlichen Member werden verworfen. Diese eigenartige Verhalten +// wird auch "object slicing" genannt. +FooSub fooSub; +Foo f1 = fooSub; + +// Ruft Foo::operator=(Foo&) oder eine andere Variante auf. +Foo f1; +f1 = f2; + +/////////////////////////////////////// +// Tuple (C++11 und höher) +/////////////////////////////////////// + +#include + +// Konzeptionell sind Tuples alten Datenstrukturen sehr ähnlich, allerdings haben diese keine +// benamten Daten-Member, sondern werden durch die Reihenfolge angesprochen. + +// Erstellen des Tuples und das Einfügen eines Werts. +auto first = make_tuple(10, 'A'); +const int maxN = 1e9; +const int maxL = 15; +auto second = make_tuple(maxN, maxL); + +// Ausgabe der Elemente des "first" Tuple. +cout << get<0>(first) << " " << get<1>(first) << "\n"; // Ausgabe : 10 A + +// Ausgabe der Elemente des "second" Tuple. +cout << get<0>(second) << " " << get<1>(second) << "\n"; // Ausgabe: 1000000000 15 + +int first_int; +char first_char; +tie(first_int, first_char) = first; +cout << first_int << " " << first_char << "\n"; // Ausgabe : 10 A + +// Tuple können auch wie folgt erzeugt werden: + +tuple third(11, 'A', 3.14141); +// tuple_size gibt die Anzahl der Elemente in einem Tuple zurück. +// Als "constexpr". + +cout << tuple_size::value << "\n"; // prints: 3 + +// tuple_cat fügt die Elemente eines Tuples aneinander (in der selben Reihenfolge). + +auto concatenated_tuple = tuple_cat(first, second, third); +// concatenated_tuple wird zu = (10, 'A', 1e9, 15, 11, 'A', 3.14141) + +cout << get<0>(concatenated_tuple) << "\n"; // Ausgabe: 10 +cout << get<3>(concatenated_tuple) << "\n"; // Ausgabe: 15 +cout << get<5>(concatenated_tuple) << "\n"; // Ausgabe: 'A' + + +/////////////////////////////////// +// Logische- und Bitoperatoren +////////////////////////////////// + +// Die meisten Operatoren in C++ entsprechen denen aus anderen Sprachen + +// Logische Operatoren. + +// C++ verwendet so genannte "Short-circuit" Evaluierung für boolean-Ausdrücke. +// Das zweite Argument wird ausgeführt bzw. evaluiert, wenn das erste Argument genügt, +// um den Ausdruck zu bestimmen. + +true && false // Führt **logisches und** aus. +true || false // Führt **logisches oder** aus. +! true // Führt **logisches nicht** aus. + +// Anstelle von Symbolen können auch Schlüsselwörter verwendet werden. +true and false // Führt **logisches und** aus. +true or false // Führt **logisches oder** aus. +not true // Führt **logisches nicht** aus. + +// Bitoperationen + +// **<<** Links-Shift +// **>>** Rechts-Shift + +~4 // Führt bitweises nicht aus. +4 | 3 // Führt bitweises oder aus. +4 & 3 // Führt bitweises und aus. +4 ^ 3 // Führt bitweises xor aus. + +// Gleichwertige Schlüsselwörter: +compl 4 // Führt bitweises nicht aus. +4 bitor 3 // Führt bitweises oder aus. +4 bitand 3 // Führt bitweises und aus. +4 xor 3 // Führt bitweises xor aus. + + +``` +Weiterführende Literatur: + +* Aktuelle Sprachen-Referenz [CPP Reference](http://cppreference.com/w/cpp). +* Zusätzliches: [CPlusPlus](http://cplusplus.com). +* Grundlagen Tutorial: [TheChernoProject - C++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb). -- cgit v1.2.3 From 223eff09c3e2444c230dd7fb5d11b66fa79b1c8d Mon Sep 17 00:00:00 2001 From: lchan05 Date: Tue, 28 May 2019 19:09:42 -0400 Subject: added language, resolves #3537 --- de-de/c++-de.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'de-de') diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown index 23cc26a8..eec11d61 100644 --- a/de-de/c++-de.html.markdown +++ b/de-de/c++-de.html.markdown @@ -9,6 +9,7 @@ contributors: - ["Ankush Goyal", "http://github.com/ankushg07"] - ["Jatin Dhankhar", "https://github.com/jatindhankhar"] - ["Maximilian Sonnenburg", "https://github.com/LamdaLamdaLamda"] +lang: de-de --- C++ ist eine Systemprogrammiersprache die, -- cgit v1.2.3 From 41f2b7f168d0599e7567c6a96bec29ac87c68de4 Mon Sep 17 00:00:00 2001 From: LamdaLamdaLamda <25778959+LamdaLamdaLamda@users.noreply.github.com> Date: Sat, 3 Aug 2019 20:18:39 +0200 Subject: [C++/de] fixed wrong spelling (#3579) * Added [C++/de] * [C++/de] filename fixed. * [C++/de] language code in filename added * [C++/de] fixed wrong spelling * [C++/en] smart pointer added --- de-de/c++-de.html.markdown | 208 ++++++++++++++++++++++----------------------- 1 file changed, 102 insertions(+), 106 deletions(-) (limited to 'de-de') diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown index eec11d61..cef7514b 100644 --- a/de-de/c++-de.html.markdown +++ b/de-de/c++-de.html.markdown @@ -23,9 +23,11 @@ entworfen wurde um, - generische Programmierung zu unterstützen Durch seinen Syntax kann sie durchaus schwieriger und komplexer als neuere Sprachen sein. -Sie ist weit verbeitet, weil sie in Maschinen-Code compiliert, welches direkt vom Prozessor ausgeführt + +Sie ist weit verbreitet, weil sie in Maschinen-Code kompiliert, welches direkt vom Prozessor ausgeführt werden kann und somit eine strikte Kontrolle über die Hardware bietet und gleichzeitig -High-Level-Features wie generics, exceptions und Klassen enthält. (wie C) +High-Level-Features wie generics, exceptions und Klassen enthält. + Diese Kombination aus Geschwindigkeit und Funktionalität bildet C++ und ist eine der weitverbreitesten Programmiersprachen. @@ -34,19 +36,20 @@ weitverbreitesten Programmiersprachen. // Vergleich zu C ////////////////// -// C++ ist fast eine Untermenge von C and teilt sich grundsätzlich den -// Syntax für Variablen Deklarationen, primitiven Typen und Funktionen. +// C ist fast eine Untermenge von C++ und teilt sich grundsätzlich den +// Syntax für Variablen Deklarationen, primitiven Typen und Funktionen. // Wie in C ist der Programmeinsprungpunkt eine Funktion, welche "main" genannt wird und -// einen Ineteger als Rückgabetyp besitzt. +// einen Integer als Rückgabetyp besitzt. + // Dieser Wert fungiert als Beendigungsstatus des Programms. // Siehe: https://de.wikipedia.org/wiki/Return_Code für weitere Informationen int main(int argc, char** argv) { // Kommandozeilen Argumente werden genauso wie in C über argc und argv übergeben - // argc entspricht der Anzahl von Argumenten und argv ist ein Array von C-style + // argc entspricht der Anzahl von Argumenten und argv ist ein Array von C-style // strings (char*), welche die Argumente repräsentieren. - // Das erste Argument ist der Name des Programms welches aufgerufen wird. + // Das erste Argument ist der Name des Programms, welches aufgerufen wird. // Argc und argv können, wenn nicht benötigt, weg gelassen werden, indem // die Funktionssignatur "int main()" verwendet wird. @@ -54,12 +57,12 @@ int main(int argc, char** argv) return 0; } -// C++ unterscheidet sich in einigen Punkten: +// C++ unterscheidet sich in einigen Punkten von C: -// In C++ sind Zeichen-Literale chars +// In C++ sind Zeichen-Literale char´s sizeof('c') == sizeof(char) == 1 -// In C sind Zeichen-Literale ints +// In C sind Zeichen-Literale int´s sizeof('c') == sizeof(int) // C++ verwendet striktes prototyping @@ -71,8 +74,8 @@ void func(); // Funktion mit beliebiger Anzahl von Argumenten // Verwende nullptr, anstatt von NULL!!! int* ip = nullptr; -// C standard headers sind in C++ verfügbar. -// C header enden mit .h, während +// C standard header sind in C++ verfügbar. +// C header enden mit .h, während // C++ header das Präfix "c" besitzen und kein ".h" Suffix verwenden. // Die C++ Standard Version: @@ -115,10 +118,9 @@ int main() // Argumente können per Standard für eine Funktion gesetzt werden, // wenn diese beim Aufruf nicht bereitgestellt werden. - void doSomethingWithInts(int a = 1, int b = 4) { - // führe Anweisungen mit "ints" aus. + // führe Anweisungen mit "int´s" aus. } int main() @@ -141,18 +143,18 @@ void invalidDeclaration(int a = 1, int b) // Fehler! // Namespaces stellen einen getrennten Gültigkeitsbereich für Variablen, // Funktionen und andere Deklarationen zur Verfügung. // Namespaces können geschachtelt werden. -namespace First +namespace First { - namespace Nested + namespace Nested { void foo() { printf("This is First::Nested::foo\n"); } - } // Ende des Namespaces "Nested" -} // Ende des Namespaces "First" + } // Ende des Namespace "Nested" +} // Ende des Namespace "First" -namespace Second +namespace Second { void foo() { @@ -236,8 +238,8 @@ cout << myString; // "Hello Dog" // C++ besitzt _Referenzen_. // Diese sind Pointer-Typen, welche nicht erneut zugewiesen werden können // und nicht Null sein können. -// Sie besitzen den selben Synthax wie Variablen. -// Für die Dereferenzierung ist kein * notwendig und +// Sie besitzen den selben Syntax wie Variablen. +// Für die Dereferenzierung ist kein * notwendig und // & (die Adresse) wird nicht für die Zuweisung verwendet. using namespace std; @@ -261,19 +263,18 @@ cout << fooRef; // Gibt "I am bar" aus // Die Adresse von fooRef verbleibt die selbe, sie verweist immer noch auf foo - const string& barRef = bar; // Erzeugt konstante Referenz auf bar. // Wie in C, können konstante Werte ( und Pointer bzw. Referenzen) nicht verändert werden. barRef += ". Hi!"; // Fehler: konstante Referenzen können nicht verändert werden. -// Hinweis: bevor wir genauer Referenzen besprechen, schauen wir uns zuerst ein Konzept an +// Hinweis: bevor wir genauer Referenzen besprechen, schauen wir uns zuerst ein Konzept an, // welches als "temporäres Objekt" bezeichnet wird. Gehen wir von folgenden Code aus: string tempObjectFun() { ... } string retVal = tempObjectFun(); // Was passiert nun in der zweiten Zeile: -// - ein String Objekt wird von tempObjectFun zurückgegeben +// - ein String Objekt wird von "tempObjectFun" zurückgegeben // - ein neuer String wird mit dem zurückgegebenen Objekt als Argument für den Konstruktor erzeugt. // - das zurückgegebene Objekt wird zerstört // Das zurückgegbene Objekt wird temporäres Objekt genannt. Temporäre Objekte werden erzeugt @@ -285,19 +286,20 @@ foo(bar(tempObjectFun())) // Nehmen wir an foo und bar existieren. Das Objekt wird von "tempObjectFun" zurückgegeben, // wird an bar übergeben und ist zerstört bevor foo aufgerufen wird. -// Zurück zu Referenzen. Die Ausnahme, dass die "am Ende des Ausdrucks" Regel ist gültig, -// wenn das temporäre Objekt an eine konstante Referenz gebunden ist, in welchem Fall das -// Leben auf den aktuellen Gültigkeitsbereich erweitert wird. +// Zurück zu Referenzen. Die Annahme, dass die "am Ende des Ausdrucks" Regel gültig ist, +// wenn das temporäre Objekt an eine konstante Referenz gebunden ist, ist der Fall, wenn die Lebensdauer +// auf den aktuellen Gültigkeitsbereich erweitert wird. void constReferenceTempObjectFun() { - // constRef erhält das temporäre Objekt und ist gültig bis ans Ende der Funktion + // constRef erhält das temporäre Objekt und ist gültig bis ans Ende der Funktion const string& constRef = tempObjectFun(); ... } -// Eine andere Art von Referenzen wird in C++11 eingeführt und ist speziell für -// temporäre Objekte. Es ist nicht möglich Variablen des Typs zu besitzen, aber -// Vorrechte bei der Auflösung. +// Eine andere Art von Referenzen wurde in C++11 eingeführt und ist speziell für +// temporäre Objekte. Es ist nicht möglich Variablen des Typs zu besitzen, aber +// Vorrechte bei der Auflösung zu besitzen. + void someFun(string& s) { ... } // Reguläre Referenz void someFun(string&& s) { ... } // Referenz auf ein temporäres Objekt @@ -310,8 +312,8 @@ someFun(tempObjectFun()); // Ruft die Funktion mit der temporären Referenz auf basic_string(const basic_string& other); basic_string(basic_string&& other); -// Nehmen wir an, wir erzeugen einen neuen String eines temporären Objekts (welches später -// zerstört wird), hierbei existiert ein effizienterer Konstruktor. Dieses Konzept wird +// Nehmen wir an, wir erzeugen einen neuen String eines temporären Objekts (welches später +// zerstört wird), hierbei existiert ein effizienterer Konstruktor. Dieses Konzept wird // als "move semantics" bezeichnet (bewegen eines Objekts in ein anderes in C++). ///////////////////// @@ -346,18 +348,18 @@ enum ECarTypes : uint8_t void WriteByteToFile(uint8_t InputValue) { - // Serialisierung von InputValue in eine Datei + // Serialisierung von "InputValue" in eine Datei } void WritePreferredCarTypeToFile(ECarTypes InputCarType) { // Das enum wird implizit zu einem "uint8_t" konvertiert. Bedingt dadurch, dass - // es sich um ein enum handelt. + // es sich um ein "enum" handelt. WriteByteToFile(InputCarType); } -// Nicht immer ist es gewünscht, dass enums zu einem Integer oder zu einem anderen -// enum umgewandelt werden. Daher ist es möglich eine enum-Klasse zu erzeugen, welche +// Nicht immer ist es gewünscht, dass enum´s zu einem Integer oder zu einem anderen +// enum umgewandelt werden. Daher ist es möglich eine enum-Klasse zu erzeugen, welche // nicht implizit umgewandelt wird. enum class ECarTypes : uint8_t { @@ -374,8 +376,8 @@ void WriteByteToFile(uint8_t InputValue) void WritePreferredCarTypeToFile(ECarTypes InputCarType) { - // Wird nicht kompilieren, da ECarTypes ein "uint8_t" ist, da das enum - // als "enum class" deklariert wurde! + // Wird nicht kompilieren, da "ECarTypes" ein "uint8_t" ist, da das enum + // als "enum class" deklariert wurde! WriteByteToFile(InputCarType); } @@ -401,15 +403,15 @@ public: // Standard Konstruktor Dog(); - // Member-Funktonensdeklaration (Implementierung folgt) + // Member-Funktionsdeklaration (Implementierung folgt). // Bemerkung: std::string statt der Verwendung von namespace std; // "using namespace" sollte niemals in einem header verwendet werden. void setName(const std::string& dogsName); void setWeight(int dogsWeight); - // Funktionen, die Objekte nicht ändern sollte mit const deklariert werden. - // Funktionen müssen explizit als "virtual" deklariert werden, um in einer + // Funktionen, die Objekte nicht ändern, sollten mit const deklariert werden. + // Funktionen müssen explizit als "virtual" deklariert werden, um in einer // abgeleiteten Klassen überschrieben zu werden. // Aus performance Gründen sind Funktionen nicht per default virtual. virtual void print() const; @@ -419,24 +421,24 @@ public: void bark() const { std::cout << name << " barks!\n"; } // Neben Konstruktoren, bietet C++ Destruktoren. - // Diese werden aufgerufen, wenn ein Objekt freigegeben wird oder - // seinen Wertebereich verlässt. + // Diese werden aufgerufen, wenn ein Objekt freigegeben wird oder + // seinen Wertebereich verlässt. // Dies ermöglicht mächtige Paradigmen, wie auch RAII. // Destruktoren sollten virtual sein, wenn eine Klasse von ihr // abgeleitet wird. Ist dieser nicht virtual, dann wird der - // Destruktor der abgeleiteten Klasse nicht aufgerufen, insofern + // Destruktor der abgeleiteten Klasse nicht aufgerufen, insofern // das Objekt durch eine Referenz/Pointer der Basisklasse entfernt wird. virtual ~Dog(); }; // Ein Semikolon schließt die Definition der Klasse ab. -// Klassen-Member-Funktionen sind üblicherweise in der .cpp Datei implmentiert. +// Klassen-Member-Funktionen sind üblicherweise in der .cpp Datei implementiert. Dog::Dog() { std::cout << "A dog has been constructed\n"; } -// Objekte sollten als Referenz übergeben werden und wenn diese nicht +// Objekte sollten als Referenz übergeben werden und wenn diese nicht // verändert werden sollen, sollte das Objekt als const Referenz übergeben werden. void Dog::setName(const std::string& dogsName) { @@ -468,8 +470,6 @@ int main() return 0; } // Ausgabe: "Goodbye Barkley" -// Vererbung: - // Diese Klasse erbt alles was public bzw. protected ist von der Dog-Klasse // und darüber hinaus auch private Methoden/Attribute, jedoch kann auf diese // nicht direkt zugegriffen werden. Lediglich über public/procted getter/setter. @@ -481,7 +481,7 @@ public: // Überschreibt das Verhalten der "print" Funktion für alle "OwnedDogs". // Siehe: http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping // für eine grundlegende Einführung in "Subtype Polymorphismus". - // Das "override" Schlüsselwort ist optional, aber stellt sicher, dass die + // Das "override" Schlüsselwort ist optional, aber stellt sicher, dass die // Methode der Basisklasse tatsächlich überschrieben wurde. void print() const override; @@ -555,7 +555,7 @@ Point& Point::operator+=(const Point& rhs) return *this; } -int main () +int main () { Point up (0,1); Point right (1,0); @@ -574,23 +574,23 @@ int main () // Templates in C++ werden in erster Linie dafür verwendet generisch zu programmieren. // Sie unterstützen explizite und partielle Spezialisierung und darüber hinaus können // sie für funktionale Klassen verwendet werden. -// Tatsächlich bilden templates die Turing-Vollständigkeit +// Tatsächlich bilden templates die Turing-Vollständigkeit // (universelle Programmierbarkeit) ab. // Zu Beginn ein einführendes Beispiel der generischen Programmierung. // Die Definition einer Klasse bzw. Funktion, welche mit dem Typ T parametriert wird. template -class Box +class Box { public: // T repräsentiert an dieser Stelle einen beliebigen Typen. void insert(const T&) { ... } }; -// Während der Kompilierung generiert der Kompiler Kopien für jedes Template, wobei -// hierbei die Parameter substituiert werden. Somit muss bei jedem Aufruf die gesamte -// Definition der Klasse zur Verfügung stehen. Aus diesem Grund wird ein Template +// Während der Kompilierung generiert der Compiler Kopien für jedes template, wobei +// hierbei die Parameter substituiert werden. Somit muss bei jedem Aufruf die gesamte +// Definition der Klasse zur Verfügung stehen. Aus diesem Grund wird ein Template // komplett im header definiert. // Erzeugung einer Template-Klasse auf dem stack: @@ -609,7 +609,7 @@ boxOfBox.insert(intBox); // Manchmal ist folgende Notation anzutreffen: // template // Das 'class' Schlüsselwort und das 'typename' Schlüsselwort -// sind fast identisch hinsichtlich der Funktionalität. Weitere +// sind fast identisch hinsichtlich der Funktionalität. Weitere // Informationen auf: http://en.wikipedia.org/wiki/Typename // Eine template-Funktion: @@ -623,7 +623,7 @@ void barkThreeTimes(const T& input) // Hierbei ist zu beachten, dass an dieser Stelle nichts über den Typen des Parameters // definiert wurde. Der Kompiler wird bei jedem Aufruf bzw. jeder Erzeugung den Typen -// prüfen. Somit funktioniert die zuvor definiert Funktion für jeden Typ 'T', die die +// prüfen. Somit funktioniert die zuvor definierte Funktion für jeden Typ 'T', die die // const Methode 'bark' implementiert hat. Dog fluffy; @@ -632,14 +632,14 @@ barkThreeTimes(fluffy); // Gibt "Fluffy barks" dreimal aus. // Template Parameter müssen keine Klassen sein. template -void printMessage() +void printMessage() { cout << "Learn C++ in " << Y << " minutes!" << endl; } // Des Weiteren können templates aus Effizienzgründen genauer spezifiziert werden. // Selbstverständlich sind reale-Problemen, welche genauer spezifiziert werden nicht -// derart trivial. Auch wenn alle Parameter explizit definiert wurden, muss die +// derart trivial. Auch wenn alle Parameter explizit definiert wurden, muss die // Funktion oder Klasse als template deklariert werden. template<> void printMessage<10>() @@ -655,17 +655,17 @@ printMessage<10>(); // Gibt "Learn C++ faster in only 10 minutes!" aus. // Ausnahme Behandlungen (Exception-Handling) ///////////////////// -// Die Standard Bibliothek bietet einige Exceptions. +// Die Standard Bibliothek bietet einige exceptions. // Siehe: http://en.cppreference.com/w/cpp/error/exception. -// Grundsätzlich können alle Typen als Exception geworfen werden. +// Grundsätzlich können alle Typen als exception geworfen werden. #include #include -// Alle Exceptions, die in dem "try" Block geworfen werden, können mittels +// Alle exceptions, die in dem "try" Block geworfen werden, können mittels // "catch" abgefangen werden. -try +try { - // Exceptions sollten nicht auf dem heap mithilfe + // exceptions sollten nicht auf dem heap mithilfe // von "new" allokiert werden. throw std::runtime_error("A problem occurred"); } @@ -690,7 +690,7 @@ catch (...) // RAII steht für "Resource Acquisition Is Initialization". // Oft wird dies als eines der wichtigsten Paradigmen in C++ betrachtet. -// RAII beschreibt das Konzept, dass der Konstruktor für ein Objekt +// RAII beschreibt das Konzept, dass der Konstruktor für ein Objekt // die Ressourcen akquiriert und der Destruktor diese freigibt. // Zum Verständnis, warum dies sinnvoll ist, nachfolgend @@ -726,7 +726,7 @@ bool doSomethingWithAFile(const char* filename) return false; // Fehler "melden". } - if (!doSomethingElseWithIt(fh)) + if (!doSomethingElseWithIt(fh)) { fclose(fh); // File handle schließen. return false; // Fehler "melden". @@ -770,12 +770,12 @@ void doSomethingWithAFile(const char* filename) doSomethingWithTheFile(fh); doSomethingElseWithIt(fh); } - catch (...) + catch (...) { - // Im Fehlerfall sollte sichergestellt sein, dass die + // Im Fehlerfall sollte sichergestellt sein, dass die // Datei geschlossen wird. - fclose(fh); - throw; // Erneutes werfen der Exception + fclose(fh); + throw; // Erneutes werfen der exception } fclose(fh); // Schließen der Datei @@ -796,7 +796,7 @@ void doSomethingWithAFile(const std::string& filename) } // Die Datei wird automatisch vom Destruktor geschlossen. // Diese Vorgehensweise bietet massive Vorteile: -// 1. Egal was passiert, die Ressource (das Datei-Handle) wird aufgelöst, +// 1. Egal was passiert, die Ressource (das Datei-Handle) wird aufgelöst, // insofern der Destruktor korrekt beschrieben wurde. Es ist möglich // zu vergessen das Datei-Handle zu schließen, was zu einem "leak" der // entsprechenden Ressource führt. @@ -804,13 +804,13 @@ void doSomethingWithAFile(const std::string& filename) // Der Destruktor wird das Datei-Handle im Hintergrund schließen und der // Programmierer muss sich darum keinerlei Sorgen machen. // 3. Der Code ist "exception sicher". -// Egal wo die exception geworfen wird, das Aufäumen wird definitv vollzogen. +// Egal wo die exception geworfen wird, das Aufräumen wird definitiv vollzogen. // Der gesamte idiomatische C++ Code verwendet RAII für alle Ressourcen. // Weitere Beispiele: // - Speicher verwenden "unique_ptr" und "shared_ptr". // - Container - verkettete Listen (linked list), vector (selbst organisierende -// Arrays), hash maps, etc., entfernen deren Inhalt, wenn diese außerhalb des +// Arrays), hash maps, etc., entfernen deren Inhalt, wenn diese außerhalb des // Gültigkeitsbereichs laufen. // - Mutex´s verwenden lock_guard und unique_lock. @@ -818,7 +818,7 @@ void doSomethingWithAFile(const std::string& filename) // Container ///////////////////// -// Die Container der Standard Tenplate Bibliothek beinhaltet einige vordefinierter templates. +// Die Container der Standard template Bibliothek beinhaltet einige vordefinierter templates. // Diese verwalten die Speicherbereiche für die eigenen Elemente und stellen Member-Funktionen // für den Zugriff und die Maniplulation bereit. @@ -842,7 +842,7 @@ for (int i = 0; i < my_vector.size(); i++) // Oder die Verwendung von Iteratoren: vector::iterator it; // Initialisierng des Iterators. -for (it = my_vector.begin(); it != my_vector.end(); ++it) +for (it = my_vector.begin(); it != my_vector.end(); ++it) { cout << *it << endl; } @@ -861,13 +861,13 @@ ST.insert(30); // Einfügen des Werts 30 in das Set ST // 10 20 30 // Entfernen eines Elements: -ST.erase(20); +ST.erase(20); // Set ST: 10 30 // Für das iterieren verwenden wir Iteratoren: set::iterator it; -for(it=ST.begin();it('A',1)); // Einfügen des Werts "1" für den Key "A" mymap.insert(pair('Z',26)); // Einfügen des Werts "26" für den Key "Z". -// Das Iterieren über Maps: +// Das Iterieren über Maps: map::iterator it; for (it=mymap.begin(); it!=mymap.end(); ++it) std::cout << it->first << "->" << it->second << '\n'; @@ -918,25 +918,25 @@ cout << it->second; // sind effizienter und benötigen keine Reihenfolge. "unordered_maps" sind ab // C++11 verfügbar. -// Container für nicht-primitve Datentypen benötigen Vergleichsfunktionen im Objekt selbst, +// Container für nicht-primitive Datentypen benötigen Vergleichsfunktionen im Objekt selbst, // oder als Funktionspointer. Primitive Datentypen besitzen default-Vergleichsfunktionen. // Allerdings können diese überschrieben werden. -class Foo +class Foo { public: int j; Foo(int a) : j(a) {} }; -struct compareFunction +struct compareFunction { - bool operator()(const Foo& a, const Foo& b) const + bool operator()(const Foo& a, const Foo& b) const { return a.j < b.j; } }; -// Folgender Code ist nicht valide, könnte aber von einigen Compilern +// Folgender Code ist nicht valide, könnte aber von einigen Compilern // als valide angesehen werden: // std::map fooMap; std::map fooMap; @@ -949,10 +949,10 @@ fooMap.find(Foo(1)); // Wahr /////////////////////////////////////// // Lambdas sind eine gängige Methodik um anonyme Funktionen an dem -// Ort der Verwendung zu definieren. Darüber hinaus auch bei der +// Ort der Verwendung zu definieren. Darüber hinaus auch bei der // Verwendung von Funktionen als Argument einer Funktion. -// Nehmen wir an es soll ein Vektor von "pairs" (Paaren) mithilfe +// Nehmen wir an es soll ein Vektor von "pairs" (Paaren) mithilfe // des zweiten Werts des "pairs" sortiert werden. vector > tester; @@ -968,19 +968,19 @@ sort(tester.begin(), tester.end(), [](const pair& lhs, const pair dog_ids; -for(int i = 0; i < 3; i++) +for(int i = 0; i < 3; i++) { dog_ids.push_back(i); } @@ -1013,8 +1013,7 @@ for(int elem: arr) } // Insofern "auto" verwendet wird, muss der Typ nicht weiter beachtet werden. - -for(auto elem: arr) +for(auto elem: arr) { // Anweisungen ... } @@ -1029,18 +1028,17 @@ for(auto elem: arr) // C++ ist eine der Sprachen, bei der es ein leichtes ist sich selbst ins Bein zu schießen. // Private-Methoden können überschrieben werden -class Foo +class Foo { virtual void bar(); }; -class FooSub : public Foo +class FooSub : public Foo { virtual void bar(); // Überschreibt Foo::bar! }; - -// 0 == false == NULL +// 0 == false == NULL bool* pt = new bool; *pt = 0; // Setzt den Wert des Pointers 'pt' auf false. pt = 0; // Setzt 'pt' auf den "null-pointer". Keine Compiler-Warnung. @@ -1050,18 +1048,17 @@ int* pt2 = new int; *pt2 = nullptr; // Kompiliert nicht. pt2 = nullptr; // Setzt pt2 auf null. -// Eine Ausnahme bilden bools. +// Eine Ausnahme bilden bool´s. // Dies erlaubt es "null-pointer" zu testen: if(!ptr) // Die Konsequenz ist jedoch, dass dem nullptr ein bool zugewiesen werden kann. -*pt = nullptr; // Kompiliert auch wenn '*pt' ein bool ist! - +*pt = nullptr; // Kompiliert auch, wenn '*pt' ein bool ist! // '=' != '=' != '='! // Ruft Foo::Foo(const Foo&) auf, oder den Kopierkonstruktor Foo f2; Foo f1 = f2; -// Ruft Foo::Foo(const Foo&) auf, aber kopiert lediglich den "Foo" Teil von +// Ruft Foo::Foo(const Foo&) auf, aber kopiert lediglich den "Foo" Teil von // "fooSub". Alle zusätzlichen Member werden verworfen. Diese eigenartige Verhalten // wird auch "object slicing" genannt. FooSub fooSub; @@ -1077,10 +1074,10 @@ f1 = f2; #include -// Konzeptionell sind Tuples alten Datenstrukturen sehr ähnlich, allerdings haben diese keine -// benamten Daten-Member, sondern werden durch die Reihenfolge angesprochen. +// Konzeptionell sind Tuple´s alten Datenstrukturen sehr ähnlich, allerdings haben diese keine +// bezeichneten Daten-Member, sondern werden durch die Reihenfolge angesprochen. -// Erstellen des Tuples und das Einfügen eines Werts. +// Erstellen des Tuples und das Einfügen eines Werts. auto first = make_tuple(10, 'A'); const int maxN = 1e9; const int maxL = 15; @@ -1122,8 +1119,7 @@ cout << get<5>(concatenated_tuple) << "\n"; // Ausgabe: 'A' // Die meisten Operatoren in C++ entsprechen denen aus anderen Sprachen // Logische Operatoren. - -// C++ verwendet so genannte "Short-circuit" Evaluierung für boolean-Ausdrücke. +// C++ verwendet so genannte "Short-circuit" Evaluierung für Boolean-Ausdrücke. // Das zweite Argument wird ausgeführt bzw. evaluiert, wenn das erste Argument genügt, // um den Ausdruck zu bestimmen. -- cgit v1.2.3 From 4132daa9e5eacab90eedbc63a203b9d21ca7ae5c Mon Sep 17 00:00:00 2001 From: Aldaschwede <32069769+Aldaschwede@users.noreply.github.com> Date: Tue, 6 Aug 2019 17:34:48 +0200 Subject: Update python3-de.html.markdown spelling mistake --- de-de/python3-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown index c383d742..4ef997a1 100644 --- a/de-de/python3-de.html.markdown +++ b/de-de/python3-de.html.markdown @@ -14,7 +14,7 @@ Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist he Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service]. -Hinweis: Dieser Beitrag bezieht sich insplizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter. +Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter. ```python -- cgit v1.2.3 From ec3d3f91ea91cd5c6b6569af194dbafb5635c4c4 Mon Sep 17 00:00:00 2001 From: Profpatsch Date: Mon, 19 Aug 2019 14:57:50 +0200 Subject: [dhall/de]: add German translation (#3600) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * [dhall/en] Typo & highlight terms Template and package are referencing concepts from other languages, so let’s highlight them to clarify. * [dhall/de] Translate to German The translation leaves (most) of the code as-is, only changing the comments and some string contents. The `philadelphia` and `john` fields are changed to `augsburg` and `bernd` respectively, as an in-joke for German programmers. --- de-de/dhall-de.html.markdown | 380 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 380 insertions(+) create mode 100644 de-de/dhall-de.html.markdown (limited to 'de-de') diff --git a/de-de/dhall-de.html.markdown b/de-de/dhall-de.html.markdown new file mode 100644 index 00000000..385c88be --- /dev/null +++ b/de-de/dhall-de.html.markdown @@ -0,0 +1,380 @@ +--- +language: Dhall +contributors: + - ["Gabriel Gonzalez", "http://www.haskellforall.com/"] +translators: + - ["Profpatsch", "http://profpatsch.de"] +filename: learndhall-de.py +lang: de-de +--- + +Dhall ist eine programmierbare Konfigurationssprache und bietet eine +nicht-repetetive Alternative zu YAML. + +Man kann Dhall sehen als: JSON + Funktionen + Typen + Importsystem + +Obwohl Dhall programmierbar ist, ist die Sprache nicht +turingvollständig. Viele von Dhalls Features benutzen diese +Einschränkung, um stärkere Sicherheitsgarantien zu bieten und besseres +Tooling zu ermöglichen. + +```haskell +-- einzeiliger Kommentar + +{- mehrzeiliger Kommentar + + Unicode funktioniert 🙂 + + Diese Datei ist eine valide Dhall-Expression und evaluiert zu einem + großen Record, welcher die Ergebnisse jedes Schritts beinhaltet. + + Das Ergebnis kann angezeigt werden, indem man die Datei evaluiert: + + $ dhall --file learndhall.dhall + + {- Kommentare können verschachtelt sein -} +-} + +let greeting = "Hallo, Welt!" + +let fruits = "🍋🍓🍍🍉🍌" + +let interpolation = "Ein paar leckere Früchte: ${fruits}" + +let multilineText {- Inline-Kommentare funktionieren ebenfalls -} = + '' + In Multiline-Text-Literals wird Whitespace am Anfang der Zeile + entfernt. + + Das bedeutet Text kann frei eingerückt oder ausgerückt werden, + ohne dass sich der Inhalt des Strings ändert. + + Relative Einrückungen bleiben erhalten. + + Ansonsten wird das Text-Literal verbatim erhalten, ähnlich + zu “literal”-Multiline-Strings in YAML. + '' + +let bool = True + +-- Typannotationen für Bindings sind optional, aber hilfreich, also +-- benutzen wir sie hier. +let annotation : Bool = True + +let renderedBool : Text = if bool then "True" else "False" + +-- Natürliche Zahlen sind nicht-negativ und vorzeichenlos. +let naturalNumber : Natural = 42 + +-- Integer können negativ sein, brauchen aber ein explizites Vorzeichen. +let positiveInteger : Integer = +1 + +let negativeInteger : Integer = -12 + +let pi : Double = 3.14159265359 + +{- Identifier dürfen eine große Anzahl an verschiedenen Zeichen + beinhalten (wie z.B. Anführungszeichen oder Whitespace), wenn man + sie mit Backticks umschließt. +-} +let `Avogadro's Number` : Double = 6.0221409e+23 + +let origin : { x : Double, y : Double } = { x = 0.0, y = 0.0 } + +let somePrimes : List Natural = [ 2, 3, 5, 7, 11 ] + +{- Ein Schema ist das gleiche wie ein Typ. + + Typnamen beginnen konventionell mit einem Großbuchstaben, was + jedoch nicht erzwungen wird. +-} +let Profile : Type + = { person : + { name : Text + , age : Natural + } + , address : + { country : Text + , state : Text + , city : Text + } + } + +let bernd : Profile = + { person = + { name = "Bernd Lauert" + , age = 67 + } + , address = + { country = "Deutschland" + , state = "Bayern" + , city = "Augsburg" + } + } + +let augsburg : Text = bernd.address.city + +{- Enum-Alternativen beginnen konventionell auch mit einem + Großbuchstaben. Das wird ebenfalls nicht erzwungen. +-} +let DNA : Type = < Adenine | Cytosine | Guanine | Thymine > + +let dnaSequence : List DNA = [ DNA.Thymine, DNA.Guanine, DNA.Guanine ] + +let compactDNASequence : List DNA = + let a = DNA.Adenine + let c = DNA.Cytosine + let g = DNA.Guanine + let t = DNA.Thymine + in [ c, t, t, a, t, c, g, g, c ] + +-- Enums werden transformiert, indem man einen Record mit einem Feld +-- pro Alternative angibt. +let theLetterG : Text = + merge + { Adenine = "A" + , Cytosine = "C" + , Guanine = "G" + , Thymine = "T" + } + DNA.Guanine + +let presentOptionalValue : Optional Natural = Some 1 + +let absentOptionalValue : Optional Natural = None Natural + +let points : List { x : Double, y : Double } = + [ { x = 1.1, y = -4.2 } + , { x = 4.4, y = -3.0 } + , { x = 8.2, y = -5.5 } + ] + +{- `Natural -> List Natural` ist der Funktionstyp mit Eingabetyp + `Natural` und Ausgabetyp `List Natural`. + + Alle Funktionen in Dhall sind Anonyme Funktionen (aka. „Lambdas“), + denen man optional einen Namen geben kann. + + Die folgende Funktion beispielsweise ist äquivalent zu diesem + Python Code: + + lambda n : [ n, n + 1 ] + + ... und diesem Javascript Code: + + function (n) { return [ n, n + 1 ]; } +-} +let exampleFunction : Natural -> List Natural = + \(n : Natural) -> [ n, n + 1 ] + +-- Dhall unterstützt auch Unicode-Syntax, aber dieses Tutorial nutzt +-- die ASCII-Syntax. +let unicodeFunction : Natural → List Natural = + λ(n : Natural) → [ n, n + 1 ] + +-- Funktionsargumente brauchen keine Klammern. +let exampleFunctionApplication : List Natural = + exampleFunction 2 + +let functionOfMultipleArguments : Natural -> Natural -> List Natural = + \(x : Natural) -> \(y : Natural) -> [ x, y ] + +let functionAppliedToMultipleArguments : List Natural = + functionOfMultipleArguments 2 3 + +{- Wie `exampleFunction`, aber wir geben dem Eingabetypen + einen Namen, `n`. +-} +let namedArgumentType : forall (n : Natural) -> List Natural = + \(n : Natural) -> [ n, n + 1 ] + +{- Bekommt der Eingabetyp einen Namen, kann man ihn weiter hinten in + der gleichen Typdefinition wiederverwenden. + + Das ermöglicht Funktionen, die mit mehr als einem Eingabetypen + arbeiten können (aka. „polymorphe“ Funktionen). +-} +let duplicate : forall (a : Type) -> a -> List a = + \(a : Type) -> \(x : a) -> [ x, x ] + +let duplicatedNumber : List Natural = + duplicate Natural 2 + +let duplicatedBool : List Bool = + duplicate Bool False + +{- Die Sprache hat auch eine handvoll eingebauter polymorpher + Funktionen, wie zum Beispiel: + + List/head : forall (a : Type) -> List a -> Optional a +-} +let firstPrime : Optional Natural = List/head Natural somePrimes + +let functionOfARecord : { x : Natural, y : Natural } -> List Natural = + \(args : { x : Natural, y : Natural }) -> [ args.x, args.y ] + +let functionAppliedToARecord : List Natural = + functionOfARecord { x = 2, y = 5 } + +{- Alle Typkonversionen sind explizit. + + `Natural/show` ist eine eingebaute Funktion mit dem Typ: + + Natural/show : Natural -> Text + + ... welche `Natural`s in ihre `Text`-Repräsentation konvertiert. +-} +let typeConversion : Natural -> Text = + \(age : Natural) -> "Ich bin ${Natural/show age} Jahre alt!" + +-- Ein „Template“ ist einfach eine Funktion mit Ausgabetyp `Text`. +let mitLicense : { year : Natural, copyrightHolder : Text } -> Text = + \(args : { year : Natural, copyrightHolder : Text }) -> +'' +Copyright ${Natural/show args.year} ${args.copyrightHolder} + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +'' + +-- Template-Instanziierung ist das gleiche wie Funktionsanwendung. +let templatedLicense : Text = + mitLicense { year = 2019, copyrightHolder = "Jane Smith" } + +{- Expressions können via URL importiert werden. + + Ähnlich wie in Bash kann man Code aus dem lokalen Dateisystem + importieren (wird nicht gezeigt). + + Sicherheitsbewusste Nutzer können via URLs importierte Expressions + mit einem semantischen Integritätscheck versehen („pinnen“). + Für gepinnte Imports wird der Dhall-Interpreter jeden Versuch + vereiteln, auf der Remote-Seite die Expression zu manipulieren. + Jedoch werden Änderungen, die den Inhalt der importierten + Expression nicht verändern trotzdem akzeptiert. + + Auf diese Weise gepinnte Expressions werden auch in einem + Content-Adressable Store lokal gecached (standardmäßig in + `~/.cache/dhall`). +-} +let Natural/sum : List Natural -> Natural = + https://prelude.dhall-lang.org/Natural/sum + sha256:33f7f4c3aff62e5ecf4848f964363133452d420dcde045784518fb59fa970037 + +let twentyEight : Natural = Natural/sum somePrimes + +-- Ein „Paket“ ist einfach ein (möglicherweise verschachtelter) +-- Record, den man importiert. +let Prelude = https://prelude.dhall-lang.org/package.dhall + +let false : Bool = Prelude.Bool.not True + +-- Durch das Anhängen von `as Text` wird eine Datei verbatim +-- importiert und nicht als Dhall-Code interpretiert. +let sourceCode : Text = https://prelude.dhall-lang.org/Bool/not as Text + +-- Environment-Variablen können auch imortiert werden. +let presentWorkingDirectory = env:PWD as Text + +-- Mit `?` kann man eine “Fallback-Expression” angeben, für den Fall +-- dass ein Import fehlschlägt. +let home : Optional Text = Some env:HOME ? None Text + +-- Fallback-Expressions können auch alternative Imports enthalten. +let possiblyCustomPrelude = + env:DHALL_PRELUDE + ? https://prelude.dhall-lang.org/package.dhall + +{- Ein ausführliches Beispiel, welches mithilfe der + `generate`-Funktion eine Konfiguration für 10 Build-User generiert: + + Prelude.List.generate + : Natural -> forall (a : Type) -> (Natural -> a) -> List a +-} +let buildUsers = + let makeUser = \(user : Text) -> + let home = "/home/${user}" + let privateKey = "${home}/.ssh/id_ed25519" + let publicKey = "${privateKey}.pub" + in { home = home + , privateKey = privateKey + , publicKey = publicKey + } + + let buildUser = + \(index : Natural) -> makeUser "build${Natural/show index}" + + let Config = + { home : Text + , privateKey : Text + , publicKey : Text + } + + in Prelude.List.generate 10 Config buildUser + +-- Alle Ergebnisse in einem großen Record +in { greeting = greeting + , fruits = fruits + , interpolation = interpolation + , multilineText = multilineText + , bool = bool + , annotation = annotation + , renderedBool = renderedBool + , naturalNumber = naturalNumber + , positiveInteger = positiveInteger + , negativeInteger = negativeInteger + , pi = pi + , `Avogadro's Number` = `Avogadro's Number` + , origin = origin + , somePrimes = somePrimes + , bernd = bernd + , augsburg = augsburg + , dnaSequence = dnaSequence + , compactDNASequence = compactDNASequence + , theLetterG = theLetterG + , presentOptionalValue = presentOptionalValue + , absentOptionalValue = absentOptionalValue + , points = points + , exampleFunction = exampleFunction + , unicodeFunction = unicodeFunction + , exampleFunctionApplication = exampleFunctionApplication + , functionOfMultipleArguments = functionOfMultipleArguments + , functionAppliedToMultipleArguments = functionAppliedToMultipleArguments + , namedArgumentType = namedArgumentType + , duplicate = duplicate + , duplicatedNumber = duplicatedNumber + , duplicatedBool = duplicatedBool + , firstPrime = firstPrime + , functionOfARecord = functionOfARecord + , functionAppliedToARecord = functionAppliedToARecord + , typeConversion = typeConversion + , mitLicense = mitLicense + , templatedLicense = templatedLicense + , twentyEight = twentyEight + , false = false + , sourceCode = sourceCode + , presentWorkingDirectory = presentWorkingDirectory + , home = home + , buildUsers = buildUsers + } +``` + +Mehr Infos und Lernmaterialien gibt es auf der offiziellen Website +(Englisch), auf der man Dhall auf im Browser ausprobieren kann: + +* [https://dhall-lang.org](http://dhall-lang.org/) -- cgit v1.2.3 From 850999a145fb4ecafe386ebbe5920311e0dfb700 Mon Sep 17 00:00:00 2001 From: Dennis Keller Date: Mon, 21 Oct 2019 08:54:16 +0200 Subject: [clojure-macros/de] Translate clojure-macros to german --- de-de/clojure-macros-de.html.markdown | 161 ++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 de-de/clojure-macros-de.html.markdown (limited to 'de-de') diff --git a/de-de/clojure-macros-de.html.markdown b/de-de/clojure-macros-de.html.markdown new file mode 100644 index 00000000..088a29a8 --- /dev/null +++ b/de-de/clojure-macros-de.html.markdown @@ -0,0 +1,161 @@ +--- +language: "clojure macros" +filename: learnclojuremacros-de.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Dennis Keller", "https://github.com/denniskeller"] +lang: de-de +--- + +Wie mit allen Lisps besitzt auch Clojure die inhärente [Homoikonizität](https://en.wikipedia.org/wiki/Homoiconic), +die dir den vollen Zugang der Sprache gibt, um + Code-Generierungsroutinen zu schreiben. Diese werden "Macros" genannt. +Macros geben dir eine leistungsarke Möglichkeit, die Sprache +an deine Bedürfnisse anzupassen. + +Sei aber vorsichtig, es wird als schlechter Stil angesehen, wenn du +ein Macro schreibst, obwohl eine Funktion genausogut funktionieren würde. +Verwende nur dann ein Macro, wenn du Kontrolle darüber brauchst, wann oder ob Argumente in einer Form evaluiert werden. + +Wenn du mit Clojure vertraut sein möchtest, stelle sicher, dass du alles in [Clojure in Y Minutes](/docs/clojure/) verstehst. + +```clojure +;; Definiere ein Macro mit defmacro. Dein Macro sollte eine Liste zurückgeben, +;; die als Clojure Code evaluiert werden kann. +;; +;; Dieses Macro ist das Gleiche, als ob du (reverse "Hallo Welt") geschrieben +;; hättest +(defmacro my-first-macro [] + (list reverse "Hallo Welt")) + +;; Inspiziere das Ergebnis eines Macros mit macroexpand oder macroexpand-1. +;; +;; Beachte, dass der Aufruf zitiert sein muss. +(macroexpand '(my-first-macro)) +;; -> (# "Hallo Welt") + +;; Du kannst das Ergebnis von macroexpand direkt auswerten. +(eval (macroexpand '(my-first-macro))) +; -> (\t \l \e \W \space \o \l \l \a \H) + +;; Aber du solltest diese prägnante und funktionsähnliche Syntax verwenden: +(my-first-macro) ; -> (\t \l \e \W \space \o \l \l \a \H) + +;; Du kannst es dir leichter machen, indem du die Zitiersyntax verwendest +;; um Listen in ihren Makros zu erstellen: +(defmacro my-first-quoted-macro [] + '(reverse "Hallo Welt")) + +(macroexpand '(my-first-quoted-macro)) +;; -> (reverse "Hallo Welt") +;; Beachte, dass reverse nicht mehr ein Funktionsobjekt ist, sondern ein Symbol + +;; Macros können Argumente haben. +(defmacro inc2 [arg] + (list + 2 arg)) + +(inc2 2) ; -> 4 + +;; Aber wenn du versuchst das mit einer zitierten Liste zu machen wirst du +;; einen Fehler bekommen, weil das Argument auch zitiert sein wird. +;; Um dies zu umgehen, bietet Clojure einee Art und Weise Macros zu zitieren: ` +;; In ` kannst du ~ verwenden um in den äußeren Bereich zu kommen. +(defmacro inc2-quoted [arg] + `(+ 2 ~arg)) + +(inc2-quoted 2) + +;; Du kannst die normalen destruktuierungs Argumente verwenden. Expandiere +;; Listenvariablen mit ~@. +(defmacro unless [arg & body] + `(if (not ~arg) + (do ~@body))) ; Erinnere dich an das do! + +(macroexpand '(unless true (reverse "Hallo Welt"))) +;; -> +;; (if (clojure.core/not true) (do (reverse "Hallo Welt"))) + +;; (unless) evaluiert und gibt body zurück, wenn das erste Argument falsch ist. +;; Andernfalls gibt es nil zurück + +(unless true "Hallo") ; -> nil +(unless false "Hallo") ; -> "Hallo" + +;; Die Verwendung Macros ohne Sorgfalt kann viel Böses auslösen, indem es +;; deine Variablen überschreibt +(defmacro define-x [] + '(do + (def x 2) + (list x))) + +(def x 4) +(define-x) ; -> (2) +(list x) ; -> (2) + +;; Um das zu verhindern kannst du gensym verwenden um einen eindeutigen +;; Identifikator zu bekommen +(gensym 'x) ; -> x1281 (oder etwas Ähnliches) + +(defmacro define-x-safely [] + (let [sym (gensym 'x)] + `(do + (def ~sym 2) + (list ~sym)))) + +(def x 4) +(define-x-safely) ; -> (2) +(list x) ; -> (4) + +;; Du kannst # innerhalb von ` verwenden um für jedes Symbol automatisch +;; ein gensym zu erstellen +(defmacro define-x-hygienically [] + `(do + (def x# 2) + (list x#))) + +(def x 4) +(define-x-hygienically) ; -> (2) +(list x) ; -> (4) + +;; Es ist üblich, Hilfsfunktionen mit Macros zu verwenden. Lass uns einige +;; erstellen, die uns helfen , eine (dumme) arithmetische Syntax +;; zu unterstützen +(declare inline-2-helper) +(defn clean-arg [arg] + (if (seq? arg) + (inline-2-helper arg) + arg)) + +(defn apply-arg + "Bekomme die Argumente [x (+ y)], gebe (+ x y) zurück" + [val [op arg]] + (list op val (clean-arg arg))) + +(defn inline-2-helper + [[arg1 & ops-and-args]] + (let [ops (partition 2 ops-and-args)] + (reduce apply-arg (clean-arg arg1) ops))) + +;; Wir können es sofort testen, ohne ein Macro zu erstellen +(inline-2-helper '(a + (b - 2) - (c * 5))) ; -> (- (+ a (- b 2)) (* c 5)) + +; Allerdings, brauchen wir ein Macro, wenn wir es zur Kompilierungszeit +; ausführen wollen +(defmacro inline-2 [form] + (inline-2-helper form)) + +(macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1))) +; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1) + +(inline-2 (1 + (3 / 2) - (1 / 2) + 1)) +; -> 3 (eigentlich, 3N, da die Zahl zu einem rationalen Bruch mit / umgewandelt wird) +``` + +### Weiterführende Literatur + +[Macros schreiben](http://www.braveclojure.com/writing-macros/) + +[Offiziele Docs](http://clojure.org/macros) + +[Wann verwendet man Macros?](https://lispcast.com/when-to-use-a-macro/) -- cgit v1.2.3 From 60e962ee0d902ba3468b8323d50276a81124144f Mon Sep 17 00:00:00 2001 From: Dennis Keller Date: Mon, 21 Oct 2019 08:51:59 +0200 Subject: [pug/de] Translate pug to german --- de-de/pug-de.html.markdown | 208 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 de-de/pug-de.html.markdown (limited to 'de-de') diff --git a/de-de/pug-de.html.markdown b/de-de/pug-de.html.markdown new file mode 100644 index 00000000..c86494ce --- /dev/null +++ b/de-de/pug-de.html.markdown @@ -0,0 +1,208 @@ +--- +language: Pug +contributors: + - ["Michael Warner", "https://github.com/MichaelJGW"] +filename: lernepug-de.pug +translators: + - ["denniskeller", "https://github.com/denniskeller"] +lang: de-de +--- + +## Erste Schritte mit Pug + +Pug ist eine kleine Sprache, die zu HTML kompiliert. Sie hat eine +saubere Syntax mit zusätzlichen Funktionen wie if Anweisungen und Schleifen. +Sie kann auch als serverseitige Templatingsprache für Serversprachen +wie NodeJS verwendet werden. + +### Die Sprache +```pug + +//- Einzeilenkommentar + +//- Mehrzeiliger + Kommentar + +//- ---TAGS--- +//- Grundlagen +div +//-
+h1 +//-

+mein-benutzerdefiniertesTag +//- + +//- Geschwister +div +div +//-
+
+ +//- Kind +div + div +//-
+
+
+ +//- Text +h1 Hallo Welt +//-

Hallo Welt

+ +//- Multizeilentext +div. + Hallo + Welt +//-
+ Hallo + Welt +
+ +//- ---ATTRIBUTE--- +div(class="meine-klasse" id="meine-id" mein-benutzerdefiniertes-attr="data" enabled) +//-
+ +//- Kurzhand +span.meine-klasse +//- +.meine-klasse +//-
+div#meine-id +//-
+div#meine-id.meine-klasse +//-
+ + +//- ---JS--- +- const sprache = "pug"; + +//- Multizeilen JS +- + const srache = "pug"; + const cool = true; + +//- JS Klassen +- const meineKlasse = ['class1', 'class2', 'class3'] +div(class=meineKlasse) +//-
+ +//- JS Stil +- const meineStile = {'color':'white', 'background-color':'blue'} +div(styles=meineStile) +//-
+ +//- JS Attributte +- const meineAttribute = {"src": "foto.png", "alt": "meine Bilder"} +img&attributes(meineAttribute) +//- meine Bilder +- let deaktiviert = false +input(type="text" disabled=deaktiviert) +//- +- deaktiviert = true +input(type="text" disabled=deaktiviert) +//- + +//- JS Templating +- const name = "Bob"; +h1 Hi #{name} +h1= name +//-

Hi Bob

+//-

Bob

+ +//- ---Schleifen--- + +//- 'each' und 'for' machen das Selbe. Wir werden nur 'each' verwenden. + +each value, i in [1,2,3] + p=value +//- +

1

+

2

+

3

+ +each value, index in [1,2,3] + p=value + '-' + index +//- +

1-0

+

2-1

+

3-2

+ +each value in [] + p=value +//- + +each value in [] + p=value +else + p Keine Werte sind hier + +//-

Keine Werte sind hier

+ +//- ---BEDINGUNGEN--- + +- const zahl = 5 +if zahl < 5 + p zahl ist kleiner als 5 +else if zahl > 5 + p zahl ist größer als 5 +else + p zahl ist 5 +//-

zahl ist 5

+ +- const bestellungsStatus = "Ausstehend"; +case bestellungsStatus + when "Ausstehend" + p.warn Deine Bestellung steht noch aus + when "Abgeschlossen" + p.success Bestellung ist abgeschlossen. + when -1 + p.error Ein Fehler ist aufgetreten + default + p kein Bestellprotokoll gefunden +//-

Deine Bestellung steht noch aus

+ +//- --INCLUDE-- +//- File path -> "includes/nav.png" +h1 Firmenname +nav + a(href="index.html") Home + a(href="about.html") Über uns + +//- Dateipfad -> "index.png" +html + body + include includes/nav.pug +//- + + +

Firmenname

+ + + + +//- Importiere JS und CSS +script + include scripts/index.js +style + include styles/theme.css + +//- ---MIXIN--- +mixin basic() + div Hallo ++basic("Bob") +//-
Hallo
+ +mixin comment(name, kommentar) + div + span.comment-name= name + div.comment-text= kommentar ++comment("Bob", "Das ist super") +//-
Hallo
+ +``` + + +### Zusätzliche Ressourcen +- [The Site](https://pugjs.org/) +- [The Docs](https://pugjs.org/api/getting-started.html) +- [Github Repo](https://github.com/pugjs/pug) -- cgit v1.2.3 From 653f2ee43eb0eebfcbd7f3e06c4cbf47e0191796 Mon Sep 17 00:00:00 2001 From: waynee95 Date: Mon, 21 Oct 2019 23:10:48 +0200 Subject: [elm/de] Translate elm to german --- de-de/elm-de.html.markdown | 376 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 376 insertions(+) create mode 100644 de-de/elm-de.html.markdown (limited to 'de-de') diff --git a/de-de/elm-de.html.markdown b/de-de/elm-de.html.markdown new file mode 100644 index 00000000..b74a975f --- /dev/null +++ b/de-de/elm-de.html.markdown @@ -0,0 +1,376 @@ +--- +language: Elm +filename: learnelm.elm +contributors: + - ["Max Goldstein", "http://maxgoldste.in/"] +translators: + - ["waynee95", "https://waynee95.me"] +lang: de-de +--- + +Elm ist eine pure funktionale Programmiersprache. Mit Elm werden GUIs +(grafische Benutzeroberfläche) für Webanwendungen erstellt. Durch die statische +Typisierung kann Elm viele Fehler schon bei der Kompilierung abfangen. Ein +Hauptmerkmal von Elm sind die ausführlichen und gut erklärten Fehlermeldungen. + +```haskell +-- Einzeilige Kommentare beginnen mit 2 Bindestrichen. +{- So wird ein mehrzeiliger Kommentar angelegt. +{- Diese können auch verschachtelt werden. -} +-} + +{-- Die Grundlagen --} + +-- Arithmetik +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 + +-- Zahlen ohne Punkt sind entweder vom Typ Int oder Float. +33 / 2 -- 16.5 mit Division von Gleitkommazahlen +33 // 2 -- 16 mit ganzzahliger Division + +-- Exponenten +5 ^ 2 -- 25 + +-- Boolsche Werte +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- Strings (Zeichenketten) und Zeichen +"Das hier ist ein String." +'a' -- Zeichen + +-- Strings können konkateniert werden. +"Hello " ++ "world!" -- "Hello world!" + +{-- Listen und Tupel --} + +-- Jedes Element einer Liste muss vom gleichen Typ sein. Listen sind homogen. +["the", "quick", "brown", "fox"] +[1, 2, 3, 4, 5] +-- Das zweite Beispiel kann man auch mit Hilfe der "range" Funktion schreiben. +List.range 1 5 + +-- Listen werden genauso wie Strings konkateniert. +List.range 1 5 ++ List.range 6 10 == List.range 1 10 -- True + +-- Mit dem "cons" Operator lässt sich ein Element an den Anfang einer Liste anfügen. +0 :: List.range 1 5 -- [0, 1, 2, 3, 4, 5] + +-- Die Funktionen "head" und "tail" haben als Rückgabewert den "Maybe" Typ. +-- Dadurch wird die Fehlerbehandlung von fehlenden Elemenent explizit, weil +-- man immer mit jedem möglichen Fall umgehen muss. +List.head (List.range 1 5) -- Just 1 +List.tail (List.range 1 5) -- Just [2, 3, 4, 5] +List.head [] -- Nothing +-- List.funktionsName bedeutet, dass diese Funktion aus dem "List"-Modul stammt. + +-- Tupel sind heterogen, jedes Element kann von einem anderen Typ sein. +-- Jedoch haben Tupel eine feste Länge. +("elm", 42) + +-- Das Zugreifen auf Elemente eines Tupels geschieht mittels den Funktionen +-- "first" und "second". +Tuple.first ("elm", 42) -- "elm" +Tuple.second ("elm", 42) -- 42 + +-- Das leere Tupel, genannt "Unit", wird manchmal als Platzhalter verwendet. +-- Es ist das einzige Element vom Typ "Unit". +() + +{-- Kontrollfluss --} + +-- Eine If-Bedingung hat immer einen Else-Zweig und beide Zweige müssen den +-- gleichen Typ haben. +if powerLevel > 9000 then + "WHOA!" +else + "meh" + +-- If-Bedingungen können verkettet werden. +if n < 0 then + "n is negative" +else if n > 0 then + "n is positive" +else + "n is zero" + +-- Mit dem Mustervergleich (pattern matching) kann man bestimmte Fälle direkt +-- behandeln. +case aList of + [] -> "matches the empty list" + [x]-> "matches a list of exactly one item, " ++ toString x + x::xs -> "matches a list of at least one item whose head is " ++ toString x +-- Mustervergleich geht immer von oben nach unten. Würde man [x] als letztes +-- platzieren, dann würde dieser Fall niemals getroffen werden, weil x:xs diesen +-- Fall schon mit einschließt (xs ist in dem Fall die leere Liste). + +-- Mustervergleich an einem Maybe Typ. +case List.head aList of + Just x -> "The head is " ++ toString x + Nothing -> "The list was empty." + +{-- Funktionen --} + +-- Die Syntax für Funktionen in Elm ist minimal. Hier werden Leerzeichen anstelle +-- von runden oder geschweiften Klammern verwendet. Außerdem gibt es kein "return" +-- Keyword. + +-- Eine Funktion wird durch ihren Namen, einer Liste von Parametern gefolgt von +-- einem Gleichheitszeichen und dem Funktionskörper angegeben. +multiply a b = + a * b + +-- Beim Aufruf der Funktion (auch Applikation genannt) werden die Argumente ohne +-- Komma übergeben. +multiply 7 6 -- 42 + +-- Partielle Applikation einer Funktion (Aufrufen einer Funktion mit fehlenden +-- Argumenten). Hierbei entsteht eine neue Funktion, der wir einen Namen geben. +double = + multiply 2 + +-- Konstanten sind Funktionen ohne Parameter. +answer = + 42 + +-- Funktionen, die Funktionen als Parameter haben, nennt man Funktionen höherer +-- Ordnung. In funktionalen Programmiersprachen werden Funktionen als "first-class" +-- behandelt. Man kann sie als Argument übergeben, als Rückgabewert einer Funktion +-- zurückgeben oder einer Variable zuweisen. +List.map double (List.range 1 4) -- [2, 4, 6, 8] + +-- Funktionen können auch als anonyme Funktion (Lambda-Funktionen) übergeben werden. +-- Diese werden mit einem Blackslash eingeleitet, gefolgt von allen Argumenten. +-- Die Funktion "\a -> a * 2" beschreibt die Funktion f(x) = x * 2. +List.map (\a -> a * 2) (List.range 1 4) -- [2, 4, 6, 8] + +-- Mustervergleich kann auch in der Funktionsdefinition verwendet werden. +-- In diesem Fall hat die Funktion ein Tupel als Parameter. (Beachte: Hier +-- werden die Werte des Tupels direkt ausgepackt. Dadurch kann man auf die +-- Verwendung von "first" und "second" verzichten.) +area (width, height) = + width * height + +area (6, 7) -- 42 + +-- Mustervergleich auf Records macht man mit geschweiften Klammern. +-- Bezeichner (lokale Variablen) werden mittels dem "let" Keyword angelegt. +-- (Mehr zu Records weiter unten!) +volume {width, height, depth} = + let + area = width * height + in + area * depth + +volume { width = 3, height = 2, depth = 7 } -- 42 + +-- Rekursive Funktion +fib n = + if n < 2 then + 1 + else + fib (n - 1) + fib (n - 2) + +List.map fib (List.range 0 8) -- [1, 1, 2, 3, 5, 8, 13, 21, 34] + +-- Noch eine rekursive Funktion (Nur ein Beispiel, verwende stattdessen immer +-- List.length!) +listLength aList = + case aList of + [] -> 0 + x::xs -> 1 + listLength xs + +-- Funktionsapplikation hat die höchste Präzedenz, sie binden stärker als Operatoren. +-- Klammern bietet die Möglichkeit der Bevorrangung. +cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1 +-- Als erstes wird die Funktion "degrees" mit dem Wert 30 aufgerufen. +-- Danach wird das Ergenis davon den Funktionen "cos", bzw. "sin" übergeben. +-- Dann wird das Ergebnis davon mit 2 quadriert und als letztes werden diese +-- beiden Werte dann addiert. + +{-- Typen und Typ Annotationen --} + +-- Durch Typinferenz kann der Compiler jeden Typ genau bestimmen. Man kann diese +-- aber auch manuell selber angeben (guter Stil!). +-- Typen beginnen immer mit eine Großbuchstaben. Dabei liest man "x : Typ" als +-- "x" ist vom Typ "Typ". +-- Hier ein paar übliche Typen: +5 : Int +6.7 : Float +"hello" : String +True : Bool + +-- Funktionen haben ebenfalls einen Typ. Dabei ist der ganz rechte Typ der +-- Rückgabetyp der Funktion und alle anderen sind die Typen der Parameter. +not : Bool -> Bool +round : Float -> Int + +-- Es ist guter Stil immer den Typ anzugeben, da diese eine Form von Dokumentation +-- sind. Außerdem kann so der Compiler genauere Fehlermeldungen geben. +double : Int -> Int +double x = x * 2 + +-- Funktionen als Parameter werden durch Klammern angegeben. Die folgende Funktion +-- ist nicht auf einen Typ festgelegt, sondern enthält Typvariablen (beginnend +-- mit Kleinbuchstaben). Die konkreten Typen werden erst bei Anwendung der +-- Funktion festgelegt. "List a" bedeutet, dass es sich um eine Liste mit +-- Elementen vom Typ "a" handelt. +List.map : (a -> b) -> List a -> List b + +-- Es gibt drei spezielle kleingeschriebene Typen: "number", "comparable" und +-- "appendable". +add : number -> number -> number +add x y = x + y -- funktioniert mit Ints und Floats. + +max :: comparable -> comparable -> comparable +max a b = if a > b then a else b -- funktioniert mit Typen, die vergleichbar sind. + +append :: appendable -> appendable -> appendable +append xs ys = xs ++ ys -- funktioniert mit Typen, die konkatenierbar sind. + +append "hello" "world" -- "helloworld" +append [1,1,2] [3,5,8] -- [1,1,2,3,5,8] + +{-- Eigene Datentypen erstellen --} + +-- Ein "Record" ist ähnlich wie ein Tupel, nur das jedes Feld einen Namne hat. +-- Dabei spielt die Reihenfolge keine Rolle. +{ x = 3, y = 7 } + +-- Um auf Werte eines Records zuzugreifen, benutzt man einen Punkt gefolgt +-- von dem Namen des Feldes. +{ x = 3, y = 7 }.x -- 3 + +-- Oder mit einer Zugriffsfunktion, welche aus einem Punkt und dem Feldnamen besteht. +.y { x = 3, y = 7 } -- 7 + +-- Wert eines Feldes ändern. (Achtung: Das Feld muss aber vorher schon vorhanden sein!) +{ person | + name = "George" } + +-- Mehrere Felder aufeinmal ändern unter Verwendung des alten Wertes. +{ particle | + position = particle.position + particle.velocity, + velocity = particle.velocity + particle.acceleration } + +-- Du kannst ein Record auch als Typ Annotation verwenden. +-- (Beachte: Ein Record Typ benutzt einen Doppelpunkt und ein Record Wert benutzt +-- ein Gleichheitszeichen!) +origin : { x : Float, y : Float, z : Float } +origin = + { x = 0, y = 0, z = 0 } + +-- Durch das "type" Keyword kann man einem existierenden Typen einen Namen geben. +type alias Point3D = + { x : Float, y : Float, z : Float } + +-- Der Name kann dann als Konstruktor verwendet werden. +otherOrigin : Point3D +otherOrigin = + Point3D 0 0 0 + +-- Aber es ist immernoch der selbe Typ, da es nur ein Alias ist! +origin == otherOrigin -- True + +-- Neben den Records gibt es auch noch so genannte Summentypen. +-- Ein Summentyp hat mehrere Konstruktoren. +type Direction = + North | South | East | West + +-- Ein Konstruktor kann außerdem noch andere Typen enthalten. Rekursion ist +-- auch möglich. +type IntTree = + Leaf | Node Int IntTree IntTree + +-- Diese können auch als Typ Annotation verwendet werden. +root : IntTree +root = + Node 7 Leaf Leaf + +-- Außerdem können auch Typvariablen verwendet werden in einem Konstruktor. +type Tree a = + Leaf | Node a (Tree a) (Tree a) + +-- Beim Mustervergleich kann man auf die verschiedenen Konstruktoren matchen. +leftmostElement : Tree a -> Maybe a +leftmostElement tree = + case tree of + Leaf -> Nothing + Node x Leaf _ -> Just x + Node _ subtree _ -> leftmostElement subtree + +{-- Module und Imports --} + +-- Die Kernbibliotheken und andere Bibliotheken sind in Module aufgeteilt. +-- Für große Projekte können auch eigene Module erstellt werden. + +-- Eine Modul beginnt mit ganz oben. Ohne diese Angabe befindet man sich +-- automatisch im Modul "Main". +module Name where + +-- Ohne genaue Angabe von Exports wird alles exportiert. Es können aber alle +-- Exporte explizit angegeben werden. +module Name (MyType, myValue) where + +-- Importiert das Modul "Dict". Jetzt kann man Funktionen mittels "Dict.insert" +-- aufrufen. +import Dict + +-- Importiert das "Dict" Modul und den "Dict" Typ. Dadurch muss man nicht "Dict.Dict" +-- verwenden. Man kann trotzdem noch Funktionen des Moduls aufrufen, wie "Dict.insert". +import Dict exposing (Dict) + +-- Abkürzung für den Modulnamen. Aufrufen der Funktionen mittels "C.funktionsName". +import Graphics.Collage as C + +{-- Kommandozeilen Programme --} + +-- Eine Elm-Datei kompilieren. +$ elm make MyFile.elm + +-- Beim ersten Aufruf wird Elm die "core" Bibliotheken installieren und eine +-- "elm-package.json"-Datei anlegen, die alle Informationen des Projektes +-- speichert. + +-- Der Reactor ist ein Server, welche alle Dateinen kompiliert und ausführt. +$ elm reactor + +-- Starte das REPL (read-eval-print-loop). +$ elm repl + +-- Bibliotheken werden durch den Github-Nutzernamen und ein Repository identifiziert. +-- Installieren einer neuen Bibliothek. +$ elm package install elm-lang/html +-- Diese wird der elm-package.json Datei hinzugefügt. + +-- Zeigt alle Veränderungen zwischen zwei bestimmten Versionen an. +$ elm package diff elm-lang/html 1.1.0 2.0.0 +-- Der Paketmanager von Elm erzwingt "semantic versioning"! +``` + +Elm ist eine besonders kleine Programmiersprache. Jetzt hast du genug Wissen an +deiner Seite, um dich in fast jedem Elm Code zurecht zu finden. + +Noch ein paar weitere hilfreiche Ressourcen (in Englisch): + +- Die [Elm Homepage](http://elm-lang.org/). Dort findest du: + + - [Anleitung zur Installierung von Elm](http://elm-lang.org/install) + - [Dokumentation](http://elm-lang.org/docs), sowie eine [Referenz zur Syntax](http://elm-lang.org/docs/syntax) + - Viele hilfreiche [Beispiele](http://elm-lang.org/examples) + +- Dokumentation der [Elm Kernbibliotheken](http://package.elm-lang.org/packages/elm-lang/core/latest/). Insbesondere: + + - [Basics](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics) (standardmäßig importiert) + - [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) sowie [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result) (benutzt für Fehlerbehandlung) + - Datenstrukturen, wie [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict), und [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set) + - JSON [encoding](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) und [decoding](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode) + +- [Die Elm Architektur](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). + +- Die [Elm mailing list](https://groups.google.com/forum/#!forum/elm-discuss). -- cgit v1.2.3 From 5657bd4fa2a038a56d22b02060e217fff0049f94 Mon Sep 17 00:00:00 2001 From: waynee95 Date: Wed, 23 Oct 2019 15:34:13 +0200 Subject: [nix/de] Fix broken link --- de-de/nix-de.html.markdown | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'de-de') diff --git a/de-de/nix-de.html.markdown b/de-de/nix-de.html.markdown index 79b60d20..ea02e81d 100644 --- a/de-de/nix-de.html.markdown +++ b/de-de/nix-de.html.markdown @@ -8,11 +8,11 @@ translators: lang: de-de --- -Nix ist eine simple funktionale Programmiersprache, die für den +Nix ist eine simple funktionale Programmiersprache, die für den [Nix package manager](https://nixos.org/nix/) und [NixOS](https://nixos.org/) entwickelt wurde. -Du kannst Nix Ausdrücke evaluieren mithilfe von +Du kannst Nix Ausdrücke evaluieren mithilfe von [nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate) oder [`nix-repl`](https://github.com/edolstra/nix-repl). @@ -24,7 +24,7 @@ with builtins; [ # Inline Kommentare sehen so aus. - /* Multizeilen Kommentare + /* Multizeilen Kommentare sehen so aus. */ @@ -61,7 +61,7 @@ with builtins; [ "String Literale sind in Anführungszeichen." " - String Literale können mehrere + String Literale können mehrere Zeilen umspannen. " @@ -95,7 +95,7 @@ with builtins; [ tutorials/learn.nix #=> /the-base-path/tutorials/learn.nix - # Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine + # Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine # Datei im selben Verzeichnis benötigt ein ./ Präfix. ./learn.nix #=> /the-base-path/learn.nix @@ -238,7 +238,7 @@ with builtins; [ #=> { d = 2; e = 3; } # Die Nachkommen eines Attributs können in diesem Feld nicht zugeordnet werden, wenn - # das Attribut selbst nicht zugewiesen wurde. + # das Attribut selbst nicht zugewiesen wurde. { a = { b = 1; }; a.c = 2; @@ -261,9 +261,9 @@ with builtins; [ #=> 7 # Die erste Linie diese Tutorials startet mit "with builtins;", - # weil builtins ein Set mit allen eingebauten + # weil builtins ein Set mit allen eingebauten # Funktionen (length, head, tail, filter, etc.) umfasst. - # Das erspart uns beispielsweise "builtins.length" zu schreiben, + # Das erspart uns beispielsweise "builtins.length" zu schreiben, # anstatt nur "length". @@ -305,7 +305,7 @@ with builtins; [ (tryEval (abort "foo")) #=> error: evaluation aborted with the following error message: ‘foo’ - # `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst + # `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst # löst es eine abfangbare Exception aus. (assert 1 < 2; 42) #=> 42 @@ -319,7 +319,7 @@ with builtins; [ #========================================= # Da die Wiederholbarkeit von Builds für den Nix Packetmanager entscheidend ist, - # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar + # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar # unreine Elemente. # Du kannst auf Umgebungsvariablen verweisen. (getEnv "HOME") @@ -355,4 +355,4 @@ with builtins; [ (https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55) * [Susan Potter - Nix Cookbook - Nix By Example] - (http://funops.co/nix-cookbook/nix-by-example/) + (https://ops.functionalalgebra.com/nix-by-example/) -- cgit v1.2.3 From 6e1f2df651ca7f3349705c7b545600e0b54fc30a Mon Sep 17 00:00:00 2001 From: retoc Date: Thu, 31 Oct 2019 20:46:49 +0100 Subject: updated link to java coding guidelines, the old one is broken --- de-de/java-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/java-de.html.markdown b/de-de/java-de.html.markdown index e8ac5bda..e52087ec 100644 --- a/de-de/java-de.html.markdown +++ b/de-de/java-de.html.markdown @@ -477,7 +477,7 @@ Für tiefergreifende Fragen ist Google der beste Startpunkt. * [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) -* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) +* [Java Code Conventions](https://www.oracle.com/technetwork/java/codeconventions-150003.pdf) **Online Tutorials** -- cgit v1.2.3 From 83cb919e5ed5c0f1d835bda0d2f690cc04eb74d5 Mon Sep 17 00:00:00 2001 From: Louis Brauer <1240462+louis77@users.noreply.github.com> Date: Sun, 10 Nov 2019 17:44:25 +0100 Subject: Fix missing double quotes Was breaking the syntax coloring --- de-de/bash-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown index 7a0db157..3fb3e71f 100644 --- a/de-de/bash-de.html.markdown +++ b/de-de/bash-de.html.markdown @@ -217,7 +217,7 @@ done function foo () { echo "Argumente funktionieren wie bei skripts: $@" - echo Und: $1 $2..." + echo "Und: $1 $2..." echo "Dies ist eine Funktion" return 0 } -- cgit v1.2.3 From bcb704c96063c26b7ba1fb6ea3f767a0c22b7b31 Mon Sep 17 00:00:00 2001 From: Marco Camenzind Date: Tue, 12 Nov 2019 09:37:33 +0100 Subject: Fixed some typos in german translation for C++ --- de-de/c++-de.html.markdown | 49 +++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 24 deletions(-) (limited to 'de-de') diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown index cef7514b..48c245d8 100644 --- a/de-de/c++-de.html.markdown +++ b/de-de/c++-de.html.markdown @@ -9,6 +9,7 @@ contributors: - ["Ankush Goyal", "http://github.com/ankushg07"] - ["Jatin Dhankhar", "https://github.com/jatindhankhar"] - ["Maximilian Sonnenburg", "https://github.com/LamdaLamdaLamda"] + - ["caminsha", "https://github.com/caminsha"] lang: de-de --- @@ -22,9 +23,9 @@ entworfen wurde um, - Objektorientierung zu unterstützen - generische Programmierung zu unterstützen -Durch seinen Syntax kann sie durchaus schwieriger und komplexer als neuere Sprachen sein. +Durch seine Syntax kann sie durchaus schwieriger und komplexer als neuere Sprachen sein. -Sie ist weit verbreitet, weil sie in Maschinen-Code kompiliert, welches direkt vom Prozessor ausgeführt +Sie ist weit verbreitet, weil sie in Maschinen-Code kompiliert, welcher direkt vom Prozessor ausgeführt werden kann und somit eine strikte Kontrolle über die Hardware bietet und gleichzeitig High-Level-Features wie generics, exceptions und Klassen enthält. @@ -36,7 +37,7 @@ weitverbreitesten Programmiersprachen. // Vergleich zu C ////////////////// -// C ist fast eine Untermenge von C++ und teilt sich grundsätzlich den +// C ist fast eine Untermenge von C++ und teilt sich grundsätzlich die // Syntax für Variablen Deklarationen, primitiven Typen und Funktionen. // Wie in C ist der Programmeinsprungpunkt eine Funktion, welche "main" genannt wird und @@ -137,7 +138,7 @@ void invalidDeclaration(int a = 1, int b) // Fehler! ///////////// -// Namespaces (Namesräume) +// Namespaces (Namensräume) ///////////// // Namespaces stellen einen getrennten Gültigkeitsbereich für Variablen, @@ -169,7 +170,7 @@ void foo() int main() { - // Fügt all Symbole aus dem namespace Second in den aktuellen Gültigkeitsbereich (scope). + // Fügt alle Symbole aus dem namespace Second in den aktuellen Gültigkeitsbereich (scope). // "foo()" wird nun nicht länger funktionieren, da es nun doppeldeutig ist, ob foo aus // dem namespace foo oder darüberliegenden aufgerufen wird. using namespace Second; @@ -283,7 +284,7 @@ string retVal = tempObjectFun(); // für Details). Wie in diesem Code: foo(bar(tempObjectFun())) -// Nehmen wir an foo und bar existieren. Das Objekt wird von "tempObjectFun" zurückgegeben, +// Nehmen wir an, foo und bar existieren. Das Objekt wird von "tempObjectFun" zurückgegeben, // wird an bar übergeben und ist zerstört bevor foo aufgerufen wird. // Zurück zu Referenzen. Die Annahme, dass die "am Ende des Ausdrucks" Regel gültig ist, @@ -335,7 +336,7 @@ ECarTypes GetPreferredCarType() return ECarTypes::Hatchback; } -// Mit C++11 existiert eine einfache Möglichkeit einem Typ dem Enum zu zuweisen. Dies +// Mit C++11 existiert eine einfache Möglichkeit einem Typ dem Enum zuzuweisen. Dies // kann durchaus sinnvoll bei der Serialisierung von Daten sein, oder bei der Konvertierung // zwischen Typen bzw. Konstanten. enum ECarTypes : uint8_t @@ -574,7 +575,7 @@ int main () // Templates in C++ werden in erster Linie dafür verwendet generisch zu programmieren. // Sie unterstützen explizite und partielle Spezialisierung und darüber hinaus können // sie für funktionale Klassen verwendet werden. -// Tatsächlich bilden templates die Turing-Vollständigkeit +// Tatsächlich bilden Templates die Turing-Vollständigkeit // (universelle Programmierbarkeit) ab. @@ -588,12 +589,12 @@ public: void insert(const T&) { ... } }; -// Während der Kompilierung generiert der Compiler Kopien für jedes template, wobei +// Während der Kompilierung generiert der Compiler Kopien für jedes Template, wobei // hierbei die Parameter substituiert werden. Somit muss bei jedem Aufruf die gesamte // Definition der Klasse zur Verfügung stehen. Aus diesem Grund wird ein Template // komplett im header definiert. -// Erzeugung einer Template-Klasse auf dem stack: +// Erzeugung einer Template-Klasse auf dem Stack: Box intBox; // eine der zu erwartenden Verwendungen: @@ -612,7 +613,7 @@ boxOfBox.insert(intBox); // sind fast identisch hinsichtlich der Funktionalität. Weitere // Informationen auf: http://en.wikipedia.org/wiki/Typename -// Eine template-Funktion: +// Eine Template-Funktion: template void barkThreeTimes(const T& input) { @@ -622,7 +623,7 @@ void barkThreeTimes(const T& input) } // Hierbei ist zu beachten, dass an dieser Stelle nichts über den Typen des Parameters -// definiert wurde. Der Kompiler wird bei jedem Aufruf bzw. jeder Erzeugung den Typen +// definiert wurde. Der Compiler wird bei jedem Aufruf bzw. jeder Erzeugung den Typen // prüfen. Somit funktioniert die zuvor definierte Funktion für jeden Typ 'T', die die // const Methode 'bark' implementiert hat. @@ -637,10 +638,10 @@ void printMessage() cout << "Learn C++ in " << Y << " minutes!" << endl; } -// Des Weiteren können templates aus Effizienzgründen genauer spezifiziert werden. -// Selbstverständlich sind reale-Problemen, welche genauer spezifiziert werden nicht +// Des Weiteren können Templates aus Effizienzgründen genauer spezifiziert werden. +// Selbstverständlich sind reale Probleme, welche genauer spezifiziert werden, nicht // derart trivial. Auch wenn alle Parameter explizit definiert wurden, muss die -// Funktion oder Klasse als template deklariert werden. +// Funktion oder Klasse als Template deklariert werden. template<> void printMessage<10>() { @@ -818,7 +819,7 @@ void doSomethingWithAFile(const std::string& filename) // Container ///////////////////// -// Die Container der Standard template Bibliothek beinhaltet einige vordefinierter templates. +// Die Container der Standard template Bibliothek beinhaltet einige vordefinierter Templates. // Diese verwalten die Speicherbereiche für die eigenen Elemente und stellen Member-Funktionen // für den Zugriff und die Maniplulation bereit. @@ -876,7 +877,7 @@ for(it=ST.begin();it > tester; @@ -966,7 +967,7 @@ sort(tester.begin(), tester.end(), [](const pair& lhs, const pair -// Konzeptionell sind Tuple´s alten Datenstrukturen sehr ähnlich, allerdings haben diese keine +// Konzeptionell sind Tupel alten Datenstrukturen sehr ähnlich, allerdings haben diese keine // bezeichneten Daten-Member, sondern werden durch die Reihenfolge angesprochen. -// Erstellen des Tuples und das Einfügen eines Werts. +// Erstellen des Tupels und das Einfügen eines Werts. auto first = make_tuple(10, 'A'); const int maxN = 1e9; const int maxL = 15; @@ -1102,7 +1103,7 @@ tuple third(11, 'A', 3.14141); cout << tuple_size::value << "\n"; // prints: 3 -// tuple_cat fügt die Elemente eines Tuples aneinander (in der selben Reihenfolge). +// tuple_cat fügt die Elemente eines Tupels aneinander (in der selben Reihenfolge). auto concatenated_tuple = tuple_cat(first, second, third); // concatenated_tuple wird zu = (10, 'A', 1e9, 15, 11, 'A', 3.14141) -- cgit v1.2.3 From aa35898ad7df7294347611dde302ea046bff434c Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 16 Nov 2019 22:10:37 +0100 Subject: Changed two typos I did not see before review --- de-de/c++-de.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown index 48c245d8..87e75ad6 100644 --- a/de-de/c++-de.html.markdown +++ b/de-de/c++-de.html.markdown @@ -819,9 +819,9 @@ void doSomethingWithAFile(const std::string& filename) // Container ///////////////////// -// Die Container der Standard template Bibliothek beinhaltet einige vordefinierter Templates. +// Die Container der Standard template Bibliothek beinhaltet einige vordefinierte Templates. // Diese verwalten die Speicherbereiche für die eigenen Elemente und stellen Member-Funktionen -// für den Zugriff und die Maniplulation bereit. +// für den Zugriff und die Manipulation bereit. // Beispielhafte Container: -- cgit v1.2.3 From 6690ad941fc0545e110fe4bd19b57914adf82672 Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 9 Jan 2020 23:20:58 +0100 Subject: [bc/de-de] added translation in german for bc --- de-de/bc.html.markdown | 101 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 de-de/bc.html.markdown (limited to 'de-de') diff --git a/de-de/bc.html.markdown b/de-de/bc.html.markdown new file mode 100644 index 00000000..9aedd93b --- /dev/null +++ b/de-de/bc.html.markdown @@ -0,0 +1,101 @@ +--- +language: bc +contributors: + - ["caminsha", "https://github.com/caminsha"] +filename: learnbc-de.bc +lang: de-de +--- +```c +/* Das is ein mehr- +zeiliger Kommentar */ +# Das ist ein (einzeiliger) Kommentar (in GNU bc). + + /*1. Variablen und Kontrollstrukturen*/ +num = 45 /* Alle Variablen speichern nur Doubles und es ist + nicht möglich String-Konstanten direkt zu speichern */ +num = 45; /* Es kann nach jedem Statement ein optionales Semikolon + hinzugefügt werden */ +/* Blöcke werden mit den Operatoren {} (ähnlich wie in C) bezeichnet */ +while(num < 50) { + num += 1 /* äquivalent zu num=num+1. + a = a Op b ist äquivalent zu a Op= b*/ +} +/* Ausserdem gibt es ++ (Inkrement) und -- (Dekrement) Operatoren */ +/* Es gibt 3 spezielle Variablen: +scale: definiert die Anzahl Nachkommastellen +ibase: definiert die Basis der Eingabe +obase: definiert die Basis der Ausgabe*/ +/*Wenn-Bedingungen:*/ +hour = read() /*Eingabe einer Zahl*/ + +if(hour < 12) { /*Operatoren sind genau wie in C*/ + print "Guten Morgen\n" /*"print" outputs strings or variables + print "Guten Morgen\n" /*"print" Gibt Strings oder Variablen + mit einem Komma separiert aus.*/ +} else if(hour == 12) { + print "Hallo\n" + /* Escape-Sequenzen starten mite einem \ in einem String. + Um Escape-Sequenzen klarer zu machen, ist hier eine vereinfachte + Liste, welche in bc funktioneren.: + \b: Backspace + \c: Wagenrücklauf (carriage return) + \n: Zeilenumbruch + \t: Tab + \\: Backslash*/ +} else { + /* Standardmässig sind Variablen global. */ + thisIsGlobal = 5 + /*Variablen können lokal gemacht werden. Benutze das Schlüsselwort "auto" in einer Funktion.*/ +} + +/* Jede Variable hat als Voreinstellung den Wert 0. */ +num = blankVariable /*num wurde auf 0 gesetzt.*/ + +/*Wie in C ist nur 0 falsch.*/ +if(!num) {print "false\n"} + +/*Im Gegensatz zu C hat bc die Operatoren ?: nicht. Zum Beispiel +führt dieser Codeblok zu einem Fehler: +a = (num) ? 1 : 0 +/*Jedoch kann dies simuliert werden:*/ +a = (num) && (1) || (0) /*&& ist das UND, || ist das ODER*/ + +/*For-Schleifen*/ +num = 0 +for(i = 1; i <= 100; i++) {/*Gleich wie die For-Schleife in C*/ + num += i +} + + /*2.Funktionen und Arrays*/ +define fac(n) { /*Definiere eine Funktion mit define*/ + if(n == 1 || n == 0) { + return 1 /*Gebe einen Wert zurück*/ + } + return n * fac(n - 1) /*Rekursion ist möglich*/ +} + +/*Closures und anonyme Funktionen sind nicht möglich */ + +num = fac(4) /*24*/ + +/*Dies ist ein Beispiel von lokalen Variabeln.*/ +define x(n) { + auto x + x = 1 + return n + x +} +x(3) /*4*/ +print x /*Es stellt sich heraus, dass x ausserhalb der Funktion nicht zugänglich ist.*/ +/*Arrays sind äquivalent zu C Arrays.*/ +for(i = 0; i <= 3; i++) { + a[i] = 1 +} +/*Greife wie folgt darauf zu:*/ +print a[0], " ", a[1], " ", a[2], " ", a[3], "\n" +quit /* Füge diese Codezeile hinzu, um sicherzustellen, dass +das Programm beendet. Diese Codezeile ist optional.*/ +``` +Viel Spass mit diesem einfachen Rechner! (Oder dieser Programmiersprache, um exakt zu sein.) + +Das ganze Programm wurde in GNU bc geschrieben. Um es auszuführen, benutze ```bc learnbc.bc```. + -- cgit v1.2.3 From 3e1955bee25482f87a9649557f4a5667c4f06d11 Mon Sep 17 00:00:00 2001 From: caminsha Date: Tue, 14 Jan 2020 23:25:17 +0100 Subject: fixed some small typos in translation --- de-de/latex-de.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'de-de') diff --git a/de-de/latex-de.html.markdown b/de-de/latex-de.html.markdown index ee9c6e3e..8a952b15 100644 --- a/de-de/latex-de.html.markdown +++ b/de-de/latex-de.html.markdown @@ -39,13 +39,13 @@ filename: latex-de.tex % Dieses Kommando kann man später benutzen. \newcommand{\comment}[1]{} -% Es können durchaus noch weitere Optione für das Dokument gesetzt werden! +% Es können durchaus noch weitere Optionen für das Dokument gesetzt werden! \author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu} \date{\today} \title{Learn \LaTeX\ in Y Minutes!} % Nun kann's losgehen mit unserem Dokument. -% Alles vor dieser Zeile wird die Preamble genannt. +% Alles vor dieser Zeile wird die Präambel genannt. \begin{document} \comment{ @@ -62,7 +62,7 @@ filename: latex-de.tex % Inhalt erscheinen. % Dieser Befehl ist in den Dokumentenklassen article und report verfügbar. \begin{abstract} - \LaTeX -Documentation geschrieben in \LaTeX ! Wie ungewöhnlich und garantiert nicht meine Idee! + \LaTeX -Dokumentation geschrieben in \LaTeX ! Wie ungewöhnlich und garantiert nicht meine Idee! \end{abstract} % Section Befehle sind intuitiv. @@ -113,7 +113,7 @@ anderen Wissenschaften. Und deswegen müssen wir in der Lage sein, spezielle Symbole zu unserem Paper hinzuzufügen! \\ Mathe kennt sehr viele Symbole, viel mehr als auf einer Tastatur zu finden sind; -Symbole für Mengen und relationen, Pfeile, Operatoren und Griechische Buchstaben, +Symbole für Mengen und Relationen, Pfeile, Operatoren und Griechische Buchstaben, um nur ein paar zu nennen.\\ Mengen und Relationen spielen eine sehr wichtige Rolle in vielen mathematischen -- cgit v1.2.3 From 3c974a573bc058516ccda27f613fac68b312e67a Mon Sep 17 00:00:00 2001 From: caminsha Date: Tue, 14 Jan 2020 23:34:23 +0100 Subject: fixed some typos in german translation --- de-de/html-de.html.markdown | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'de-de') diff --git a/de-de/html-de.html.markdown b/de-de/html-de.html.markdown index 0bf58f9c..8b5597e7 100644 --- a/de-de/html-de.html.markdown +++ b/de-de/html-de.html.markdown @@ -50,10 +50,10 @@ Dieser Artikel ist bedacht darauf, nur HTML Syntax und nützliche Tipps zu geben - + - + @@ -65,13 +65,13 @@ Dieser Artikel ist bedacht darauf, nur HTML Syntax und nützliche Tipps zu geben - - + +

Hallo, Welt!

- Komm, schaue was das zeigt + Komm, schaue was das zeigt

Das ist ein Absatz.

Das ist ein anderer Absatz.

    @@ -93,12 +93,12 @@ Dieser Artikel ist bedacht darauf, nur HTML Syntax und nützliche Tipps zu geben - - + + - + -- cgit v1.2.3 From d6f4b949d57bfaaaf85e6e8bc93825a575c3ac5b Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 18 Jan 2020 00:43:12 +0100 Subject: fixed typos and grammar I have fixed some typos and comama errors in make --- de-de/make-de.html.markdown | 43 ++++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 21 deletions(-) (limited to 'de-de') diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown index cf90dc29..1bae332c 100644 --- a/de-de/make-de.html.markdown +++ b/de-de/make-de.html.markdown @@ -11,14 +11,14 @@ 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 +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 +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äftig sich -mit der Version GNU Make. Diese Version ist standard auf Linux. +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 @@ -44,14 +44,15 @@ file0.txt: # die erste Regel ist die Standard-Regel. -# Diese Regel wird nur abgearbeitet wenn file0.txt aktueller als file1.txt ist. +# 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 das Make die Abarbeitung fortsetzt auch wenn Fehler passieren. + # - 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. @@ -59,7 +60,7 @@ 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. +# 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. @@ -67,8 +68,8 @@ file2.txt file3.txt: file0.txt file1.txt # Phony-Ziele #----------------------------------------------------------------------- -# Ein Phony-Ziel ist ein Ziel das keine Datei ist. -# Es wird nie aktuell sein, daher wird Make immer versuchen es abzuarbeiten +# 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. @@ -89,14 +90,14 @@ ex0.txt ex1.txt: maker # Automatische Variablen & Wildcards #----------------------------------------------------------------------- -process: file*.txt # Eine Wildcard um Dateinamen zu Vergleichen +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 $? # Nur die Voraussetzungen, die nicht aktuell sind. @echo $+ # Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich) #@echo $| # Alle 'order only' Voraussetzungen @@ -114,20 +115,20 @@ process: ex1.txt file0.txt %.png: %.svg inkscape --export-png $^ -# Muster-Vergleichs-Regeln werden nur abgearbeitet wenn make entscheidet das Ziel zu -# erzeugen +# 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 +# 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 +# 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 @@ -171,7 +172,7 @@ name4 ?= Jean # nicht gibt. override name5 = David -# Verhindert das Kommando-Zeilen Argumente diese Variable ändern können. +# Verhindert, dass Kommando-Zeilen Argumente diese Variable ändern können. name4 +=grey # Werte an eine Variable anhängen (inkludiert Leerzeichen). @@ -179,9 +180,9 @@ name4 +=grey # 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!) + # kann, wenn es zu kompilizert wird!) -# Ein paar Variablen die von Make automatisch definiert werden. +# Ein paar Variablen, die von Make automatisch definiert werden. echo_inbuilt: echo $(CC) echo ${CXX} @@ -196,7 +197,7 @@ echo_inbuilt: # Variablen 2 #----------------------------------------------------------------------- -# Der erste Typ von Variablen wird bei jeder verwendung ausgewertet. +# 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) @@ -215,7 +216,7 @@ var4 ::= good night # Funktionen #----------------------------------------------------------------------- -# Make verfügt über eine vielzahl von Funktionen. +# Make verfügt über eine Vielzahl von Funktionen. sourcefiles = $(wildcard *.c */*.c) objectfiles = $(patsubst %.c,%.o,$(sourcefiles)) -- cgit v1.2.3 From 7d51b05c4108cac0cfb26b87b9d5ce22016df74d Mon Sep 17 00:00:00 2001 From: danielgolf Date: Sun, 19 Jan 2020 23:44:41 +0100 Subject: fixed a typo in bash de-de --- de-de/bash-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown index 3fb3e71f..3a76708a 100644 --- a/de-de/bash-de.html.markdown +++ b/de-de/bash-de.html.markdown @@ -157,7 +157,7 @@ echo "#helloworld" | cat > output.out echo "#helloworld" | tee output.out >/dev/null # Löschen der Hilfsdateien von oberhalb, mit Anzeige der Dateinamen -# (mit '-i' für "interactive" erfolgt für jede Date eine Rückfrage) +# (mit '-i' für "interactive" erfolgt für jede Datei eine Rückfrage) rm -v output.out error.err output-and-error.log # Die Ausgabe von Befehlen kann mit Hilfe von $( ) in anderen Befehlen verwendet weden: -- cgit v1.2.3 From 043e4984ffa29389e3110a8f277870642df51097 Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 30 Jan 2020 17:48:40 +0100 Subject: removed doubled line --- de-de/bc.html.markdown | 1 - 1 file changed, 1 deletion(-) (limited to 'de-de') diff --git a/de-de/bc.html.markdown b/de-de/bc.html.markdown index 9aedd93b..e1b51e4f 100644 --- a/de-de/bc.html.markdown +++ b/de-de/bc.html.markdown @@ -29,7 +29,6 @@ obase: definiert die Basis der Ausgabe*/ hour = read() /*Eingabe einer Zahl*/ if(hour < 12) { /*Operatoren sind genau wie in C*/ - print "Guten Morgen\n" /*"print" outputs strings or variables print "Guten Morgen\n" /*"print" Gibt Strings oder Variablen mit einem Komma separiert aus.*/ } else if(hour == 12) { -- cgit v1.2.3 From 42ce472cf95d60bbd1f64ed022c84362dfc3cf6f Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 30 Jan 2020 17:49:10 +0100 Subject: =?UTF-8?q?removed=20Wagenr=C3=BCcklauf=20because=20it=20is=20not?= =?UTF-8?q?=20very=20common?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- de-de/bc.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/bc.html.markdown b/de-de/bc.html.markdown index e1b51e4f..61ae1b79 100644 --- a/de-de/bc.html.markdown +++ b/de-de/bc.html.markdown @@ -37,7 +37,7 @@ if(hour < 12) { /*Operatoren sind genau wie in C*/ Um Escape-Sequenzen klarer zu machen, ist hier eine vereinfachte Liste, welche in bc funktioneren.: \b: Backspace - \c: Wagenrücklauf (carriage return) + \c: carriage return \n: Zeilenumbruch \t: Tab \\: Backslash*/ -- cgit v1.2.3 From f3f32e2d814650db6ce633a73ba99ef0c8ceaef1 Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 30 Jan 2020 17:49:48 +0100 Subject: made newlines so that the content is not more than 80 char --- de-de/bc.html.markdown | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/bc.html.markdown b/de-de/bc.html.markdown index 61ae1b79..3e04f2a7 100644 --- a/de-de/bc.html.markdown +++ b/de-de/bc.html.markdown @@ -44,7 +44,8 @@ if(hour < 12) { /*Operatoren sind genau wie in C*/ } else { /* Standardmässig sind Variablen global. */ thisIsGlobal = 5 - /*Variablen können lokal gemacht werden. Benutze das Schlüsselwort "auto" in einer Funktion.*/ + /*Variablen können lokal gemacht werden. Benutze das Schlüsselwort "auto" + in einer Funktion.*/ } /* Jede Variable hat als Voreinstellung den Wert 0. */ @@ -84,7 +85,8 @@ define x(n) { return n + x } x(3) /*4*/ -print x /*Es stellt sich heraus, dass x ausserhalb der Funktion nicht zugänglich ist.*/ +print x /*Es stellt sich heraus, dass x ausserhalb der Funktion nicht + zugänglich ist.*/ /*Arrays sind äquivalent zu C Arrays.*/ for(i = 0; i <= 3; i++) { a[i] = 1 -- cgit v1.2.3 From de19c7fbe18a1307a1ebcea02d683366c231b133 Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 30 Jan 2020 17:50:09 +0100 Subject: added ternary operator --- de-de/bc.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/bc.html.markdown b/de-de/bc.html.markdown index 3e04f2a7..49a2878d 100644 --- a/de-de/bc.html.markdown +++ b/de-de/bc.html.markdown @@ -54,10 +54,10 @@ num = blankVariable /*num wurde auf 0 gesetzt.*/ /*Wie in C ist nur 0 falsch.*/ if(!num) {print "false\n"} -/*Im Gegensatz zu C hat bc die Operatoren ?: nicht. Zum Beispiel +/*Im Gegensatz zu C hat bc den Ternäroperator ?: nicht. Zum Beispiel führt dieser Codeblok zu einem Fehler: a = (num) ? 1 : 0 -/*Jedoch kann dies simuliert werden:*/ +Jedoch kann dies simuliert werden:*/ a = (num) && (1) || (0) /*&& ist das UND, || ist das ODER*/ /*For-Schleifen*/ -- cgit v1.2.3 From 066e454654135e9fd375d522745fa4978920391a Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 30 Jan 2020 19:12:07 +0100 Subject: Started german translation in C --- de-de/c-de.html.markdown | 83 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 de-de/c-de.html.markdown (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown new file mode 100644 index 00000000..242e51e1 --- /dev/null +++ b/de-de/c-de.html.markdown @@ -0,0 +1,83 @@ +--- +language: c +filename: learnc.c +contributors: + - ["caminsha", "https://github.com/caminsha"] +lang: de-de +--- + +Ach, C. Immer noch **die** Sprache für modernes High-Performance Computing. + +C ist wahrscheinlich die niedrigste Programmiersprache, welche die meisten +Programmierer je brauchen werden. Die Geschwindigkeit von C ist enorm, allerdings +muss man sich stets der maneullen Speicherverwaltung bewusst sein. + + +> **Über Compiler Flags** +> +> Standardmässig sind `gcc` und `clang` ziemlich ruhig bezüglich Warnungen und +> Fehlern, obwohl dies sehr nützliche Informationen sein können. Es wird +> empfohlen, strengere Compiler Flags zu verwenden. Hier sind einige empfohlene +> Standards: +> `-Wall -Wextra -Werror -O2 -std=c99 -pedantic` +> +> Für weitere Informationen, was diese und weitere Optionen genau machen, +> sollte die Man-Page des C-Compilers aufgerufen werden (z.B. `man 1 gcc`). +> Alternativ kann auch online nach den unterschiedlichen Optionen gesucht werden. + +```c +// einzeilige Kommentare starten mit // - nur in C99 und später vorhanden. + +/* +mehrzeilige Kommentare sehen so aus. Diese funktionieren auch in C89 +*/ + +/* +mehrzeilige Kommentare können nicht verschaltelt werden /* Sei Vorsichtig! */ // Kommentar endet auf dieser Linie ... +*/ // ... nicht bei dieser! + +// Konstanten: #define +// Konstanten werden laut der Konvention immer in GROSSBUCHSTABEN geschrieben +#define TAGE_IM_JAHR 365 + +// Konstanten können auch als Aufzählungskonstanten (Enums) definiert werden. +// Alle Anweisungen müssen mit einem Semikolon beendet werden. +enum tage {SO=1, MO, DI, MI, DO, FR, SA}; +// MO wird automatisch zu 2, DI zu 3 etc. + +// Importiere Header-Dateien mit #include +#include +#include +#include + +// Dateien, welche zwischen stehen, sind Header-Dateien aus +// der C-Standard-Bibliothek. +// Für deine eigenen Header müssen Anführungszeichen verwendet werden, z.B.: +// #include "mein_header.h" + +// Funktionssignaturen werden entweder vorher in einer .h-Datei deklariert oder +// am Anfang der .c-Datei. +void funktion_1(); +int funktion_2(void); + +// Es muss ein Funktionsprototyp deklariert werden vor der `main()` Funktion, +// wenn die Funktion nach der `main()` Funktion gebraucht wird. +int addiere_zwei_integer(int x1, int x2); // Funktionsprototyp +// Auch wenn der Ausdrck `int addiere_zwei_integer(int, int)` auch valid wäre, +// ist es empfohlen, dass man die Namen der Argumente hinschreibt für eine +// einfachere Analyse. + +// Der Einstiegspunkt deines Programms ist eine Funktion mit dem Namen main und +// einem Integer als Rückgabewert. +int main(void){ + // dein Programm +} + +// Die Kommandozeilenargumente, welche gebraucht werden, damit dein Programm läuft, +// werden als Argumente der `main`-Funktion mitgegeben. +// argc steht für die Anzahl von Argumenten. - Der Programmname ist das erste Argument. +// argv ist ein Array von Zeichenarrays, welche die Argumente beinhaltet. +// argv[0] = Name des Programms +// argv[1] = erstes Argument usw. +int main (int argc, char** argv){ +} -- cgit v1.2.3 From b4e6dc73c1dcb5dfd4aa53a31fa666a537492a73 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 00:00:39 +0100 Subject: Continued with german translation of C --- de-de/c-de.html.markdown | 72 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 242e51e1..777bba11 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -80,4 +80,76 @@ int main(void){ // argv[0] = Name des Programms // argv[1] = erstes Argument usw. int main (int argc, char** argv){ + // Ausgabe mit Hilfe von printf (print formatted) + // %d ist ein Integer. + // \n steht für eine neue Zeile + printf("%d\n",0); // => Gibt 0 aus. + + //////////////////////////////////////////////// + // Typen + //////////////////////////////////////////////// + + // Alle Variable müssen am Anfang des jetzigen Blocks deklariert werden. + // Wir deklarieren die Variablen dynamisch im Code um die Lesbarkeit im + // Tutorial zu verbessern. + // C99-Konforme Compiler erlauben die Variablendeklaration an dem Punkt, an + // welchem die Variable verwendet wird. + + // integer sind normalerweise 4 Bytes gross + int x_int = 0; + + // shorts sind normalerweise 2 Bytes gross + short x_short = 0; + + // chars sind garantiert 1 Byte gross + char x_char = 0; + char y_char = 'y'; // Charakterliterale werden mit '' gekennzeichnet. + + // longs sind oft 4 bis 8 Bytes gross. long long sind garantiert mindestens + // 8 Bytes gross. + long x_long = 0; + long long x_long_long = 0; + + // floats sind normalerweise 32-Bit Gleitkommazahlen + float x_float = 0.0f; // 'f'-Suffix beschreibt eine Gleitkommazahl. + + // doubles sind normalerweise 64-Bit Gleitkommazahlen + double x_double = 0.0; // echte Zahlen ohne Suffix sind vom Typ double + + // integer-Typen können vorzeichenlos (unsigned) sein (grösser oder kleiner als 0) + unsigned short ux_short; + unsigned int ux_int; + unsigned long long ux_long_long; + + // chars innerhalb von einfachen Anführungszeichen sind Integers im + // Maschinenzeichensatz + '0'; // => 48 im ASCII-Zeichensatz + 'A'; // => 65 im ASCII-Zeichensatz + + // sizeof(T) gibt die Grösse einer Variablen des Typen T in Bytes zurück. + // sizeof(obj) ergibt die Grösse des Ausdrucks (Variable, Literal usw.) + + printf("%zu\n", sizeof(int)); // => 4 (auf den meisten Rechnern mit einem 4-Byte-Wort) + + // Wenn das Argument des `sizeof`-Operator ein Ausdruck ist, dann wird das + // Argument nicht ausgewertet (ausser Arrays mit variabler Länge) + // Der Wert, der in diesem Fall zurückgegeben wird, ist eine Konstante zur + // Kompillierzeit. + + int a = 1; + //size_t ist ein vorzeichenloser Integer Typ mit mindestens 2 Byte um die + // Grösse eines Objekts zu repräsentieren. + size_t size = sizeof(a++); // a++ wird nicht ausgewertet + printf("sizeof(a++) = %zu, wobei a=%d ist\n", size, a); + // Gibt "sizeof(a++) = 4, wobei a=1 ist" aus (mit einer 32-Bit-Architektur) + + // Arrays müssen mit einer Grösse initialisiert werden. + char my_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes + int my_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. + // unter der Voraussetzung eines 4-Byte-Worts. + + // Ein Array kann auf diese Weise mit 0 initialisiert werden. + char my_array[20] = {0}; + // Hierbei ist der Teil "{0}" der "Array Initialisierer". + } -- cgit v1.2.3 From ea00cc1fdac7acded85b8aad0eb2ac5e09b8e5d7 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 01:11:48 +0100 Subject: translated operators to german --- de-de/c-de.html.markdown | 141 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 138 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 777bba11..69576da0 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -144,12 +144,147 @@ int main (int argc, char** argv){ // Gibt "sizeof(a++) = 4, wobei a=1 ist" aus (mit einer 32-Bit-Architektur) // Arrays müssen mit einer Grösse initialisiert werden. - char my_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes - int my_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. + char mein_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes + int mein_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. // unter der Voraussetzung eines 4-Byte-Worts. // Ein Array kann auf diese Weise mit 0 initialisiert werden. - char my_array[20] = {0}; + char mein_array[20] = {0}; // Hierbei ist der Teil "{0}" der "Array Initialisierer". + // Beachte, dass die Länge des Arrays nicht explizit definiert werden muss, + // wenn er auf derselben Linie initialisiert wird. + // Folgende Deklaration ist gleichwertig: + char mein_array[] = {0}; + // Allerdings muss die Länge des Arrays dann zur Laufzeit ausgewertet werden: + size_t mein_array_size = sizeof(mein_array) / sizeof(mein_array[0]); + // WARNUNG: Wenn dieser Ansatz gewählt wird, muss man sicherstellen, dass die + // Grösse des Arrays ermittelt werden *bevor* dieser einer Funktion als + // Argument weitergegeben wird (siehe Diskussion weiter unten), weil Arrays + // einer Funktion nur als Zeiger übergeben werden. => Das obere Statement + // würde innerhalb einer Funktion ein falsches Resultat liefern. + + // Das Indexieren eines Arrays funktioniert wie in anderen Sprache - resp. + // in anderen Sprachen funktioniert es gleich wie in C. + mein_array[0]; // => 0 + + // Arrays sind veränderbar; es ist nur Arbeitsspeicher! + mein_array[1] = 2; + printf("%d\n", mein_array[1]); // => 2 + + // In C99 (und als optionales Feature in C11) können Arrays mit variabler + // Länge deklariert werden. Die Grösse eines solchen Array muss eine Konstante + // zur Kompilierzeit sein. + printf("Geben Sie die Arraygrösse an: "); //Frag den Benutzer nach der Arraygrösse + int array_size; + fcsanf(stdin, "%d", &array_size); + int var_length_array[array_size]; // deklariere Array mit variabler Länge + printf("sizeof array =%zu\n", sizeof var_length_array); + + // Zum Beispiel: + // > Geben Sie die Arraygrösse an: 10 + // > sizeof array = 40 + + // Strings sind lediglich Arrays von `chars`, welche mit einem Null-Byte + // (0x00) beendet werden. In Strings wird das Nullbyte durch das Zeichen \0 + // repräsentiert. Wir müssen das Null-Byte nicht angeben in String-Literalen; + // Der Compiler fügt es am Ende des Array automatisch hinzu. + char ein_string[20] = "Das ist ein String"; + printf("%s\n", ein_string); // %s formattiert einen String + + printf("%d\n", ein_string[18]); // => 0 + // Hier ist das Byte #19 0 (wie auch Byte #20) + + // Wenn wir Zeichen zwischen einfachen Anführungszeichen haben, ist es ein + // Zeichenliteral vom Typ int und *nicht* char. (aus historischen Gründen) + int cha = 'a'; // Ok + char chb = 'a'; // auch ok (implizite Umwandlung von int zu char) + + // Mehrdimensionale Arrays: + int multi_array[2][5] = { + {1,2,3,4,5}, + {6,7,8,9,0} + }; + // Auf Elemente zugreifen: + int array_int = multi_array[0][2]; // => 3 + //////////////////////////////////////////////// + // Operatoren + //////////////////////////////////////////////// + + // Kurzschreibweise für mehrere Deklarationen + int i1 = 1, i2 = 2; + flaot f1 = 1.0, f2 = 2.0; + + int b,c; + b = c = 0; + + // Arithmetik ist unkompliziert + i1 + i2; // => 3 + i2 - i1; // => 1 + i2 * i1; // => 2 + i1 / i2; // 0 (0.5, aber abgeschnitten, da es int sind. + + // Man muss mindestens ein Integer to einen float konvertieren, damit man als + // Resultat eine Gleitkommazahl erhält. + (float)i1 / i2; // => 0.5f + i1 / (double)i2; // => 0.5 // das gleiche mit dem Typ `double` + f1 / f2; // => 0.5, plus oder minus Epsilon + // Gleitkommazahlen und deren Berechnungen sind nicht exakt. + + // Es gibt auch die Möglichkeit, Modulo zu rechnen + 11 % 3; // => 2 + + // Vergleichsoperatoren sind vielleicht schon bekannt, aber in C gibt es keinen + // Boolean-Typ. In C verwenden wir `int`. (Oder _Bool oder bool in C99.) + // 0 ist falsch, alles andere ist wahr (Die Vergleichsoperatoren ergeben + // immer 1 oder 0. + 3 == 2; // => 0 (falsch) + 3 != 2; // => 1 (wahr) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // C ist nicht Python - Vergleiche können nicht verkettet werden. + // Warnung: die folgende Zeile wird kompilieren, aber es bedeutet `(0 < a) < 2`. + // Dieser Ausdruck ist immer wahr, weil (0 < a) kann entweder 1 oder 0 sein. + // In diesem Falle ist es 1, weil (0 < 1). + int zwischen_0_und_2 = 0 < a < 2; + // Benutze stattdessen folgende Schreibweise: + int zwischen_0_und_2 = 0 < a && a < 2; + + // Logik funktioniert auch mit ints + !3; // => 0 (logisches Nicht) + !0; // => 1 + 1 && 1; // => 1 (logisches Und) + 0 && 1; // => 0 + 0 || 1; // => 1 (logisches Oder) + 0 || 0; // => 0 + + // Bedingter ternärer Ausdruck ( ? : ) + int e = 5; + int f = 10; + int z; + z = ( e > f) ? e : f; // => // => 10 "wenn e > f ist, gib e zurück, sonst f." + + // Inkrementierungs- und Dekrementierungsoperatoren + int j = 0; + int s = j++; // gib j zurück und erhöhe danach j. (s = 0, j = 1) + s = ++j; // erhöhe zuerst j und gib dann j zurück (s = 2, j = 2) + // das gleiche gilt für j-- und --j + + // Bitweise Operatoren + ~0x0F; // => 0xFFFFFFF0 (Bitweise Negation, "Einer-Komplement", Beispielresultat für 32-Bit int) + 0x0F & 0xF0; // => 0x00 (Bitweises UND) + 0x0F | 0xF0; // => 0xFF (Bitweises ODER) + 0x04 ^ 0x0F; // => 0x0B (Bitweises XOR) + 0x01 << 1; // => 0x02 (Bitweises Linksshift (left shift) (um 1)) + 0x02 >> 1; // => 0x01 (Bitweises Rechtsshift (right shift) (um 1)) + + // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern - folgende Ausdrücke sind nicht definiert: + // - Verschiebung in das Vorzeichenbit (int a = 1 << 31) + // - Linksshift einer negativen Zahl (int a = -1 << 2) + // - Shift um einen Offset, welcher >= die Breite des linken Ausdrucks ist. + // int a = 1 << 32; // undefiniertes Verhalten, wenn int 32-Bit ist. + } -- cgit v1.2.3 From dcf628e2866634bee9e9e04ecbb336885adaf7e4 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 01:42:28 +0100 Subject: translated control structures to German --- de-de/c-de.html.markdown | 85 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 69576da0..b027cdbe 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -287,4 +287,89 @@ int main (int argc, char** argv){ // - Shift um einen Offset, welcher >= die Breite des linken Ausdrucks ist. // int a = 1 << 32; // undefiniertes Verhalten, wenn int 32-Bit ist. + //////////////////////////////////////////////// + // Kontrollstrukturen + //////////////////////////////////////////////// + if (0) { + printf("Ich werde nie ausgeführt."); + } + else if (0){ + printf("Ich werde auch nie ausgeführt."); + } + else { + printf("Ich gebe etwas aus."); + } + + // While-Schleifen existieren auch + int ii = 0; + while (ii < 10){ // JEDER Wert unter zehn ist wahr + printf("%d, " ii++); //i++ inkrementiert ii NACHDEM der Wert gebraucht wurde. + } // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + int kk = 0; + do { + printf("%d, ", kk); + } while(++kk < 10); //++kk inkrementiert kk BEVOR der Wert gebraucht wurde. + // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // In C gibt es auch for-Schleifen + int jj; + for (jj = 0; jj < 10; jj++){ + printf("%d, ", jj); + } // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // **Merke** + // Schleifen und Funktionen müssen einen Body haben. Wenn kein Body gebraucht + // wird, kann folgendes gemacht werden: + int i; + for (i = 0; i <= 5; i++){ + ; // Semikolon wird als Body behandelt (Null-Anweisung) + } + // Alternativ kann auch folgendes geschrieben werden: + for (i = 0; i <= 5; i++); + + // Verzweigungen mit mehreren Möglichkeiten: `switch()` + switch (a){ + case 0: //labels müssen integrale *konstante* Ausdrücke sein (z.B. Enums) + printf("Hey, 'a' ist gleich 0!\n"); + break; //Wenn du kein break einsetzt, so geht der Kontrollfluss durch die Labels + case 1: + printf("Huh, 'a' ist gleich 1!\n"); + break; + // Sei vorsichtig - wenn man das `break` vergisst, werden alle Anweisungen + // ausgeführt bis das nächste `break` erscheint. + case 3: + case 4: + printf("Schau mal ... 'a' ist entweder 3 oder 4.\n"); + break; + default: + // wenn der Ausdruck `a` auf kein Label zutrifft. + fputs("Fehler!\n", stderr); + exit(-1); + break; + } + + // Verwendung von "goto" in C + typedef enum { false, true } bool; + bool desaster = false; + int i, j; + for(i=0; i < 100; ++i){ + for (j=0; j < 100; ++j){ + if ((i + j ) >= 150){ + desaster = true; + } + if (desaster){ + goto error; + } + } + } +error: + printf("Ein Fehler ist aufgetreten bei i = %d & j ? %d\n", i, j); + } -- cgit v1.2.3 From a53f355f9ffa02e4b87f1769bb48b2cb2b40ea2f Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 01:47:49 +0100 Subject: added translation for type casting --- de-de/c-de.html.markdown | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index b027cdbe..1b97faaf 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -372,4 +372,31 @@ int main (int argc, char** argv){ error: printf("Ein Fehler ist aufgetreten bei i = %d & j ? %d\n", i, j); + //////////////////////////////////////////////// + // Typenumwandlung + //////////////////////////////////////////////// + + // Jeder Wert in C hat einen bestimmten Typen, aber es ist möglich, ein + // Wert in einen anderen Typ umzuwandeln (mit einigen Einschränkungen). + + int x_hex = 0x01; // Es ist möglich, Variablen Hexadezimalwerten zuzuweisen. + + // Bei der Umwandlung zwischen Typen wird versucht, den numerischen Wert + // beizubehalten. + printf("%d\n", x_hex); // => 1 + printf("%d\n", (short) x_hex); // => 1 + printf("%d\n", (char) x_hex); // => 1 + + // Typen werden überlaufen (overflow) ohne jegliche Warnung + printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 wenn char 8 Bit lang ist) + + // Um den maximalen Wert eines `char`, `signed char` oder `unsigned char` + // herauszufinden, können die Makros `CHAR_MAX`, `SCHAR_MAX` und `UCHAR_MAX` + // aus der Header-Datei `` verwendet werden. + + // Integer-Typen können zu Gleitkommazahlen und umgekehrt umgewandelt werden. + printf("%f\n", (double) 100); // %f formattiert immer zu einem `double`... + printf("%f\n", (flaot) 100); // ... auch mit einem `float` + printf("%d\n", (char)100.0); + } -- cgit v1.2.3 From 09a4d598ae157d2d007db1740c6b811a11c84367 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 03:16:16 +0100 Subject: translated section pointers to german --- de-de/c-de.html.markdown | 132 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 131 insertions(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 1b97faaf..c9e01181 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -399,4 +399,134 @@ error: printf("%f\n", (flaot) 100); // ... auch mit einem `float` printf("%d\n", (char)100.0); -} + //////////////////////////////////////////////// + // Zeiger (aka Pointer) + //////////////////////////////////////////////// + + // In diesem Tutorial wird das deutsche Wort Zeiger nicht verwendet, da es + // bei einer weiteren Recherche einfacher ist, wenn man von Pointern ausgeht. + // Ausserdem ist der Begriff Pointer auf im deutschen Sprachgebrauch zu finden. + + // Ein Pointer ist eine Variable, welche deklariert wurde, um eine Speicher- + // Adresse zu speichern. Die Deklaration eines Pointers wird auch zeigen, + // auf welche Art von Daten der Pointer zeigt. Man kann die Speicheradresse + // von Variablen abrufen und dann mit diesen herumspielen. + + int x = 0; + printf("%p\n", (void *)&x); // verwende & um die Adresse der Variable zu erhalten + // %p formattiert einen Objektpointer des Typen void*) + // => Gibt eine Adresse im Speicher aus + + // Pointer starten mit einem * zu Beginn der Deklaration. + int *px, kein_pointer; // px ist ein Pointer zu einem int. + px = &x; // Speichert die Adresse von x in px + printf("%p\n", (void *)px); // => Gibt eine Adresse im Speicher aus + printf("%zu, %zu\n", sizeof(px), sizeof(kein_pointer)); + // Gibt auf einem typischen 64-Bit-System folgendes aus: "8, 4" + + // Um den Wert einer Adresse, auf welche ein Pointer zeigt, herauszufinden, + // muss man vor die Variable ein * setzen, um sie zu dereferenzieren. + // Notiz: Ja, es kann verwirrend sein, dass '*' sowohl für das Deklarieren + // als auch das Derefenzieren verwendet werden kann. + printf("%d\n", *px); // => 0, der Wert von x + + // Man kann den Wert, auf welchen ein Pointer zeigt, auch verändern. + // Man muss die Dereferenzierung in Klammern setzen, weil ++ eine höhere + // Priorität als * hat. + (*px)++; // Inkrementiere den Wert, auf welchen px zeigt, um 1 + printf("%d\n", *px); // => 1 + printf("%d\n", x); // => 1 + + // Arrays sind eine gute Möglichekit, einen zusammenhängenden Block von + // Speicher zu allozieren. + int x_array[20]; // deklariert einen Array der Grösse 20 (Grösse kann + // nicht geändert werden.) + int xx; + for (xx =0; xx < 20; xx++){ + x_array[xx] 20 -xx; + } // Initialisiere x_array zu 20, 19, 18, ... 2, 1 + + // Deklariere ein Pointer des Typs int und initalisiere ihn, um auf `x_array` + // zu zeigen. + int *x_ptr = x_array; + // x_ptr zeigt jetzt auf den ersten Wert innerhalb des Arrays (int 20) + // Das funktioniert, weil Arrays oft zu Pointern reduziert werden, welche + // auf das erste Element zeigen. + // Zum Beispiel: Wenn ein Array einer Funktion mitgegeben wird oder einem + // Pointer zugewiesen wird, wird es zu einem Pointer reduziert (implizites Casting) + // Ausnahme: Wenn das Array das Argument des Operators `&` ist. + int arr[10]; + int (*ptr_zu_arr)[10] = &arr; //`&arr` ist nicht vom Typ `int *`! + // Es ist vom Typem "Pointer auf Array" (aus zehn `int`s) + // oder wenn das Array ein Stringliteral ist, welches gebraucht wird um ein + // `char`-Array zu initialisieren. + char anderer_arr[] = "foobarbazquirk"; + // oder wenn es das Argument des des `sizeof` oder `alignof` Operators ist. + int dritter_array[10]; + int *ptr = dritter_array; // gleich wie: `int *ptr = &arr[0]` + printf("%zu, %zu\n", sizeof(dritter_array), sizeof(ptr)); + // Gibt wahrscheinlich "40, 4" oder "40, 8" aus + + // Pointer werden basierend auf dem Typ in- und dekrementiert + // Dies wird Pointer-Arithmetik genannt. + printf("%d\n", *(x_ptr + 1)); // => 19 + printf("%d\n", x_array[1]); // => 19 + + // Man kann zusammenhängende Speicherblöcke auch mit der Funktion `malloc` + // aus der Standardbibliothek dynamisch allozieren. Der Funktion `malloc` + // muss ein Argument des Typs `size_t` übergeben werden, welches bestimmt, + // wie viele Bytes alloziert werden sollen. (Normalerweise geschieht dies + // aus dem Heap - dies kann auf eingebetteten Systemen unterschiedlichen sein. + // Der C Standard sagt nichts darüber.) + int *mein_ptr = malloc(sizeof(*mein_ptr) * 20); + for (xx = 0; xx < 20; xx++){ + *(mein_ptr + xx) = 20 -xx; //mein_ptr[xx] = 20-xx + } // initialisiere Speicher zu 20, 19, 18, 17, ... 2, 1 (als `int`) + + // Sei vorsichtig beim Übergeben von Benutzerdefinierten Werten an `malloc`. + // Wenn du sicher sein willst, kannst du die Funktion `calloc` nutzen, welche + // (nicht wie `malloc`) auch den Speicher nullt. + int *mein_anderer_ptr = calloc(20, sizeof(int)); + + // Merke, dass es in C keinen Standard-Weg gibt, um die Länge eines dynamisch + // allozierten Arrays zu bestimmen. Auf Grund dessen sollte eine Variable + // erstellt werden, welche sich die Anzahl der Elemente im Array merkt, wenn + // die Arrays mehrmals im Programm gebraucht werden. + // Weitere Informationen stehen im Abschnitt Funktionen. + size_t groesse = 10; + int *mein_array = calloc(groesse, sizeof(int)); + // Füge dem Array ein Element hinzu + groesse++; + mein_array = realloc(mein_array, sizeof(int) *groesse); + if (mein_array == NULL){ + // Denke daran, realloc-Fehler zu prüfen + return + } + mein_array[10] = 5; + + // Das Dereferenzieren von nicht alloziertem Speicher führt zu einem + // Undefinierten Verhalten. + printf("%d\n", *(mein_ptr + 21)); // Gibt irgendwas aus. Das Programm kann auch abstürzen + + // Nachdem du fertig mit einem Block bist, welcher `malloc` verwendet hat, + // muss der Speicher befreit werden. Ansonsten kann dieser Speicherbereich + // niemand nutzen bis dein Programm beendet wird. + // Dies wird auch als "Speicherleck" (engl: memory leak) bezeichnet. + free(mein_ptr); + + // Obwohl Strings normalerweise als Pointer-to-Char (Pointer zum ersten + // Zeichen des Arrays) repräsentiert werden, sind Strings sind Arrays aus `char`s. + // Es ist eine gute Praxis, `const char *` zu verwenden, wenn man ein + // String-Literal referenziert, da String-Literale nicht modifiziert werden + // sollten (z.B. "foo"[0] = 'a' ist ILLEGAL) + const char *mein_str = "Das ist mein eigener String"; + printf("%c\n", *mein_str); // => D + + // Dies ist nicht der Fall, wenn der String ein Array (möglicherweise mit + // einem String-Literal initialisiert) ist, welcher im beschreibbaren Speicher + // bleibt, wie zum Beispiel in: + char foo[] = "foo"; + foo[0] = 'a'; // Dies ist legal, foo enthält jetzt "aoo" + + funktion_1(); +} // Ende der `main`-Funktion -- cgit v1.2.3 From e08467e87257b718ec687e8d58d72172d660f070 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 03:41:40 +0100 Subject: Fixed some small typos --- de-de/css-de.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/css-de.html.markdown b/de-de/css-de.html.markdown index c31e73d2..da706e91 100644 --- a/de-de/css-de.html.markdown +++ b/de-de/css-de.html.markdown @@ -27,7 +27,7 @@ In diesem Artikel wird am meisten auf generelle Hinweise und die Syntax geachtet ####################*/ /* Eigentlich ist das grundlegende CSS-Statement sehr simpel */ -selektor { eigenschaft: wert; /* mehr eigenschaften...*/ } +selektor { eigenschaft: wert; /* mehr Eigenschaften...*/ } /* Der Selektor wird dazu benutzt, ein Element auf der Seite auszuwählen. @@ -35,7 +35,7 @@ Man kann aber auch alle Elemente auf einer Seite auswählen! */ * { color:red; } /* farbe:rot */ /* -Angenommen wir haben folgendes Element auf einer Seite: +Angenommen, wir haben folgendes Element auf einer Seite:
    */ @@ -170,7 +170,7 @@ empfohlen ist --> ## Spezifität Ein Element kann natürlich auch von mehr als einer Regel in einem Stylesheet -angesprochen werdenm und kann eine Eigenschaft auch öfters als einmal zugewiesen +angesprochen werden und kann eine Eigenschaft auch öfters als einmal zugewiesen bekommen. In diesen Fällen gibt es Regeln, die die Spezifität von Selektoren regeln. Wir haben dieses CSS: -- cgit v1.2.3 From b8d10209a6d645b63a64593debf047566284392e Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 04:30:57 +0100 Subject: added german translation to function in c --- de-de/c-de.html.markdown | 100 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index c9e01181..20aade8d 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -530,3 +530,103 @@ error: funktion_1(); } // Ende der `main`-Funktion + +//////////////////////////////////////////////// +// Funktionen +//////////////////////////////////////////////// + +// Syntax einer Funktionsdeklaration +// () + +int addiere_zwei_integer(int x1, int x2){ + return x1 + x2; // verwendet return, um einen Wert zurückzugeben +} + +/* + * Funktionen werden auf Grund des Wertes aufgerufen (call-by-value). Wenn eine + * Funktion aufgerufen wird, sind die Argumente Kopien der ursprüunglichen Werte + * (ausgenommen Arrays). Alles, was man innerhalb einer Funktion mit den Werten + * macht, hat keinen Einfluss auf die Originalwerte als die Funktion aufgerufen + * wurde + + * Verwende Pointer, um den Originalinhalt zu bearbeiten. + + * Beispiel: +*/ + +// Eine `void`-Funktion gibt keinen Wert zurück +void str_reverse(char *str_in){ + char tmp; + size_t ii = 0; + size_t laenge = strlen(str_in); + // `strlen()` ist ein Teil der C Standard-Bibliothek. + // Merke: Die Länge, welche von `strlen` zurückgegeben wird, ist ohne den + // Null-Byter Terminatur. + for (ii = 0; i < laenge /2; ii++){ // in C99 kann man `ii` direkt hier deklarieren. + tmp = str_in[ii]; + str_in[ii] = str_in[laenge - ii - 1]; //#ii'tes Zeichen vom Ende her + str_in[laenge - ii- 1] = tmp; + } +} +// Merke: Die `string.h`-Headerdatei muss inkludiert werden, bevor `strlen()` +// verwendet werden kann. + +/* + * char c[] = "Das ist ein Test"; + * str_reverse(c); + * printf("%s\n", c), => "tseT nie tsi saD" +*/ + +// Weil wir lediglich eine Variable zurückgeben können, kann zum Ändern mehrerer +// Variablen das Konzept call-by-reference verwendet werden. +void tausche_zwei_zahlen(int *a, int *b){ + int temp = *a; + *a = *b; + *b = temp; +} +int erste_zahl = 10; +int zweite_zahl = 20; +printf("Erste Zahl: %d\n Zweite Zahl: %d\n", erste_zahl, zweite_zahl); +tausche_zwei_zahlen(&erste_zahl, &zweite_zahl); +printf("Erste Zahl: %d\n Zweite Zahl: %d\n", erste_zahl, zweite_zahl); +// Werte sind vertauscht. + +/* +Wenn man Arrays betrachtet, so werden diese immer als Pointer übergeben. Auch +wenn die Arrays statisch alloziert werden (wie zum Beispiel `arr[10]`), werden +diese als Pointer zum ersten Element des Arrays übergeben. +Auch hier soll noch einmal erwähnt werden, dass keinen Standard gibt, wie die +Grösse eines dynamischen Arrays herausgefunden werden kann. +*/ +// Die Grösse des Arrays muss unbedingt mitgegeben werden. +// Sonst hat die Funktion keine Ahnung wie gross das Array ist. +void ausgabe_int_array(int *arr, size_t size){ + int i; + for (i = 0; i < size; i++){ + printf("arr[%d] ist %d\n", i, arr[i]); + } +} + +int mein_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; +int groesse = 10; +ausgabe_int_array(mein_array, groesse); +// Wird folgendes ausgeben: "arr[0] ist 1" usw. + +// Wenn man auf externe Variable (ausserhalb der Funktion) referenziert, sollte +// man das Schlüsselwort `extern` verwenden. +int i = 0; +void test_funktion(){ + extern int i; //i braucht nun die externe Variable i +} + +// Das Schlüsselwort `static` macht, dass eine Variable ausserhalb der Kompilier- +// einheit nicht zugreifbar ist. (Auf den meisten Systemen ist eine Kompiliereinheit +// eine `.c`-Datei.) Das Schlüsselwort `static` kann sowohl global (zur Kompiliereinheit gehörende) +// Variablen, Funktionen und Funktionslokale Variablen angewendet werden. +// Wenn man `static` bei lokalen Variablen verwendet, so ist diese Variable global +// erreichbar und behält dessen Wert über Funktionsaufrufe hinweg, aber sie ist +// nur innerhalb der deklarierten Funktion verfügbar. Ausserdem werden statische +// Variablen mit 0 initialisiert, wenn sie nicht mit einem anderen Startwert +// initialisiert werden. +// Es ist auch möglich, Funktionen als statisch zu deklarieren, damit diese +// `private` sind. Private heisst, dass sie nur in diesem Kontekt sichtbar sind. -- cgit v1.2.3 From a0d2ed81aebd48f60135c554a959d8ad7a47984b Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 05:14:28 +0100 Subject: added user defined types and structs --- de-de/c-de.html.markdown | 53 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 20aade8d..509e08fa 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -630,3 +630,56 @@ void test_funktion(){ // initialisiert werden. // Es ist auch möglich, Funktionen als statisch zu deklarieren, damit diese // `private` sind. Private heisst, dass sie nur in diesem Kontekt sichtbar sind. + + +//////////////////////////////////////////////// +// Benutzerdefinierte Typen und Strukturen (Structs) +//////////////////////////////////////////////// + +// `typdef`s können verwendet werden, um Typenaliase zu erstellen. +typedef int mein_typ; +mein_typ meine_typ_var = 0; + +// Structs sind lediglich Sammlungen von Daten, die Inhalte werden +// (in der Reihenfolge wie sie geschrieben wurden) sequentiell alloziert. +struct rechteck{ + int breite; + int hoehe; +}; + +// Allgemein ist es nicht so, dass folgender Ausdruck wahr ist. +// sizeof(struct rechteck) == sizeof(int) + sizeof(int) +// Dies ist so, weil potentiell ein Padding zwischen den Struktur-Inhalten +// möglich ist). siehe [1] + +void funktion_1(){ + struct rechteck mein_rechteck; + + // Greife auf Struct-Inhalte mit `.` zu. + mein_rechteck.breite = 10; + mein_rechteck.hoehe = 20; + + // Du kannst Pointer zu Structs deklarieren. + struct rechteck *mein_rechteck_ptr = &mein_rechteck; + + // Verwende Dereferenzierung, um Struct-Inhalte zu bearbeiten + (*mein_rechteck_ptr).breite = 30; + + //Noch besser: Verwende die Kurzschreibweise ->, um die Lesbarkeit zu verbessern. + mein_rechteck_ptr->hoehe = 10; // Das gleiche wie: (*mein_rechteck_ptr).hoehe = 10; +} + +// Aus Bequemlichkeitsgründen ist es möglich einem `struct` ein `typedef`hinzuzufügen. +typedef struct rechteck recht; + +int flaeche(recht r){ + return r.breite * r.hoehe; +} + +// Wenn du grosse Structs hast, kannst du diese mit dem Pointer kopieren, +// damit grosse Kopiervorgänge vermieden werden. +int flaecheptr(const recht *r){ + return r->breite * r->hoehe; +} + +[1] [Why isn't sizeof for a struct equal to the sum of sizeof of each member?](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member) -- cgit v1.2.3 From 38d3c33507d0d91103a8b1c7df9593e22938d960 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 31 Jan 2020 05:15:23 +0100 Subject: translated section of function pointers to German --- de-de/c-de.html.markdown | 72 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 509e08fa..946d8329 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -682,4 +682,76 @@ int flaecheptr(const recht *r){ return r->breite * r->hoehe; } +//////////////////////////////////////////////// +// Funktionspointer +//////////////////////////////////////////////// + +/* +Zur Laufzeit sind Funktionen in einer Speicheradresse gespeichert. +Funktionspointer sind wie normale Pointer (es wird einfach eine Speicheradresse +geseichert). Funktionspointer können verwendet werden, um Funktionen und +Handler (oder Callback-Funktionen) direkt aufzurufen. +Wie auch immer, die Syntax kann zu Beginn verwirrend wirken. + +Zum Beispiel: Verwende str_reverse von einem Pointer +*/ +void str_reverse_through_pointer(char *str_in){ + // Definiere eine Funktionspointer-Variable, welche f genannt wird. + void (*f)(char *); // Signatur sollte genau der Funktion entsprechen. + f = &str_reverse; // weise die Adresse der wirklichen Funktion zu (zur Laufzeit bestimmt) + // `f = str_reverse;` würde auch funktionieren, da Funktionen zu Pointern + // reduziert werden (ähnlich wie Arrays) + (*f)(str_in); // Die Funktion einfach mit dem Pointer aufrufen + // f(str_in); // Dies ist eine weitere gültige Alternative um eine Funktion auzurufen. +} + +/* +Solange die Signaturen der Funktionen übereinstimmen, kann man sämtliche Funktionen +demselben Pointer zuweisen. Funktionspointer sind auf Grund der Einfacheit und +Leserlichkeit normalerweise wie folgt `typedef`d +*/ +typedef void (*mein_fnp_type)(char *); +// Danach werden diese genutzt, um die wirkliche Pointervariable zu deklarieren. +// .. +// mein_fnp_type f; + +// Spezialzeichen +// Im folgenden sin die englischen Begriffe jeweils in Klammern geschrieben, +// da diese Begriffe auch im deutschten Sprachgebrauch verwendet werden. +'\a'; // Alarmzeichen (alert (bell) character) +'\n'; // Zeichen für neue Linie (newline character) +'\t'; // Tab (tab character (left justifies text)) +'\v'; // Vertikaler Tab (vertical tab) +'\f'; // Neue Seite (new page (form feed)) +'\r'; // Wagenrücklauf (carriage return) +'\b'; // Backspace-Zeichen (backspace character) +'\0'; // Null-Byte (NULL character). In C wird dieses Zeichen normalerweise am Ende eines Strings gesetzt. +// Beispiel: Hallo\n\0. \0 wird per Konvention verwendet, um das Ende eines Strings zu kennzeichnen. +'\\'; // Backslash (backslash) +'\?'; // Fragezeichen (question mark) +'\''; // einfaches Anführungszeichen (single quote) +'\"'; // doppeltes Anführungszeichen (double quote) +'\xhh'; // Hexadezimale Zahl (hexadecimal number.) Beispiel: '\xb' = Zeichen für vertikalen Tab +'\0oo'; // Oktalzahl (octal number). Beispiel \013 = Zeichen für vertikalen Tab + +//Ausgabeformatierung +"%d"; // Integer +"%3d"; // integer mit einer minimalen Länge von drei Zeichen. +"%s"; // String +"%f"; // Float +"%ld"; // Long +"%3.2f"; // Mindest drei Zeichen vor und drei nach dem Komma. +"%7.4s"; // (Kann auch mit Strings gemacht werden) +"%c"; // Char +"%p"; // Pointer. Merke: man muss den Pointer zu void umwandeln, bevor `printf`funktioniert. +"%x"; // Hexadezimal +"%o"; // Oktalzahl +"%%"; // Gibt % aus + + + + + + + [1] [Why isn't sizeof for a struct equal to the sum of sizeof of each member?](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member) -- cgit v1.2.3 From bc9c26d44c32fe6609f3434891efadad27ff5e6b Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 00:27:18 +0100 Subject: translated associativity of operators --- de-de/c-de.html.markdown | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 946d8329..36865900 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -748,7 +748,29 @@ typedef void (*mein_fnp_type)(char *); "%o"; // Oktalzahl "%%"; // Gibt % aus +//////////////////////////////////////////////// +// Reihenfolge der Auswertung +//////////////////////////////////////////////// +//-------------------------------------------------------// +// Operatoren | Assoziativität // +//-------------------------------------------------------// +// () [] -> . | linksassoziativ // +// ! ~ ++ -- + = *(type)sizeof | rechtsassoziativ // +// * / % | linksassoziativ // +// + - | linksassoziativ // +// << >> | linksassoziativ // +// < <= > >= | linksassoziativ // +// == != | linksassoziativ // +// & | linksassoziativ // +// ^ | linksassoziativ // +// | | linksassoziativ // +// && | linksassoziativ // +// || | linksassoziativ // +// ?: | rechtsassoziativ // +// = += -= *= /= %= &= ^= |= <<= >>= | rechtsassoziativ // +// , | linksassoziativ // +//-------------------------------------------------------// -- cgit v1.2.3 From f3975fdc0e1cc6001565c854b209e118fb323665 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 00:27:55 +0100 Subject: Translated part headerfiles to German --- de-de/c-de.html.markdown | 60 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 36865900..70f5cc94 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -773,7 +773,67 @@ typedef void (*mein_fnp_type)(char *); //-------------------------------------------------------// +//////////////////////////////////////////////// +// Header-Dateien +//////////////////////////////////////////////// +/* +Header-Dateien sind ein wichtiger Teil von C, da sie eine Verbindung zwischen +unterschiedlichen C-Quelldateien herstellen. Ausserdem vereinfachen Header-Dateien +den Code und Definitionen, da diese in separaten Daten geschrieben werden können. + +Header-Dateien sind von der Syntax her ähnlich zu C-Quelldateien, allerdings haben +die Header-Dateien die Dateiendung `.h`. Header-Dateien können im Quellcode mit +der `#include`-Anweisung eingebunden werden z.B. `#include "beispiel.h". Die +vorherige Anweisung geht davon aus, dass sich die Header-Datei im selben Ordner +befindet wie die C-Quelldatei. +*/ + +// Eine sichere Möglichkeit, einen Header mehrere Male zu definieren bietet, das +// folgende Statement. Die mehrfache Definition geschieht, wenn Kreisabhängigkeiten +// bestehen. +#ifndef BEISPIEL_H /* Wenn BEISPIEL_H noch nicht definiert wurde */ +#define BEISPIEL_H /* definiere das Makro BEISPIEL_H */ + +// Es könenn weitere Header innerhalb eines Headers eingebunden werden, was dazu +// führt, dass diese bereits in anderen Dateien eingebunden wurden. So kann eine +// Header-Datei in mehreren Dateien eingebunden werden. zum Beispiel: +#include +// Wie in den Quelldateien können auch in den Header-Dateien Makros definiert +// werden und in anderen Dateien verwendet werden, welche diesen Header einbinden. +#define BEISPIEL_NAME "Dennis Ritchie" + +// Funktionsmakros können auch definiert werden. +#define ADD(a, b) ((a) + (b)) + +// Beachte die Klammern, welche um die Argumente geschrieben wurden - diese sind +// wichtig, damit sichergestellt werden kann, dass a und b nicht unerwartet +// erweitert werden. Zum Beispiel: `MUL (x,y) (x * y)`; Bei der Verwendung von +// `MUL(1 + 2, 3)` würde dies wie folgt erweitert werden: `(1 + 2 * 3)`, was zu +// einem falschen Resultat führen würde. + +// Strukturen und Typendefinitionen können verwendet werden, um die Konsistenz +// zwischen unterschiedlichen Dateien beizubehalten. +typedef struct Knoten{ + int wert; + struct Knoten *naechster; +}Knoten; + +// Dies kann auch mit Aufzählungen gemacht werden. +enum ampel_status {GRUEN, GELB, ROT}; + +// Funktionsprototypen könenn auch in Header-Dateien definiert werden, um die +// Funktion in unterschiedlichen Dateien zu verwenden, aber dies wird als schlechte +// Praxis angesehen. Definitionen sollten in einer C-Datei erstellt werden. +Knoten erstelleVerketteteListe(int *werte, int laenge); + +// Ausser den oben genannten Elementen, sollten weitere Definitionen in einer +// C-Datei gemacht werden. Übermässige Includes und Definitionen sollten auch +// nicht einer Header-Datei gemacht werden. Stattdessen wird es empfohlen, diese +// in eine separate Header-Datei oder in eine C-Quelldatei zu schreiben. + +#endif /* Ende der Präprozessordirektive */ +``` [1] [Why isn't sizeof for a struct equal to the sum of sizeof of each member?](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member) -- cgit v1.2.3 From edeb77b89394e913054d74af178da7bdab429158 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 00:28:07 +0100 Subject: translated further reading --- de-de/c-de.html.markdown | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 70f5cc94..0b52284c 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -835,5 +835,27 @@ Knoten erstelleVerketteteListe(int *werte, int laenge); #endif /* Ende der Präprozessordirektive */ ``` +## Weiterführende Literatur + +Das Beste wird es sein, wenn man sich ein Exemplar des Buches +["The C Programming Language"](https://de.wikipedia.org/wiki/The_C_Programming_Language) besorgt. +Dieses Buch gilt als *das* Buch über die Programmiersprache C und wurde von Dennis Ritchie, +dem Erfinder der Programmiersprache C, und Brian Kernighan geschrieben. +Sei vorsichtig, da dieses Buch mittlerweile schon etwas älter ist und gewisse +Unkorrektheiten (d.h. Ideen, welche nicht mehr als gut empfunden werden.) oder +mittlerweile geänderte Praktiken enthält. [Hinweis: Das Buch wurde auf Englisch +geschrieben, es gibt aber auch eine Übersetzung davon] + +Eine weitere gute Resource ist [Learn C The Hard Way](http://learncodethehardway.org/c/). +[Englisch] + +Solltest du Fragen zu C haben, so lies die FAQ [compl.lang.c Frequently Asked Questions](http://c-faq.com).[Englisch] + +Ausserdem ist es wichtig, eine saubere Einrückung zu verwenden. Des weiteren ist +es wichtig, dass der Codestil möglichst konsistent ist. Es ist wichtiger, lesbaren +Code zu schreiben als Code, welcher clever und schnell ist. Es lohnt sich ein +Blick auf den [Codestil des Linuxkernel](https://www.kernel.org/doc/Documentation/process/coding-style.rst) zu werfen. [Englisch] + +Wenn die erwähnte Literatur dein Problem nicht löst, denke daran: "Google ist dein Freund" [1] [Why isn't sizeof for a struct equal to the sum of sizeof of each member?](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member) -- cgit v1.2.3 From 0996b5a20ed351046ad9e67f01d1593ffe769a34 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 01:00:55 +0100 Subject: Fixed some small typos in german translation --- de-de/c-de.html.markdown | 98 ++++++++++++++++++++++++------------------------ 1 file changed, 50 insertions(+), 48 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 0b52284c..db64b6df 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -13,11 +13,11 @@ Programmierer je brauchen werden. Die Geschwindigkeit von C ist enorm, allerding muss man sich stets der maneullen Speicherverwaltung bewusst sein. -> **Über Compiler Flags** +> **Über Compiler Optionen** > > Standardmässig sind `gcc` und `clang` ziemlich ruhig bezüglich Warnungen und > Fehlern, obwohl dies sehr nützliche Informationen sein können. Es wird -> empfohlen, strengere Compiler Flags zu verwenden. Hier sind einige empfohlene +> empfohlen, strengere Compiler Optionen zu verwenden. Hier sind einige empfohlene > Standards: > `-Wall -Wextra -Werror -O2 -std=c99 -pedantic` > @@ -33,7 +33,7 @@ mehrzeilige Kommentare sehen so aus. Diese funktionieren auch in C89 */ /* -mehrzeilige Kommentare können nicht verschaltelt werden /* Sei Vorsichtig! */ // Kommentar endet auf dieser Linie ... +mehrzeilige Kommentare können nicht verschachtelt werden /* Sei Vorsichtig! */ // Kommentar endet auf dieser Linie ... */ // ... nicht bei dieser! // Konstanten: #define @@ -89,7 +89,7 @@ int main (int argc, char** argv){ // Typen //////////////////////////////////////////////// - // Alle Variable müssen am Anfang des jetzigen Blocks deklariert werden. + // Alle Variablen müssen am Anfang des jetzigen Blocks deklariert werden. // Wir deklarieren die Variablen dynamisch im Code um die Lesbarkeit im // Tutorial zu verbessern. // C99-Konforme Compiler erlauben die Variablendeklaration an dem Punkt, an @@ -121,7 +121,7 @@ int main (int argc, char** argv){ unsigned int ux_int; unsigned long long ux_long_long; - // chars innerhalb von einfachen Anführungszeichen sind Integers im + // Zeichen innerhalb von einfachen Anführungszeichen sind Integers im // Maschinenzeichensatz '0'; // => 48 im ASCII-Zeichensatz 'A'; // => 65 im ASCII-Zeichensatz @@ -187,7 +187,7 @@ int main (int argc, char** argv){ // Strings sind lediglich Arrays von `chars`, welche mit einem Null-Byte // (0x00) beendet werden. In Strings wird das Nullbyte durch das Zeichen \0 // repräsentiert. Wir müssen das Null-Byte nicht angeben in String-Literalen; - // Der Compiler fügt es am Ende des Array automatisch hinzu. + // der Compiler fügt es am Ende des Array automatisch hinzu. char ein_string[20] = "Das ist ein String"; printf("%s\n", ein_string); // %s formattiert einen String @@ -222,9 +222,9 @@ int main (int argc, char** argv){ i1 + i2; // => 3 i2 - i1; // => 1 i2 * i1; // => 2 - i1 / i2; // 0 (0.5, aber abgeschnitten, da es int sind. + i1 / i2; // 0 (0.5, aber abgeschnitten, da es int sind.) - // Man muss mindestens ein Integer to einen float konvertieren, damit man als + // Man muss mindestens ein Integer zu einen float konvertieren, damit man als // Resultat eine Gleitkommazahl erhält. (float)i1 / i2; // => 0.5f i1 / (double)i2; // => 0.5 // das gleiche mit dem Typ `double` @@ -245,7 +245,7 @@ int main (int argc, char** argv){ 2 <= 2; // => 1 2 >= 2; // => 1 - // C ist nicht Python - Vergleiche können nicht verkettet werden. + // C ist nicht Python - Vergleiche können nicht einfach verkettet werden. // Warnung: die folgende Zeile wird kompilieren, aber es bedeutet `(0 < a) < 2`. // Dieser Ausdruck ist immer wahr, weil (0 < a) kann entweder 1 oder 0 sein. // In diesem Falle ist es 1, weil (0 < 1). @@ -278,8 +278,8 @@ int main (int argc, char** argv){ 0x0F & 0xF0; // => 0x00 (Bitweises UND) 0x0F | 0xF0; // => 0xFF (Bitweises ODER) 0x04 ^ 0x0F; // => 0x0B (Bitweises XOR) - 0x01 << 1; // => 0x02 (Bitweises Linksshift (left shift) (um 1)) - 0x02 >> 1; // => 0x01 (Bitweises Rechtsshift (right shift) (um 1)) + 0x01 << 1; // => 0x02 (Bitweises Linksverschiebung (left shift) (um 1)) + 0x02 >> 1; // => 0x01 (Bitweises Rechtsverschiebung (right shift) (um 1)) // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern - folgende Ausdrücke sind nicht definiert: // - Verschiebung in das Vorzeichenbit (int a = 1 << 31) @@ -325,18 +325,18 @@ int main (int argc, char** argv){ printf("\n"); // **Merke** - // Schleifen und Funktionen müssen einen Body haben. Wenn kein Body gebraucht + // Schleifen und Funktionen müssen einen Rumpf haben. Wenn kein Rumpf gebraucht // wird, kann folgendes gemacht werden: int i; for (i = 0; i <= 5; i++){ - ; // Semikolon wird als Body behandelt (Null-Anweisung) + ; // Semikolon wird als Rumpf behandelt (Null-Anweisung) } // Alternativ kann auch folgendes geschrieben werden: for (i = 0; i <= 5; i++); // Verzweigungen mit mehreren Möglichkeiten: `switch()` switch (a){ - case 0: //labels müssen integrale *konstante* Ausdrücke sein (z.B. Enums) + case 0: // Labels müssen integrale *konstante* Ausdrücke sein (z.B. Enums) printf("Hey, 'a' ist gleich 0!\n"); break; //Wenn du kein break einsetzt, so geht der Kontrollfluss durch die Labels case 1: @@ -405,10 +405,10 @@ error: // In diesem Tutorial wird das deutsche Wort Zeiger nicht verwendet, da es // bei einer weiteren Recherche einfacher ist, wenn man von Pointern ausgeht. - // Ausserdem ist der Begriff Pointer auf im deutschen Sprachgebrauch zu finden. + // Ausserdem ist der Begriff Pointer auch im deutschen Sprachgebrauch zu finden. // Ein Pointer ist eine Variable, welche deklariert wurde, um eine Speicher- - // Adresse zu speichern. Die Deklaration eines Pointers wird auch zeigen, + // adresse zu speichern. Die Deklaration eines Pointers wird auch zeigen, // auf welche Art von Daten der Pointer zeigt. Man kann die Speicheradresse // von Variablen abrufen und dann mit diesen herumspielen. @@ -461,7 +461,7 @@ error: // oder wenn das Array ein Stringliteral ist, welches gebraucht wird um ein // `char`-Array zu initialisieren. char anderer_arr[] = "foobarbazquirk"; - // oder wenn es das Argument des des `sizeof` oder `alignof` Operators ist. + // oder wenn es das Argument des `sizeof` oder `alignof` Operators ist. int dritter_array[10]; int *ptr = dritter_array; // gleich wie: `int *ptr = &arr[0]` printf("%zu, %zu\n", sizeof(dritter_array), sizeof(ptr)); @@ -515,7 +515,7 @@ error: free(mein_ptr); // Obwohl Strings normalerweise als Pointer-to-Char (Pointer zum ersten - // Zeichen des Arrays) repräsentiert werden, sind Strings sind Arrays aus `char`s. + // Zeichen des Arrays) repräsentiert werden, sind Strings Arrays aus `char`s. // Es ist eine gute Praxis, `const char *` zu verwenden, wenn man ein // String-Literal referenziert, da String-Literale nicht modifiziert werden // sollten (z.B. "foo"[0] = 'a' ist ILLEGAL) @@ -536,22 +536,22 @@ error: //////////////////////////////////////////////// // Syntax einer Funktionsdeklaration -// () +// () int addiere_zwei_integer(int x1, int x2){ return x1 + x2; // verwendet return, um einen Wert zurückzugeben } /* - * Funktionen werden auf Grund des Wertes aufgerufen (call-by-value). Wenn eine - * Funktion aufgerufen wird, sind die Argumente Kopien der ursprüunglichen Werte - * (ausgenommen Arrays). Alles, was man innerhalb einer Funktion mit den Werten - * macht, hat keinen Einfluss auf die Originalwerte als die Funktion aufgerufen - * wurde +Funktionen werden auf Grund des Wertes aufgerufen (call-by-value). Wenn eine +Funktion aufgerufen wird, sind die Argumente Kopien der ursprüunglichen Werte +(ausgenommen Arrays). Alles, was man innerhalb einer Funktion mit den Werten +macht, hat keinen Einfluss auf die Originalwerte als die Funktion aufgerufen +wurde - * Verwende Pointer, um den Originalinhalt zu bearbeiten. +Verwende Pointer, um den Originalinhalt zu bearbeiten. - * Beispiel: +Beispiel: */ // Eine `void`-Funktion gibt keinen Wert zurück @@ -561,7 +561,7 @@ void str_reverse(char *str_in){ size_t laenge = strlen(str_in); // `strlen()` ist ein Teil der C Standard-Bibliothek. // Merke: Die Länge, welche von `strlen` zurückgegeben wird, ist ohne den - // Null-Byter Terminatur. + // Null-Byte Terminator. for (ii = 0; i < laenge /2; ii++){ // in C99 kann man `ii` direkt hier deklarieren. tmp = str_in[ii]; str_in[ii] = str_in[laenge - ii - 1]; //#ii'tes Zeichen vom Ende her @@ -572,9 +572,9 @@ void str_reverse(char *str_in){ // verwendet werden kann. /* - * char c[] = "Das ist ein Test"; - * str_reverse(c); - * printf("%s\n", c), => "tseT nie tsi saD" +char c[] = "Das ist ein Test"; +str_reverse(c); +printf("%s\n", c), => "tseT nie tsi saD" */ // Weil wir lediglich eine Variable zurückgeben können, kann zum Ändern mehrerer @@ -595,7 +595,7 @@ printf("Erste Zahl: %d\n Zweite Zahl: %d\n", erste_zahl, zweite_zahl); Wenn man Arrays betrachtet, so werden diese immer als Pointer übergeben. Auch wenn die Arrays statisch alloziert werden (wie zum Beispiel `arr[10]`), werden diese als Pointer zum ersten Element des Arrays übergeben. -Auch hier soll noch einmal erwähnt werden, dass keinen Standard gibt, wie die +Auch hier soll noch einmal erwähnt werden, dass es keinen Standard gibt, wie die Grösse eines dynamischen Arrays herausgefunden werden kann. */ // Die Grösse des Arrays muss unbedingt mitgegeben werden. @@ -616,7 +616,7 @@ ausgabe_int_array(mein_array, groesse); // man das Schlüsselwort `extern` verwenden. int i = 0; void test_funktion(){ - extern int i; //i braucht nun die externe Variable i + extern int i; // i braucht nun die externe Variable i } // Das Schlüsselwort `static` macht, dass eine Variable ausserhalb der Kompilier- @@ -629,14 +629,14 @@ void test_funktion(){ // Variablen mit 0 initialisiert, wenn sie nicht mit einem anderen Startwert // initialisiert werden. // Es ist auch möglich, Funktionen als statisch zu deklarieren, damit diese -// `private` sind. Private heisst, dass sie nur in diesem Kontekt sichtbar sind. +// `private` sind. Privat heisst, dass sie nur in diesem Kontekt sichtbar sind. //////////////////////////////////////////////// // Benutzerdefinierte Typen und Strukturen (Structs) //////////////////////////////////////////////// -// `typdef`s können verwendet werden, um Typenaliase zu erstellen. +// `typedef`s können verwendet werden, um Typenaliase zu erstellen. typedef int mein_typ; mein_typ meine_typ_var = 0; @@ -650,7 +650,7 @@ struct rechteck{ // Allgemein ist es nicht so, dass folgender Ausdruck wahr ist. // sizeof(struct rechteck) == sizeof(int) + sizeof(int) // Dies ist so, weil potentiell ein Padding zwischen den Struktur-Inhalten -// möglich ist). siehe [1] +// möglich ist). (siehe [1, Englisch]) void funktion_1(){ struct rechteck mein_rechteck; @@ -669,7 +669,7 @@ void funktion_1(){ mein_rechteck_ptr->hoehe = 10; // Das gleiche wie: (*mein_rechteck_ptr).hoehe = 10; } -// Aus Bequemlichkeitsgründen ist es möglich einem `struct` ein `typedef`hinzuzufügen. +// Aus Bequemlichkeitsgründen ist es möglich einem `struct` ein `typedef` hinzuzufügen. typedef struct rechteck recht; int flaeche(recht r){ @@ -689,7 +689,7 @@ int flaecheptr(const recht *r){ /* Zur Laufzeit sind Funktionen in einer Speicheradresse gespeichert. Funktionspointer sind wie normale Pointer (es wird einfach eine Speicheradresse -geseichert). Funktionspointer können verwendet werden, um Funktionen und +gespeichert). Funktionspointer können verwendet werden, um Funktionen und Handler (oder Callback-Funktionen) direkt aufzurufen. Wie auch immer, die Syntax kann zu Beginn verwirrend wirken. @@ -725,8 +725,10 @@ typedef void (*mein_fnp_type)(char *); '\f'; // Neue Seite (new page (form feed)) '\r'; // Wagenrücklauf (carriage return) '\b'; // Backspace-Zeichen (backspace character) -'\0'; // Null-Byte (NULL character). In C wird dieses Zeichen normalerweise am Ende eines Strings gesetzt. -// Beispiel: Hallo\n\0. \0 wird per Konvention verwendet, um das Ende eines Strings zu kennzeichnen. +'\0'; // Null-Byte (NULL character). In C wird dieses Zeichen normalerweise am +// Ende eines Strings gesetzt. +// Beispiel: Hallo\n\0. "\0" wird per Konvention verwendet, um das Ende +// eines Strings zu kennzeichnen. '\\'; // Backslash (backslash) '\?'; // Fragezeichen (question mark) '\''; // einfaches Anführungszeichen (single quote) @@ -736,20 +738,20 @@ typedef void (*mein_fnp_type)(char *); //Ausgabeformatierung "%d"; // Integer -"%3d"; // integer mit einer minimalen Länge von drei Zeichen. +"%3d"; // Integer mit einer minimalen Länge von drei Zeichen. "%s"; // String -"%f"; // Float -"%ld"; // Long -"%3.2f"; // Mindest drei Zeichen vor und drei nach dem Komma. +"%f"; // Gleitkommazahl (float) +"%ld"; // genauere Gleitkommazahl (long) +"%3.2f"; // Mindestens drei Zeichen vor und drei nach dem Komma. "%7.4s"; // (Kann auch mit Strings gemacht werden) -"%c"; // Char -"%p"; // Pointer. Merke: man muss den Pointer zu void umwandeln, bevor `printf`funktioniert. +"%c"; // einzelnes Zeichen (char) +"%p"; // Pointer. Merke: man muss den Pointer zu void umwandeln, bevor `printf` funktioniert. "%x"; // Hexadezimal "%o"; // Oktalzahl "%%"; // Gibt % aus //////////////////////////////////////////////// -// Reihenfolge der Auswertung +// Reihenfolge der Auswertung von Operatoren //////////////////////////////////////////////// //-------------------------------------------------------// @@ -780,7 +782,7 @@ typedef void (*mein_fnp_type)(char *); /* Header-Dateien sind ein wichtiger Teil von C, da sie eine Verbindung zwischen unterschiedlichen C-Quelldateien herstellen. Ausserdem vereinfachen Header-Dateien -den Code und Definitionen, da diese in separaten Daten geschrieben werden können. +den Code und Definitionen, da diese in separaten Dateien geschrieben werden können. Header-Dateien sind von der Syntax her ähnlich zu C-Quelldateien, allerdings haben die Header-Dateien die Dateiendung `.h`. Header-Dateien können im Quellcode mit @@ -811,7 +813,7 @@ befindet wie die C-Quelldatei. // wichtig, damit sichergestellt werden kann, dass a und b nicht unerwartet // erweitert werden. Zum Beispiel: `MUL (x,y) (x * y)`; Bei der Verwendung von // `MUL(1 + 2, 3)` würde dies wie folgt erweitert werden: `(1 + 2 * 3)`, was zu -// einem falschen Resultat führen würde. +// einem falschen Resultat führt. // Strukturen und Typendefinitionen können verwendet werden, um die Konsistenz // zwischen unterschiedlichen Dateien beizubehalten. -- cgit v1.2.3 From 5ff9fd5659c308dc7a8e3767bef09934a04cc62b Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 01:05:29 +0100 Subject: Added suffix to filename because of contributing guidelines --- de-de/c-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index db64b6df..40c6489c 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -1,6 +1,6 @@ --- language: c -filename: learnc.c +filename: learnc-de.c contributors: - ["caminsha", "https://github.com/caminsha"] lang: de-de -- cgit v1.2.3 From 8041d796bbddf8ad61a3fb7e38acfb5f9659567b Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 02:18:13 +0100 Subject: Fixed small typo in include statement --- de-de/c-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 40c6489c..72928516 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -47,7 +47,7 @@ enum tage {SO=1, MO, DI, MI, DO, FR, SA}; // Importiere Header-Dateien mit #include #include -#include +#include #include // Dateien, welche zwischen stehen, sind Header-Dateien aus -- cgit v1.2.3 From a765253cd49af22d757b21c7725d22d892a8aae3 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 02:19:22 +0100 Subject: Changed italic typing to bold --- de-de/c-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 72928516..6670ac46 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -841,7 +841,7 @@ Knoten erstelleVerketteteListe(int *werte, int laenge); Das Beste wird es sein, wenn man sich ein Exemplar des Buches ["The C Programming Language"](https://de.wikipedia.org/wiki/The_C_Programming_Language) besorgt. -Dieses Buch gilt als *das* Buch über die Programmiersprache C und wurde von Dennis Ritchie, +Dieses Buch gilt als **das** Buch über die Programmiersprache C und wurde von Dennis Ritchie, dem Erfinder der Programmiersprache C, und Brian Kernighan geschrieben. Sei vorsichtig, da dieses Buch mittlerweile schon etwas älter ist und gewisse Unkorrektheiten (d.h. Ideen, welche nicht mehr als gut empfunden werden.) oder -- cgit v1.2.3 From 8e1372e08bf29428f9e59f10744f4182e29bbcc4 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 1 Feb 2020 02:26:58 +0100 Subject: Changed some lines so that it is not more than 80 chars --- de-de/c-de.html.markdown | 75 +++++++++++++++++++++++++++++------------------- 1 file changed, 46 insertions(+), 29 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 6670ac46..64159c31 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -73,9 +73,10 @@ int main(void){ // dein Programm } -// Die Kommandozeilenargumente, welche gebraucht werden, damit dein Programm läuft, -// werden als Argumente der `main`-Funktion mitgegeben. -// argc steht für die Anzahl von Argumenten. - Der Programmname ist das erste Argument. +// Die Kommandozeilenargumente, welche gebraucht werden, damit dein Programm +// läuft, werden als Argumente der `main`-Funktion mitgegeben. +// argc steht für die Anzahl von Argumenten. - Der Programmname ist das erste +// Argument. // argv ist ein Array von Zeichenarrays, welche die Argumente beinhaltet. // argv[0] = Name des Programms // argv[1] = erstes Argument usw. @@ -116,7 +117,8 @@ int main (int argc, char** argv){ // doubles sind normalerweise 64-Bit Gleitkommazahlen double x_double = 0.0; // echte Zahlen ohne Suffix sind vom Typ double - // integer-Typen können vorzeichenlos (unsigned) sein (grösser oder kleiner als 0) + // integer-Typen können vorzeichenlos (unsigned) sein + // (grösser oder kleiner als 0) unsigned short ux_short; unsigned int ux_int; unsigned long long ux_long_long; @@ -129,7 +131,7 @@ int main (int argc, char** argv){ // sizeof(T) gibt die Grösse einer Variablen des Typen T in Bytes zurück. // sizeof(obj) ergibt die Grösse des Ausdrucks (Variable, Literal usw.) - printf("%zu\n", sizeof(int)); // => 4 (auf den meisten Rechnern mit einem 4-Byte-Wort) + printf("%zu\n", sizeof(int)); // => 4 (auf den Rechnern mit einem 4-Byte-Wort) // Wenn das Argument des `sizeof`-Operator ein Ausdruck ist, dann wird das // Argument nicht ausgewertet (ausser Arrays mit variabler Länge) @@ -174,7 +176,8 @@ int main (int argc, char** argv){ // In C99 (und als optionales Feature in C11) können Arrays mit variabler // Länge deklariert werden. Die Grösse eines solchen Array muss eine Konstante // zur Kompilierzeit sein. - printf("Geben Sie die Arraygrösse an: "); //Frag den Benutzer nach der Arraygrösse + printf("Geben Sie die Arraygrösse an: "); //Frag den Benutzer nach + // der Arraygrösse int array_size; fcsanf(stdin, "%d", &array_size); int var_length_array[array_size]; // deklariere Array mit variabler Länge @@ -234,8 +237,8 @@ int main (int argc, char** argv){ // Es gibt auch die Möglichkeit, Modulo zu rechnen 11 % 3; // => 2 - // Vergleichsoperatoren sind vielleicht schon bekannt, aber in C gibt es keinen - // Boolean-Typ. In C verwenden wir `int`. (Oder _Bool oder bool in C99.) + // Vergleichsoperatoren sind vielleicht schon bekannt, aber in C gibt es + // keinen Boolean-Typ. In C verwenden wir `int`. (Oder _Bool oder bool in C99) // 0 ist falsch, alles andere ist wahr (Die Vergleichsoperatoren ergeben // immer 1 oder 0. 3 == 2; // => 0 (falsch) @@ -274,14 +277,16 @@ int main (int argc, char** argv){ // das gleiche gilt für j-- und --j // Bitweise Operatoren - ~0x0F; // => 0xFFFFFFF0 (Bitweise Negation, "Einer-Komplement", Beispielresultat für 32-Bit int) + ~0x0F; // => 0xFFFFFFF0 (Bitweise Negation, "Einer-Komplement", + // Beispielresultat für 32-Bit int) 0x0F & 0xF0; // => 0x00 (Bitweises UND) 0x0F | 0xF0; // => 0xFF (Bitweises ODER) 0x04 ^ 0x0F; // => 0x0B (Bitweises XOR) 0x01 << 1; // => 0x02 (Bitweises Linksverschiebung (left shift) (um 1)) 0x02 >> 1; // => 0x01 (Bitweises Rechtsverschiebung (right shift) (um 1)) - // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern - folgende Ausdrücke sind nicht definiert: + // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern + // folgende Ausdrücke sind nicht definiert: // - Verschiebung in das Vorzeichenbit (int a = 1 << 31) // - Linksshift einer negativen Zahl (int a = -1 << 2) // - Shift um einen Offset, welcher >= die Breite des linken Ausdrucks ist. @@ -303,7 +308,8 @@ int main (int argc, char** argv){ // While-Schleifen existieren auch int ii = 0; while (ii < 10){ // JEDER Wert unter zehn ist wahr - printf("%d, " ii++); //i++ inkrementiert ii NACHDEM der Wert gebraucht wurde. + printf("%d, " ii++); //i++ inkrementiert ii NACHDEM der Wert gebraucht + // wurde. } // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " printf("\n"); @@ -338,12 +344,13 @@ int main (int argc, char** argv){ switch (a){ case 0: // Labels müssen integrale *konstante* Ausdrücke sein (z.B. Enums) printf("Hey, 'a' ist gleich 0!\n"); - break; //Wenn du kein break einsetzt, so geht der Kontrollfluss durch die Labels + break; //Wenn du kein break einsetzt, so geht der Kontrollfluss + // durch die Labels case 1: printf("Huh, 'a' ist gleich 1!\n"); break; - // Sei vorsichtig - wenn man das `break` vergisst, werden alle Anweisungen - // ausgeführt bis das nächste `break` erscheint. + // Sei vorsichtig - wenn man das `break` vergisst, werden alle + // Anweisungen ausgeführt bis das nächste `break` erscheint. case 3: case 4: printf("Schau mal ... 'a' ist entweder 3 oder 4.\n"); @@ -388,7 +395,7 @@ error: printf("%d\n", (char) x_hex); // => 1 // Typen werden überlaufen (overflow) ohne jegliche Warnung - printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 wenn char 8 Bit lang ist) + printf("%d\n", (unsigned char) 257); // => 1 (Max char=255 wenn char 8 Bit ist) // Um den maximalen Wert eines `char`, `signed char` oder `unsigned char` // herauszufinden, können die Makros `CHAR_MAX`, `SCHAR_MAX` und `UCHAR_MAX` @@ -413,7 +420,8 @@ error: // von Variablen abrufen und dann mit diesen herumspielen. int x = 0; - printf("%p\n", (void *)&x); // verwende & um die Adresse der Variable zu erhalten + printf("%p\n", (void *)&x); // verwende & um die Adresse der Variable + // zu erhalten // %p formattiert einen Objektpointer des Typen void*) // => Gibt eine Adresse im Speicher aus @@ -506,7 +514,8 @@ error: // Das Dereferenzieren von nicht alloziertem Speicher führt zu einem // Undefinierten Verhalten. - printf("%d\n", *(mein_ptr + 21)); // Gibt irgendwas aus. Das Programm kann auch abstürzen + printf("%d\n", *(mein_ptr + 21)); // Gibt irgendwas aus. + // Das Programm kann auch abstürzen // Nachdem du fertig mit einem Block bist, welcher `malloc` verwendet hat, // muss der Speicher befreit werden. Ansonsten kann dieser Speicherbereich @@ -562,7 +571,7 @@ void str_reverse(char *str_in){ // `strlen()` ist ein Teil der C Standard-Bibliothek. // Merke: Die Länge, welche von `strlen` zurückgegeben wird, ist ohne den // Null-Byte Terminator. - for (ii = 0; i < laenge /2; ii++){ // in C99 kann man `ii` direkt hier deklarieren. + for (ii = 0; i < laenge /2; ii++){ // in C99 kann man `ii` hier deklarieren. tmp = str_in[ii]; str_in[ii] = str_in[laenge - ii - 1]; //#ii'tes Zeichen vom Ende her str_in[laenge - ii- 1] = tmp; @@ -621,8 +630,9 @@ void test_funktion(){ // Das Schlüsselwort `static` macht, dass eine Variable ausserhalb der Kompilier- // einheit nicht zugreifbar ist. (Auf den meisten Systemen ist eine Kompiliereinheit -// eine `.c`-Datei.) Das Schlüsselwort `static` kann sowohl global (zur Kompiliereinheit gehörende) -// Variablen, Funktionen und Funktionslokale Variablen angewendet werden. +// eine `.c`-Datei.) Das Schlüsselwort `static` kann sowohl global +// (zur Kompiliereinheit gehörende) Variablen, Funktionen und Funktionslokale +// Variablen angewendet werden. // Wenn man `static` bei lokalen Variablen verwendet, so ist diese Variable global // erreichbar und behält dessen Wert über Funktionsaufrufe hinweg, aber sie ist // nur innerhalb der deklarierten Funktion verfügbar. Ausserdem werden statische @@ -665,8 +675,9 @@ void funktion_1(){ // Verwende Dereferenzierung, um Struct-Inhalte zu bearbeiten (*mein_rechteck_ptr).breite = 30; - //Noch besser: Verwende die Kurzschreibweise ->, um die Lesbarkeit zu verbessern. - mein_rechteck_ptr->hoehe = 10; // Das gleiche wie: (*mein_rechteck_ptr).hoehe = 10; + //Noch besser: Verwende die Kurzschreibweise ->, um die Lesbarkeit zu + // verbessern. + mein_rechteck_ptr->hoehe = 10; // Gleich wie: (*mein_rechteck_ptr).hoehe = 10; } // Aus Bequemlichkeitsgründen ist es möglich einem `struct` ein `typedef` hinzuzufügen. @@ -698,11 +709,13 @@ Zum Beispiel: Verwende str_reverse von einem Pointer void str_reverse_through_pointer(char *str_in){ // Definiere eine Funktionspointer-Variable, welche f genannt wird. void (*f)(char *); // Signatur sollte genau der Funktion entsprechen. - f = &str_reverse; // weise die Adresse der wirklichen Funktion zu (zur Laufzeit bestimmt) + f = &str_reverse; // weise die Adresse der wirklichen Funktion zu + // (zur Laufzeit bestimmt) // `f = str_reverse;` würde auch funktionieren, da Funktionen zu Pointern // reduziert werden (ähnlich wie Arrays) (*f)(str_in); // Die Funktion einfach mit dem Pointer aufrufen - // f(str_in); // Dies ist eine weitere gültige Alternative um eine Funktion auzurufen. + // f(str_in); // Dies ist eine weitere gültige Alternative um eine Funktion + // auzurufen. } /* @@ -733,7 +746,8 @@ typedef void (*mein_fnp_type)(char *); '\?'; // Fragezeichen (question mark) '\''; // einfaches Anführungszeichen (single quote) '\"'; // doppeltes Anführungszeichen (double quote) -'\xhh'; // Hexadezimale Zahl (hexadecimal number.) Beispiel: '\xb' = Zeichen für vertikalen Tab +'\xhh'; // Hexadezimale Zahl (hexadecimal number.) Beispiel: + // '\xb' = Zeichen für vertikalen Tab '\0oo'; // Oktalzahl (octal number). Beispiel \013 = Zeichen für vertikalen Tab //Ausgabeformatierung @@ -745,7 +759,8 @@ typedef void (*mein_fnp_type)(char *); "%3.2f"; // Mindestens drei Zeichen vor und drei nach dem Komma. "%7.4s"; // (Kann auch mit Strings gemacht werden) "%c"; // einzelnes Zeichen (char) -"%p"; // Pointer. Merke: man muss den Pointer zu void umwandeln, bevor `printf` funktioniert. +"%p"; // Pointer. Merke: man muss den Pointer zu void umwandeln, + // bevor `printf` funktioniert. "%x"; // Hexadezimal "%o"; // Oktalzahl "%%"; // Gibt % aus @@ -841,8 +856,9 @@ Knoten erstelleVerketteteListe(int *werte, int laenge); Das Beste wird es sein, wenn man sich ein Exemplar des Buches ["The C Programming Language"](https://de.wikipedia.org/wiki/The_C_Programming_Language) besorgt. -Dieses Buch gilt als **das** Buch über die Programmiersprache C und wurde von Dennis Ritchie, -dem Erfinder der Programmiersprache C, und Brian Kernighan geschrieben. +Dieses Buch gilt als **das** Buch über die Programmiersprache C und wurde +von Dennis Ritchie, dem Erfinder der Programmiersprache C, und Brian Kernighan +geschrieben. Sei vorsichtig, da dieses Buch mittlerweile schon etwas älter ist und gewisse Unkorrektheiten (d.h. Ideen, welche nicht mehr als gut empfunden werden.) oder mittlerweile geänderte Praktiken enthält. [Hinweis: Das Buch wurde auf Englisch @@ -858,6 +874,7 @@ es wichtig, dass der Codestil möglichst konsistent ist. Es ist wichtiger, lesba Code zu schreiben als Code, welcher clever und schnell ist. Es lohnt sich ein Blick auf den [Codestil des Linuxkernel](https://www.kernel.org/doc/Documentation/process/coding-style.rst) zu werfen. [Englisch] -Wenn die erwähnte Literatur dein Problem nicht löst, denke daran: "Google ist dein Freund" +Wenn die erwähnte Literatur dein Problem nicht löst, denke daran: +"Google ist dein Freund" [1] [Why isn't sizeof for a struct equal to the sum of sizeof of each member?](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member) -- cgit v1.2.3 From 4686ba1bbaaf72e94e3cfce3acac4f440dcff93e Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 20:27:41 +0100 Subject: Fixed small typo and added Abstraktionsniveau Typo: maneullen => manuelllen - Added new word because it makes the sentence more clear --- de-de/c-de.html.markdown | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 64159c31..bbb46f71 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -8,9 +8,10 @@ lang: de-de Ach, C. Immer noch **die** Sprache für modernes High-Performance Computing. -C ist wahrscheinlich die niedrigste Programmiersprache, welche die meisten -Programmierer je brauchen werden. Die Geschwindigkeit von C ist enorm, allerdings -muss man sich stets der maneullen Speicherverwaltung bewusst sein. +C ist wahrscheinlich die Programmiersprache mit dem niedrigsten Abstraktionsnvieau, +welche die meisten Programmierer je brauchen werden. +Die Geschwindigkeit von C ist enorm, allerdings muss man sich stets der +manuellen Speicherverwaltung bewusst sein. > **Über Compiler Optionen** -- cgit v1.2.3 From 28fe657526b2134457b9f08863ceba24b3bc3ae3 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 21:02:01 +0100 Subject: Changed german variables to english --- de-de/c-de.html.markdown | 174 +++++++++++++++++++++++------------------------ 1 file changed, 87 insertions(+), 87 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index bbb46f71..dee05954 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -39,12 +39,12 @@ mehrzeilige Kommentare können nicht verschachtelt werden /* Sei Vorsichtig! */ // Konstanten: #define // Konstanten werden laut der Konvention immer in GROSSBUCHSTABEN geschrieben -#define TAGE_IM_JAHR 365 +#define DAYS_IN_YEAR 365 // Konstanten können auch als Aufzählungskonstanten (Enums) definiert werden. // Alle Anweisungen müssen mit einem Semikolon beendet werden. -enum tage {SO=1, MO, DI, MI, DO, FR, SA}; -// MO wird automatisch zu 2, DI zu 3 etc. +enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT}; +// MON wird automatisch zu 2, TUE zu 3 etc. // Importiere Header-Dateien mit #include #include @@ -58,13 +58,13 @@ enum tage {SO=1, MO, DI, MI, DO, FR, SA}; // Funktionssignaturen werden entweder vorher in einer .h-Datei deklariert oder // am Anfang der .c-Datei. -void funktion_1(); -int funktion_2(void); +void function_1(); +int funkcion_2(void); // Es muss ein Funktionsprototyp deklariert werden vor der `main()` Funktion, // wenn die Funktion nach der `main()` Funktion gebraucht wird. -int addiere_zwei_integer(int x1, int x2); // Funktionsprototyp -// Auch wenn der Ausdrck `int addiere_zwei_integer(int, int)` auch valid wäre, +int add_two_ints(int x1, int x2); // Funktionsprototyp +// Auch wenn der Ausdrck `int add_two_ints(int, int)` auch valid wäre, // ist es empfohlen, dass man die Namen der Argumente hinschreibt für eine // einfachere Analyse. @@ -147,19 +147,19 @@ int main (int argc, char** argv){ // Gibt "sizeof(a++) = 4, wobei a=1 ist" aus (mit einer 32-Bit-Architektur) // Arrays müssen mit einer Grösse initialisiert werden. - char mein_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes - int mein_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. + char my_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes + int my_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. // unter der Voraussetzung eines 4-Byte-Worts. // Ein Array kann auf diese Weise mit 0 initialisiert werden. - char mein_array[20] = {0}; + char my_array[20] = {0}; // Hierbei ist der Teil "{0}" der "Array Initialisierer". // Beachte, dass die Länge des Arrays nicht explizit definiert werden muss, // wenn er auf derselben Linie initialisiert wird. // Folgende Deklaration ist gleichwertig: - char mein_array[] = {0}; + char my_array[] = {0}; // Allerdings muss die Länge des Arrays dann zur Laufzeit ausgewertet werden: - size_t mein_array_size = sizeof(mein_array) / sizeof(mein_array[0]); + size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]); // WARNUNG: Wenn dieser Ansatz gewählt wird, muss man sicherstellen, dass die // Grösse des Arrays ermittelt werden *bevor* dieser einer Funktion als // Argument weitergegeben wird (siehe Diskussion weiter unten), weil Arrays @@ -168,11 +168,11 @@ int main (int argc, char** argv){ // Das Indexieren eines Arrays funktioniert wie in anderen Sprache - resp. // in anderen Sprachen funktioniert es gleich wie in C. - mein_array[0]; // => 0 + my_array[0]; // => 0 // Arrays sind veränderbar; es ist nur Arbeitsspeicher! - mein_array[1] = 2; - printf("%d\n", mein_array[1]); // => 2 + my_array[1] = 2; + printf("%d\n", my_array[1]); // => 2 // In C99 (und als optionales Feature in C11) können Arrays mit variabler // Länge deklariert werden. Die Grösse eines solchen Array muss eine Konstante @@ -192,10 +192,10 @@ int main (int argc, char** argv){ // (0x00) beendet werden. In Strings wird das Nullbyte durch das Zeichen \0 // repräsentiert. Wir müssen das Null-Byte nicht angeben in String-Literalen; // der Compiler fügt es am Ende des Array automatisch hinzu. - char ein_string[20] = "Das ist ein String"; - printf("%s\n", ein_string); // %s formattiert einen String + char a_string[20] = "Das ist ein String"; + printf("%s\n", a_string); // %s formattiert einen String - printf("%d\n", ein_string[18]); // => 0 + printf("%d\n", a_string[18]); // => 0 // Hier ist das Byte #19 0 (wie auch Byte #20) // Wenn wir Zeichen zwischen einfachen Anführungszeichen haben, ist es ein @@ -427,10 +427,10 @@ error: // => Gibt eine Adresse im Speicher aus // Pointer starten mit einem * zu Beginn der Deklaration. - int *px, kein_pointer; // px ist ein Pointer zu einem int. + int *px, not_a_pointer; // px ist ein Pointer zu einem int. px = &x; // Speichert die Adresse von x in px printf("%p\n", (void *)px); // => Gibt eine Adresse im Speicher aus - printf("%zu, %zu\n", sizeof(px), sizeof(kein_pointer)); + printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer)); // Gibt auf einem typischen 64-Bit-System folgendes aus: "8, 4" // Um den Wert einer Adresse, auf welche ein Pointer zeigt, herauszufinden, @@ -465,15 +465,15 @@ error: // Pointer zugewiesen wird, wird es zu einem Pointer reduziert (implizites Casting) // Ausnahme: Wenn das Array das Argument des Operators `&` ist. int arr[10]; - int (*ptr_zu_arr)[10] = &arr; //`&arr` ist nicht vom Typ `int *`! + int (*ptr_to_arr)[10] = &arr; //`&arr` ist nicht vom Typ `int *`! // Es ist vom Typem "Pointer auf Array" (aus zehn `int`s) // oder wenn das Array ein Stringliteral ist, welches gebraucht wird um ein // `char`-Array zu initialisieren. - char anderer_arr[] = "foobarbazquirk"; + char other_arr[] = "foobarbazquirk"; // oder wenn es das Argument des `sizeof` oder `alignof` Operators ist. - int dritter_array[10]; - int *ptr = dritter_array; // gleich wie: `int *ptr = &arr[0]` - printf("%zu, %zu\n", sizeof(dritter_array), sizeof(ptr)); + int third_array[10]; + int *ptr = third_array; // gleich wie: `int *ptr = &arr[0]` + printf("%zu, %zu\n", sizeof(third_array), sizeof(ptr)); // Gibt wahrscheinlich "40, 4" oder "40, 8" aus // Pointer werden basierend auf dem Typ in- und dekrementiert @@ -487,50 +487,50 @@ error: // wie viele Bytes alloziert werden sollen. (Normalerweise geschieht dies // aus dem Heap - dies kann auf eingebetteten Systemen unterschiedlichen sein. // Der C Standard sagt nichts darüber.) - int *mein_ptr = malloc(sizeof(*mein_ptr) * 20); + int *my_ptr = malloc(sizeof(*my_ptr) * 20); for (xx = 0; xx < 20; xx++){ - *(mein_ptr + xx) = 20 -xx; //mein_ptr[xx] = 20-xx + *(my_ptr + xx) = 20 -xx; //my_ptr[xx] = 20-xx } // initialisiere Speicher zu 20, 19, 18, 17, ... 2, 1 (als `int`) // Sei vorsichtig beim Übergeben von Benutzerdefinierten Werten an `malloc`. // Wenn du sicher sein willst, kannst du die Funktion `calloc` nutzen, welche // (nicht wie `malloc`) auch den Speicher nullt. - int *mein_anderer_ptr = calloc(20, sizeof(int)); + int *my_other_ptr = calloc(20, sizeof(int)); // Merke, dass es in C keinen Standard-Weg gibt, um die Länge eines dynamisch // allozierten Arrays zu bestimmen. Auf Grund dessen sollte eine Variable // erstellt werden, welche sich die Anzahl der Elemente im Array merkt, wenn // die Arrays mehrmals im Programm gebraucht werden. // Weitere Informationen stehen im Abschnitt Funktionen. - size_t groesse = 10; - int *mein_array = calloc(groesse, sizeof(int)); + size_t size = 10; + int *my_array = calloc(size, sizeof(int)); // Füge dem Array ein Element hinzu - groesse++; - mein_array = realloc(mein_array, sizeof(int) *groesse); - if (mein_array == NULL){ + size++; + my_array = realloc(my_array, sizeof(int) *size); + if (my_array == NULL){ // Denke daran, realloc-Fehler zu prüfen return } - mein_array[10] = 5; + my_array[10] = 5; // Das Dereferenzieren von nicht alloziertem Speicher führt zu einem // Undefinierten Verhalten. - printf("%d\n", *(mein_ptr + 21)); // Gibt irgendwas aus. + printf("%d\n", *(my_ptr + 21)); // Gibt irgendwas aus. // Das Programm kann auch abstürzen // Nachdem du fertig mit einem Block bist, welcher `malloc` verwendet hat, // muss der Speicher befreit werden. Ansonsten kann dieser Speicherbereich // niemand nutzen bis dein Programm beendet wird. // Dies wird auch als "Speicherleck" (engl: memory leak) bezeichnet. - free(mein_ptr); + free(my_ptr); // Obwohl Strings normalerweise als Pointer-to-Char (Pointer zum ersten // Zeichen des Arrays) repräsentiert werden, sind Strings Arrays aus `char`s. // Es ist eine gute Praxis, `const char *` zu verwenden, wenn man ein // String-Literal referenziert, da String-Literale nicht modifiziert werden // sollten (z.B. "foo"[0] = 'a' ist ILLEGAL) - const char *mein_str = "Das ist mein eigener String"; - printf("%c\n", *mein_str); // => D + const char *my_str = "Das ist mein eigener String"; + printf("%c\n", *my_str); // => D // Dies ist nicht der Fall, wenn der String ein Array (möglicherweise mit // einem String-Literal initialisiert) ist, welcher im beschreibbaren Speicher @@ -538,7 +538,7 @@ error: char foo[] = "foo"; foo[0] = 'a'; // Dies ist legal, foo enthält jetzt "aoo" - funktion_1(); + function_1(); } // Ende der `main`-Funktion //////////////////////////////////////////////// @@ -548,16 +548,16 @@ error: // Syntax einer Funktionsdeklaration // () -int addiere_zwei_integer(int x1, int x2){ +int add_two_ints(int x1, int x2){ return x1 + x2; // verwendet return, um einen Wert zurückzugeben } /* Funktionen werden auf Grund des Wertes aufgerufen (call-by-value). Wenn eine -Funktion aufgerufen wird, sind die Argumente Kopien der ursprüunglichen Werte +Funktion aufgerufen wird, sind die Argumente Kopien der ursprünglichen Werte (ausgenommen Arrays). Alles, was man innerhalb einer Funktion mit den Werten macht, hat keinen Einfluss auf die Originalwerte als die Funktion aufgerufen -wurde +wurde. Verwende Pointer, um den Originalinhalt zu bearbeiten. @@ -568,14 +568,14 @@ Beispiel: void str_reverse(char *str_in){ char tmp; size_t ii = 0; - size_t laenge = strlen(str_in); + size_t size = strlen(str_in); // `strlen()` ist ein Teil der C Standard-Bibliothek. // Merke: Die Länge, welche von `strlen` zurückgegeben wird, ist ohne den // Null-Byte Terminator. - for (ii = 0; i < laenge /2; ii++){ // in C99 kann man `ii` hier deklarieren. + for (ii = 0; i < size /2; ii++){ // in C99 kann man `ii` hier deklarieren. tmp = str_in[ii]; - str_in[ii] = str_in[laenge - ii - 1]; //#ii'tes Zeichen vom Ende her - str_in[laenge - ii- 1] = tmp; + str_in[ii] = str_in[size - ii - 1]; //#ii'tes Zeichen vom Ende her + str_in[size - ii- 1] = tmp; } } // Merke: Die `string.h`-Headerdatei muss inkludiert werden, bevor `strlen()` @@ -589,16 +589,16 @@ printf("%s\n", c), => "tseT nie tsi saD" // Weil wir lediglich eine Variable zurückgeben können, kann zum Ändern mehrerer // Variablen das Konzept call-by-reference verwendet werden. -void tausche_zwei_zahlen(int *a, int *b){ +void swap_two_numbers(int *a, int *b){ int temp = *a; *a = *b; *b = temp; } -int erste_zahl = 10; -int zweite_zahl = 20; -printf("Erste Zahl: %d\n Zweite Zahl: %d\n", erste_zahl, zweite_zahl); -tausche_zwei_zahlen(&erste_zahl, &zweite_zahl); -printf("Erste Zahl: %d\n Zweite Zahl: %d\n", erste_zahl, zweite_zahl); +int first = 10; +int seconde = 20; +printf("Erste Zahl: %d\n Zweite Zahl: %d\n", first, second); +swap_two_numbers(&first, &second); +printf("Erste Zahl: %d\n Zweite Zahl: %d\n", first, second); // Werte sind vertauscht. /* @@ -610,28 +610,28 @@ Grösse eines dynamischen Arrays herausgefunden werden kann. */ // Die Grösse des Arrays muss unbedingt mitgegeben werden. // Sonst hat die Funktion keine Ahnung wie gross das Array ist. -void ausgabe_int_array(int *arr, size_t size){ +void print_int_arrray(int *arr, size_t size){ int i; for (i = 0; i < size; i++){ printf("arr[%d] ist %d\n", i, arr[i]); } } -int mein_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; -int groesse = 10; -ausgabe_int_array(mein_array, groesse); +int my_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; +int size = 10; +print_int_array(my_array, size); // Wird folgendes ausgeben: "arr[0] ist 1" usw. // Wenn man auf externe Variable (ausserhalb der Funktion) referenziert, sollte // man das Schlüsselwort `extern` verwenden. int i = 0; -void test_funktion(){ +void test_function(){ extern int i; // i braucht nun die externe Variable i } // Das Schlüsselwort `static` macht, dass eine Variable ausserhalb der Kompilier- // einheit nicht zugreifbar ist. (Auf den meisten Systemen ist eine Kompiliereinheit -// eine `.c`-Datei.) Das Schlüsselwort `static` kann sowohl global +// eine `.c`-Datei.) Das Schlüsselwort `static` kann sowohl bei globalen // (zur Kompiliereinheit gehörende) Variablen, Funktionen und Funktionslokale // Variablen angewendet werden. // Wenn man `static` bei lokalen Variablen verwendet, so ist diese Variable global @@ -648,50 +648,50 @@ void test_funktion(){ //////////////////////////////////////////////// // `typedef`s können verwendet werden, um Typenaliase zu erstellen. -typedef int mein_typ; -mein_typ meine_typ_var = 0; +typedef int my_type; +my_type my_type_var = 0; // Structs sind lediglich Sammlungen von Daten, die Inhalte werden // (in der Reihenfolge wie sie geschrieben wurden) sequentiell alloziert. -struct rechteck{ - int breite; - int hoehe; +struct rectangle{ + int width; + int height; }; // Allgemein ist es nicht so, dass folgender Ausdruck wahr ist. -// sizeof(struct rechteck) == sizeof(int) + sizeof(int) +// sizeof(struct rectangle) == sizeof(int) + sizeof(int) // Dies ist so, weil potentiell ein Padding zwischen den Struktur-Inhalten // möglich ist). (siehe [1, Englisch]) -void funktion_1(){ - struct rechteck mein_rechteck; +void function_1(){ + struct rectangle my_rectangle; // Greife auf Struct-Inhalte mit `.` zu. - mein_rechteck.breite = 10; - mein_rechteck.hoehe = 20; + my_rectangle.width = 10; + my_rectangle.height = 20; // Du kannst Pointer zu Structs deklarieren. - struct rechteck *mein_rechteck_ptr = &mein_rechteck; + struct rectangle *my_rectangle_ptr = &my_rectangle; // Verwende Dereferenzierung, um Struct-Inhalte zu bearbeiten - (*mein_rechteck_ptr).breite = 30; + (*my_rectangle_ptr).width = 30; //Noch besser: Verwende die Kurzschreibweise ->, um die Lesbarkeit zu // verbessern. - mein_rechteck_ptr->hoehe = 10; // Gleich wie: (*mein_rechteck_ptr).hoehe = 10; + my_rectangle_ptr->height = 10; // Gleich wie: (*my_rectangle_ptr).height = 10; } // Aus Bequemlichkeitsgründen ist es möglich einem `struct` ein `typedef` hinzuzufügen. -typedef struct rechteck recht; +typedef struct rectangle rect; -int flaeche(recht r){ - return r.breite * r.hoehe; +int area(rect r){ + return r.width * r.height; } // Wenn du grosse Structs hast, kannst du diese mit dem Pointer kopieren, // damit grosse Kopiervorgänge vermieden werden. -int flaecheptr(const recht *r){ - return r->breite * r->hoehe; +int area_ptr(const rect *r){ + return r->width * r->height; } //////////////////////////////////////////////// @@ -724,10 +724,10 @@ Solange die Signaturen der Funktionen übereinstimmen, kann man sämtliche Funkt demselben Pointer zuweisen. Funktionspointer sind auf Grund der Einfacheit und Leserlichkeit normalerweise wie folgt `typedef`d */ -typedef void (*mein_fnp_type)(char *); +typedef void (*my_fnp_type)(char *); // Danach werden diese genutzt, um die wirkliche Pointervariable zu deklarieren. // .. -// mein_fnp_type f; +// my_fnp_type f; // Spezialzeichen // Im folgenden sin die englischen Begriffe jeweils in Klammern geschrieben, @@ -810,8 +810,8 @@ befindet wie die C-Quelldatei. // Eine sichere Möglichkeit, einen Header mehrere Male zu definieren bietet, das // folgende Statement. Die mehrfache Definition geschieht, wenn Kreisabhängigkeiten // bestehen. -#ifndef BEISPIEL_H /* Wenn BEISPIEL_H noch nicht definiert wurde */ -#define BEISPIEL_H /* definiere das Makro BEISPIEL_H */ +#ifndef EXAMPLE_H /* Wenn EXAMPLE_H noch nicht definiert wurde */ +#define EXAMPLE_H /* definiere das Makro EXAMPLE_H */ // Es könenn weitere Header innerhalb eines Headers eingebunden werden, was dazu // führt, dass diese bereits in anderen Dateien eingebunden wurden. So kann eine @@ -820,7 +820,7 @@ befindet wie die C-Quelldatei. // Wie in den Quelldateien können auch in den Header-Dateien Makros definiert // werden und in anderen Dateien verwendet werden, welche diesen Header einbinden. -#define BEISPIEL_NAME "Dennis Ritchie" +#define EXAMPLE_NAME "Dennis Ritchie" // Funktionsmakros können auch definiert werden. #define ADD(a, b) ((a) + (b)) @@ -833,18 +833,18 @@ befindet wie die C-Quelldatei. // Strukturen und Typendefinitionen können verwendet werden, um die Konsistenz // zwischen unterschiedlichen Dateien beizubehalten. -typedef struct Knoten{ - int wert; - struct Knoten *naechster; -}Knoten; +typedef struct Node{ + int value; + struct Node *next; +}Node; // Dies kann auch mit Aufzählungen gemacht werden. -enum ampel_status {GRUEN, GELB, ROT}; +enum traffic_light_state {GREEN, YELLOW, RED}; // Funktionsprototypen könenn auch in Header-Dateien definiert werden, um die // Funktion in unterschiedlichen Dateien zu verwenden, aber dies wird als schlechte // Praxis angesehen. Definitionen sollten in einer C-Datei erstellt werden. -Knoten erstelleVerketteteListe(int *werte, int laenge); +Node create_linked_list(int *value, int length); // Ausser den oben genannten Elementen, sollten weitere Definitionen in einer // C-Datei gemacht werden. Übermässige Includes und Definitionen sollten auch -- cgit v1.2.3 From 4670481fa27d60d59e837052d33740cfe21b4823 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 21:04:40 +0100 Subject: Added description for argc and argv --- de-de/c-de.html.markdown | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index dee05954..be74053b 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -76,9 +76,10 @@ int main(void){ // Die Kommandozeilenargumente, welche gebraucht werden, damit dein Programm // läuft, werden als Argumente der `main`-Funktion mitgegeben. -// argc steht für die Anzahl von Argumenten. - Der Programmname ist das erste -// Argument. -// argv ist ein Array von Zeichenarrays, welche die Argumente beinhaltet. +// argc (argument counter) steht für die Anzahl von Argumenten. +// Der Programmname ist das erste Argument. +// argv (argument vector) ist ein Array von Zeichenarrays, welche die +// Argumente beinhaltet. // argv[0] = Name des Programms // argv[1] = erstes Argument usw. int main (int argc, char** argv){ -- cgit v1.2.3 From 603af4b36e57e72f20f02c51f220923df47f8852 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 21:08:18 +0100 Subject: =?UTF-8?q?Changed=20gross=20to=20gro=C3=9F=20because=20it's=20de-?= =?UTF-8?q?de?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- de-de/c-de.html.markdown | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index be74053b..fee30734 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -98,18 +98,18 @@ int main (int argc, char** argv){ // C99-Konforme Compiler erlauben die Variablendeklaration an dem Punkt, an // welchem die Variable verwendet wird. - // integer sind normalerweise 4 Bytes gross + // integer sind normalerweise 4 Bytes groß int x_int = 0; - // shorts sind normalerweise 2 Bytes gross + // shorts sind normalerweise 2 Bytes groß short x_short = 0; - // chars sind garantiert 1 Byte gross + // chars sind garantiert 1 Byte groß char x_char = 0; char y_char = 'y'; // Charakterliterale werden mit '' gekennzeichnet. - // longs sind oft 4 bis 8 Bytes gross. long long sind garantiert mindestens - // 8 Bytes gross. + // longs sind oft 4 bis 8 Bytes groß. long long sind garantiert mindestens + // 8 Bytes groß. long x_long = 0; long long x_long_long = 0; @@ -610,7 +610,7 @@ Auch hier soll noch einmal erwähnt werden, dass es keinen Standard gibt, wie di Grösse eines dynamischen Arrays herausgefunden werden kann. */ // Die Grösse des Arrays muss unbedingt mitgegeben werden. -// Sonst hat die Funktion keine Ahnung wie gross das Array ist. +// Sonst hat die Funktion keine Ahnung wie groß das Array ist. void print_int_arrray(int *arr, size_t size){ int i; for (i = 0; i < size; i++){ @@ -689,8 +689,8 @@ int area(rect r){ return r.width * r.height; } -// Wenn du grosse Structs hast, kannst du diese mit dem Pointer kopieren, -// damit grosse Kopiervorgänge vermieden werden. +// Wenn du große Structs hast, kannst du diese mit dem Pointer kopieren, +// damit große Kopiervorgänge vermieden werden. int area_ptr(const rect *r){ return r->width * r->height; } -- cgit v1.2.3 From 06c51c70e1f79a54c9d99b48bdb1dd66d64818e6 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 21:19:06 +0100 Subject: Made whitespace more consistent --- de-de/c-de.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index fee30734..e5beb28f 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -270,7 +270,7 @@ int main (int argc, char** argv){ int e = 5; int f = 10; int z; - z = ( e > f) ? e : f; // => // => 10 "wenn e > f ist, gib e zurück, sonst f." + z = ( e > f ) ? e : f; // => // => 10 "wenn e > f ist, gib e zurück, sonst f." // Inkrementierungs- und Dekrementierungsoperatoren int j = 0; @@ -297,13 +297,13 @@ int main (int argc, char** argv){ //////////////////////////////////////////////// // Kontrollstrukturen //////////////////////////////////////////////// - if (0) { + if (0){ printf("Ich werde nie ausgeführt."); } else if (0){ printf("Ich werde auch nie ausgeführt."); } - else { + else{ printf("Ich gebe etwas aus."); } @@ -317,9 +317,9 @@ int main (int argc, char** argv){ printf("\n"); int kk = 0; - do { + do{ printf("%d, ", kk); - } while(++kk < 10); //++kk inkrementiert kk BEVOR der Wert gebraucht wurde. + }while(++kk < 10); //++kk inkrementiert kk BEVOR der Wert gebraucht wurde. // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " printf("\n"); -- cgit v1.2.3 From ec76a960a6e9f04b5fe75faa7301d5fa5eed7fdb Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 21:20:09 +0100 Subject: Removed section about goto --- de-de/c-de.html.markdown | 17 ----------------- 1 file changed, 17 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index e5beb28f..fceec5d4 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -364,23 +364,6 @@ int main (int argc, char** argv){ break; } - // Verwendung von "goto" in C - typedef enum { false, true } bool; - bool desaster = false; - int i, j; - for(i=0; i < 100; ++i){ - for (j=0; j < 100; ++j){ - if ((i + j ) >= 150){ - desaster = true; - } - if (desaster){ - goto error; - } - } - } -error: - printf("Ein Fehler ist aufgetreten bei i = %d & j ? %d\n", i, j); - //////////////////////////////////////////////// // Typenumwandlung //////////////////////////////////////////////// -- cgit v1.2.3 From 8ab886330e8cf8dc19301d16155c849371f35e66 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 21:25:23 +0100 Subject: reordered section about operators and changed variables to numbers --- de-de/c-de.html.markdown | 165 ++++++++++++++++++++++++----------------------- 1 file changed, 83 insertions(+), 82 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index fceec5d4..e493a303 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -88,6 +88,89 @@ int main (int argc, char** argv){ // \n steht für eine neue Zeile printf("%d\n",0); // => Gibt 0 aus. + //////////////////////////////////////////////// + // Operatoren + //////////////////////////////////////////////// + + // Kurzschreibweise für mehrere Deklarationen + int i1 = 1, i2 = 2; + flaot f1 = 1.0, f2 = 2.0; + + int b,c; + b = c = 0; + + // Arithmetik ist unkompliziert + 1 + 2; // => 3 + 2 - 1; // => 1 + 2 * 1; // => 2 + 1 / 2; // 0 (0.5, aber abgeschnitten, da es int sind.) + + // Man muss mindestens ein Integer zu einen float konvertieren, damit man als + // Resultat eine Gleitkommazahl erhält. + (float)1 / 2; // => 0.5f + 1 / (double)2; // => 0.5 // das gleiche mit dem Typ `double` + 1.0 / 2.0; // => 0.5, plus oder minus Epsilon + // Gleitkommazahlen und deren Berechnungen sind nicht exakt. + + // Es gibt auch die Möglichkeit, Modulo zu rechnen + 11 % 3; // => 2 + + // Vergleichsoperatoren sind vielleicht schon bekannt, aber in C gibt es + // keinen Boolean-Typ. In C verwenden wir `int`. (Oder _Bool oder bool in C99) + // 0 ist falsch, alles andere ist wahr (Die Vergleichsoperatoren ergeben + // immer 1 oder 0. + 3 == 2; // => 0 (falsch) + 3 != 2; // => 1 (wahr) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // C ist nicht Python - Vergleiche können nicht einfach verkettet werden. + // Warnung: die folgende Zeile wird kompilieren, aber es bedeutet `(0 < a) < 2`. + // Dieser Ausdruck ist immer wahr, weil (0 < a) kann entweder 1 oder 0 sein. + // In diesem Falle ist es 1, weil (0 < 1). + int zwischen_0_und_2 = 0 < a < 2; + // Benutze stattdessen folgende Schreibweise: + int zwischen_0_und_2 = 0 < a && a < 2; + + // Logik funktioniert auch mit ints + !3; // => 0 (logisches Nicht) + !0; // => 1 + 1 && 1; // => 1 (logisches Und) + 0 && 1; // => 0 + 0 || 1; // => 1 (logisches Oder) + 0 || 0; // => 0 + + // Bedingter ternärer Ausdruck ( ? : ) + int e = 5; + int f = 10; + int z; + z = ( e > f ) ? e : f; // => // => 10 "wenn e > f ist, gib e zurück, sonst f." + + // Inkrementierungs- und Dekrementierungsoperatoren + int j = 0; + int s = j++; // gib j zurück und erhöhe danach j. (s = 0, j = 1) + s = ++j; // erhöhe zuerst j und gib dann j zurück (s = 2, j = 2) + // das gleiche gilt für j-- und --j + + // Bitweise Operatoren + ~0x0F; // => 0xFFFFFFF0 (Bitweise Negation, "Einer-Komplement", + // Beispielresultat für 32-Bit int) + 0x0F & 0xF0; // => 0x00 (Bitweises UND) + 0x0F | 0xF0; // => 0xFF (Bitweises ODER) + 0x04 ^ 0x0F; // => 0x0B (Bitweises XOR) + 0x01 << 1; // => 0x02 (Bitweises Linksverschiebung (left shift) (um 1)) + 0x02 >> 1; // => 0x01 (Bitweises Rechtsverschiebung (right shift) (um 1)) + + // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern + // folgende Ausdrücke sind nicht definiert: + // - Verschiebung in das Vorzeichenbit (int a = 1 << 31) + // - Linksshift einer negativen Zahl (int a = -1 << 2) + // - Shift um einen Offset, welcher >= die Breite des linken Ausdrucks ist. + // int a = 1 << 32; // undefiniertes Verhalten, wenn int 32-Bit ist. + + //////////////////////////////////////////////// // Typen //////////////////////////////////////////////// @@ -212,88 +295,6 @@ int main (int argc, char** argv){ // Auf Elemente zugreifen: int array_int = multi_array[0][2]; // => 3 - //////////////////////////////////////////////// - // Operatoren - //////////////////////////////////////////////// - - // Kurzschreibweise für mehrere Deklarationen - int i1 = 1, i2 = 2; - flaot f1 = 1.0, f2 = 2.0; - - int b,c; - b = c = 0; - - // Arithmetik ist unkompliziert - i1 + i2; // => 3 - i2 - i1; // => 1 - i2 * i1; // => 2 - i1 / i2; // 0 (0.5, aber abgeschnitten, da es int sind.) - - // Man muss mindestens ein Integer zu einen float konvertieren, damit man als - // Resultat eine Gleitkommazahl erhält. - (float)i1 / i2; // => 0.5f - i1 / (double)i2; // => 0.5 // das gleiche mit dem Typ `double` - f1 / f2; // => 0.5, plus oder minus Epsilon - // Gleitkommazahlen und deren Berechnungen sind nicht exakt. - - // Es gibt auch die Möglichkeit, Modulo zu rechnen - 11 % 3; // => 2 - - // Vergleichsoperatoren sind vielleicht schon bekannt, aber in C gibt es - // keinen Boolean-Typ. In C verwenden wir `int`. (Oder _Bool oder bool in C99) - // 0 ist falsch, alles andere ist wahr (Die Vergleichsoperatoren ergeben - // immer 1 oder 0. - 3 == 2; // => 0 (falsch) - 3 != 2; // => 1 (wahr) - 3 > 2; // => 1 - 3 < 2; // => 0 - 2 <= 2; // => 1 - 2 >= 2; // => 1 - - // C ist nicht Python - Vergleiche können nicht einfach verkettet werden. - // Warnung: die folgende Zeile wird kompilieren, aber es bedeutet `(0 < a) < 2`. - // Dieser Ausdruck ist immer wahr, weil (0 < a) kann entweder 1 oder 0 sein. - // In diesem Falle ist es 1, weil (0 < 1). - int zwischen_0_und_2 = 0 < a < 2; - // Benutze stattdessen folgende Schreibweise: - int zwischen_0_und_2 = 0 < a && a < 2; - - // Logik funktioniert auch mit ints - !3; // => 0 (logisches Nicht) - !0; // => 1 - 1 && 1; // => 1 (logisches Und) - 0 && 1; // => 0 - 0 || 1; // => 1 (logisches Oder) - 0 || 0; // => 0 - - // Bedingter ternärer Ausdruck ( ? : ) - int e = 5; - int f = 10; - int z; - z = ( e > f ) ? e : f; // => // => 10 "wenn e > f ist, gib e zurück, sonst f." - - // Inkrementierungs- und Dekrementierungsoperatoren - int j = 0; - int s = j++; // gib j zurück und erhöhe danach j. (s = 0, j = 1) - s = ++j; // erhöhe zuerst j und gib dann j zurück (s = 2, j = 2) - // das gleiche gilt für j-- und --j - - // Bitweise Operatoren - ~0x0F; // => 0xFFFFFFF0 (Bitweise Negation, "Einer-Komplement", - // Beispielresultat für 32-Bit int) - 0x0F & 0xF0; // => 0x00 (Bitweises UND) - 0x0F | 0xF0; // => 0xFF (Bitweises ODER) - 0x04 ^ 0x0F; // => 0x0B (Bitweises XOR) - 0x01 << 1; // => 0x02 (Bitweises Linksverschiebung (left shift) (um 1)) - 0x02 >> 1; // => 0x01 (Bitweises Rechtsverschiebung (right shift) (um 1)) - - // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern - // folgende Ausdrücke sind nicht definiert: - // - Verschiebung in das Vorzeichenbit (int a = 1 << 31) - // - Linksshift einer negativen Zahl (int a = -1 << 2) - // - Shift um einen Offset, welcher >= die Breite des linken Ausdrucks ist. - // int a = 1 << 32; // undefiniertes Verhalten, wenn int 32-Bit ist. - //////////////////////////////////////////////// // Kontrollstrukturen //////////////////////////////////////////////// -- cgit v1.2.3 From ca042dcb65e65af210c5ee26de5237478d911d23 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 21:44:15 +0100 Subject: =?UTF-8?q?Changed=20all=20occurences=20of=20ss=20to=20=C3=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit I have changed all occurences of 'ss' to 'ß' according to duden.de --- de-de/c-de.html.markdown | 48 ++++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 24 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index e493a303..ffa64bcc 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -16,7 +16,7 @@ manuellen Speicherverwaltung bewusst sein. > **Über Compiler Optionen** > -> Standardmässig sind `gcc` und `clang` ziemlich ruhig bezüglich Warnungen und +> Standardmäßig sind `gcc` und `clang` ziemlich ruhig bezüglich Warnungen und > Fehlern, obwohl dies sehr nützliche Informationen sein können. Es wird > empfohlen, strengere Compiler Optionen zu verwenden. Hier sind einige empfohlene > Standards: @@ -203,7 +203,7 @@ int main (int argc, char** argv){ double x_double = 0.0; // echte Zahlen ohne Suffix sind vom Typ double // integer-Typen können vorzeichenlos (unsigned) sein - // (grösser oder kleiner als 0) + // (größer oder kleiner als 0) unsigned short ux_short; unsigned int ux_int; unsigned long long ux_long_long; @@ -213,24 +213,24 @@ int main (int argc, char** argv){ '0'; // => 48 im ASCII-Zeichensatz 'A'; // => 65 im ASCII-Zeichensatz - // sizeof(T) gibt die Grösse einer Variablen des Typen T in Bytes zurück. - // sizeof(obj) ergibt die Grösse des Ausdrucks (Variable, Literal usw.) + // sizeof(T) gibt die Größe einer Variablen des Typen T in Bytes zurück. + // sizeof(obj) ergibt die Größe des Ausdrucks (Variable, Literal usw.) printf("%zu\n", sizeof(int)); // => 4 (auf den Rechnern mit einem 4-Byte-Wort) // Wenn das Argument des `sizeof`-Operator ein Ausdruck ist, dann wird das - // Argument nicht ausgewertet (ausser Arrays mit variabler Länge) + // Argument nicht ausgewertet (außer Arrays mit variabler Länge) // Der Wert, der in diesem Fall zurückgegeben wird, ist eine Konstante zur // Kompillierzeit. int a = 1; //size_t ist ein vorzeichenloser Integer Typ mit mindestens 2 Byte um die - // Grösse eines Objekts zu repräsentieren. + // Größe eines Objekts zu repräsentieren. size_t size = sizeof(a++); // a++ wird nicht ausgewertet printf("sizeof(a++) = %zu, wobei a=%d ist\n", size, a); // Gibt "sizeof(a++) = 4, wobei a=1 ist" aus (mit einer 32-Bit-Architektur) - // Arrays müssen mit einer Grösse initialisiert werden. + // Arrays müssen mit einer Größe initialisiert werden. char my_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes int my_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. // unter der Voraussetzung eines 4-Byte-Worts. @@ -245,7 +245,7 @@ int main (int argc, char** argv){ // Allerdings muss die Länge des Arrays dann zur Laufzeit ausgewertet werden: size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]); // WARNUNG: Wenn dieser Ansatz gewählt wird, muss man sicherstellen, dass die - // Grösse des Arrays ermittelt werden *bevor* dieser einer Funktion als + // Größe des Arrays ermittelt werden *bevor* dieser einer Funktion als // Argument weitergegeben wird (siehe Diskussion weiter unten), weil Arrays // einer Funktion nur als Zeiger übergeben werden. => Das obere Statement // würde innerhalb einer Funktion ein falsches Resultat liefern. @@ -259,17 +259,17 @@ int main (int argc, char** argv){ printf("%d\n", my_array[1]); // => 2 // In C99 (und als optionales Feature in C11) können Arrays mit variabler - // Länge deklariert werden. Die Grösse eines solchen Array muss eine Konstante + // Länge deklariert werden. Die Größe eines solchen Array muss eine Konstante // zur Kompilierzeit sein. - printf("Geben Sie die Arraygrösse an: "); //Frag den Benutzer nach - // der Arraygrösse + printf("Geben Sie die Arraygröße an: "); //Frag den Benutzer nach + // der Arraygröße int array_size; fcsanf(stdin, "%d", &array_size); int var_length_array[array_size]; // deklariere Array mit variabler Länge printf("sizeof array =%zu\n", sizeof var_length_array); // Zum Beispiel: - // > Geben Sie die Arraygrösse an: 10 + // > Geben Sie die Arraygröße an: 10 // > sizeof array = 40 // Strings sind lediglich Arrays von `chars`, welche mit einem Null-Byte @@ -398,7 +398,7 @@ int main (int argc, char** argv){ // In diesem Tutorial wird das deutsche Wort Zeiger nicht verwendet, da es // bei einer weiteren Recherche einfacher ist, wenn man von Pointern ausgeht. - // Ausserdem ist der Begriff Pointer auch im deutschen Sprachgebrauch zu finden. + // Außerdem ist der Begriff Pointer auch im deutschen Sprachgebrauch zu finden. // Ein Pointer ist eine Variable, welche deklariert wurde, um eine Speicher- // adresse zu speichern. Die Deklaration eines Pointers wird auch zeigen, @@ -433,7 +433,7 @@ int main (int argc, char** argv){ // Arrays sind eine gute Möglichekit, einen zusammenhängenden Block von // Speicher zu allozieren. - int x_array[20]; // deklariert einen Array der Grösse 20 (Grösse kann + int x_array[20]; // deklariert einen Array der Größe 20 (Größe kann // nicht geändert werden.) int xx; for (xx =0; xx < 20; xx++){ @@ -591,9 +591,9 @@ Wenn man Arrays betrachtet, so werden diese immer als Pointer übergeben. Auch wenn die Arrays statisch alloziert werden (wie zum Beispiel `arr[10]`), werden diese als Pointer zum ersten Element des Arrays übergeben. Auch hier soll noch einmal erwähnt werden, dass es keinen Standard gibt, wie die -Grösse eines dynamischen Arrays herausgefunden werden kann. +Größe eines dynamischen Arrays herausgefunden werden kann. */ -// Die Grösse des Arrays muss unbedingt mitgegeben werden. +// Die Größe des Arrays muss unbedingt mitgegeben werden. // Sonst hat die Funktion keine Ahnung wie groß das Array ist. void print_int_arrray(int *arr, size_t size){ int i; @@ -607,25 +607,25 @@ int size = 10; print_int_array(my_array, size); // Wird folgendes ausgeben: "arr[0] ist 1" usw. -// Wenn man auf externe Variable (ausserhalb der Funktion) referenziert, sollte +// Wenn man auf externe Variable (außerhalb der Funktion) referenziert, sollte // man das Schlüsselwort `extern` verwenden. int i = 0; void test_function(){ extern int i; // i braucht nun die externe Variable i } -// Das Schlüsselwort `static` macht, dass eine Variable ausserhalb der Kompilier- +// Das Schlüsselwort `static` macht, dass eine Variable außerhalb der Kompilier- // einheit nicht zugreifbar ist. (Auf den meisten Systemen ist eine Kompiliereinheit // eine `.c`-Datei.) Das Schlüsselwort `static` kann sowohl bei globalen // (zur Kompiliereinheit gehörende) Variablen, Funktionen und Funktionslokale // Variablen angewendet werden. // Wenn man `static` bei lokalen Variablen verwendet, so ist diese Variable global // erreichbar und behält dessen Wert über Funktionsaufrufe hinweg, aber sie ist -// nur innerhalb der deklarierten Funktion verfügbar. Ausserdem werden statische +// nur innerhalb der deklarierten Funktion verfügbar. Außerdem werden statische // Variablen mit 0 initialisiert, wenn sie nicht mit einem anderen Startwert // initialisiert werden. // Es ist auch möglich, Funktionen als statisch zu deklarieren, damit diese -// `private` sind. Privat heisst, dass sie nur in diesem Kontekt sichtbar sind. +// `private` sind. Privat heißt, dass sie nur in diesem Kontekt sichtbar sind. //////////////////////////////////////////////// @@ -782,7 +782,7 @@ typedef void (*my_fnp_type)(char *); /* Header-Dateien sind ein wichtiger Teil von C, da sie eine Verbindung zwischen -unterschiedlichen C-Quelldateien herstellen. Ausserdem vereinfachen Header-Dateien +unterschiedlichen C-Quelldateien herstellen. Außerdem vereinfachen Header-Dateien den Code und Definitionen, da diese in separaten Dateien geschrieben werden können. Header-Dateien sind von der Syntax her ähnlich zu C-Quelldateien, allerdings haben @@ -831,8 +831,8 @@ enum traffic_light_state {GREEN, YELLOW, RED}; // Praxis angesehen. Definitionen sollten in einer C-Datei erstellt werden. Node create_linked_list(int *value, int length); -// Ausser den oben genannten Elementen, sollten weitere Definitionen in einer -// C-Datei gemacht werden. Übermässige Includes und Definitionen sollten auch +// Außer den oben genannten Elementen, sollten weitere Definitionen in einer +// C-Datei gemacht werden. Übermäßige Includes und Definitionen sollten auch // nicht einer Header-Datei gemacht werden. Stattdessen wird es empfohlen, diese // in eine separate Header-Datei oder in eine C-Quelldatei zu schreiben. @@ -855,7 +855,7 @@ Eine weitere gute Resource ist [Learn C The Hard Way](http://learncodethehardway Solltest du Fragen zu C haben, so lies die FAQ [compl.lang.c Frequently Asked Questions](http://c-faq.com).[Englisch] -Ausserdem ist es wichtig, eine saubere Einrückung zu verwenden. Des weiteren ist +Außerdem ist es wichtig, eine saubere Einrückung zu verwenden. Des weiteren ist es wichtig, dass der Codestil möglichst konsistent ist. Es ist wichtiger, lesbaren Code zu schreiben als Code, welcher clever und schnell ist. Es lohnt sich ein Blick auf den [Codestil des Linuxkernel](https://www.kernel.org/doc/Documentation/process/coding-style.rst) zu werfen. [Englisch] -- cgit v1.2.3 From e48d05c98d3415a5c5edd7d8c3931cd5e68976f5 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 23:08:38 +0100 Subject: added link to useful compiler options --- de-de/c-de.html.markdown | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index ffa64bcc..05b26dd2 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -22,6 +22,11 @@ manuellen Speicherverwaltung bewusst sein. > Standards: > `-Wall -Wextra -Werror -O2 -std=c99 -pedantic` > +> Da gewisse Optionen (inbesondere der C-Standard) sehr stark vom Projekt +> abhängen, lohnt es sich, wenn die unterschiedlichen Optionen genauer +> angeschaut werden. Eine Übersicht über die Compiler-Optionen findet man unter +> [diesem](https://stackoverflow.com/questions/3375697/useful-gcc-flags-for-c) Stackoverflow-Beitrag. +> > Für weitere Informationen, was diese und weitere Optionen genau machen, > sollte die Man-Page des C-Compilers aufgerufen werden (z.B. `man 1 gcc`). > Alternativ kann auch online nach den unterschiedlichen Optionen gesucht werden. -- cgit v1.2.3 From e24e38a1b984307bb5e68d231060f7024d908618 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 23:08:55 +0100 Subject: Fixed small typo Resource => Ressource --- de-de/c-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 05b26dd2..1976a6e8 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -855,7 +855,7 @@ Unkorrektheiten (d.h. Ideen, welche nicht mehr als gut empfunden werden.) oder mittlerweile geänderte Praktiken enthält. [Hinweis: Das Buch wurde auf Englisch geschrieben, es gibt aber auch eine Übersetzung davon] -Eine weitere gute Resource ist [Learn C The Hard Way](http://learncodethehardway.org/c/). +Eine weitere gute Ressource ist [Learn C The Hard Way](http://learncodethehardway.org/c/). [Englisch] Solltest du Fragen zu C haben, so lies die FAQ [compl.lang.c Frequently Asked Questions](http://c-faq.com).[Englisch] -- cgit v1.2.3 From fbb24b487e0f847a54b6317dea22dfd6b850c12e Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 2 Feb 2020 23:09:36 +0100 Subject: Removed unnecessary lines about google --- de-de/c-de.html.markdown | 3 --- 1 file changed, 3 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 1976a6e8..3dcb5ab9 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -865,7 +865,4 @@ es wichtig, dass der Codestil möglichst konsistent ist. Es ist wichtiger, lesba Code zu schreiben als Code, welcher clever und schnell ist. Es lohnt sich ein Blick auf den [Codestil des Linuxkernel](https://www.kernel.org/doc/Documentation/process/coding-style.rst) zu werfen. [Englisch] -Wenn die erwähnte Literatur dein Problem nicht löst, denke daran: -"Google ist dein Freund" - [1] [Why isn't sizeof for a struct equal to the sum of sizeof of each member?](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member) -- cgit v1.2.3 From c7e03628fc70ce300f1d57528c709fc29b35e25e Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 9 Feb 2020 23:01:52 +0100 Subject: started fixing the translation --- de-de/d-de.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'de-de') diff --git a/de-de/d-de.html.markdown b/de-de/d-de.html.markdown index 2b0b38dd..9cebd9f2 100644 --- a/de-de/d-de.html.markdown +++ b/de-de/d-de.html.markdown @@ -9,7 +9,7 @@ lang: de-de --- ```c -// Es war klar dass das kommt... +// Es war klar, dass das kommt... module hello; import std.stdio; @@ -20,10 +20,10 @@ void main(string[] args) { } ``` -Wenn du so wie ich bist und viel zeit im Internet verbringst stehen die Chancen gut -das du schonmal über [D](http://dlang.org/) gehört hast. -Die D-Sprache ist eine moderne, überall einsetzbare programmiersprache die von Low bis -High Level verwendet werden kann und dabei viele Stile anbietet. +Wenn du so wie ich bist und viel Zeit im Internet verbringst, stehen die Chancen +gut, dass du schonmal über [D](http://dlang.org/) gehört hast. +Die D-Sprache ist eine moderne, überall einsetzbare programmiersprache die von +Low bis High Level verwendet werden kann und dabei viele Stile anbietet. D wird aktiv von Walter Bright und Andrei Alexandrescu entwickelt, zwei super schlaue, richtig coole leute. Da das jetzt alles aus dem weg ist - auf zu den Beispielen! -- cgit v1.2.3 From 5c06bbba578ac019cd74cbeabcb21e42cffc5b42 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 9 Feb 2020 23:20:16 +0100 Subject: fixed some typos in German translation --- de-de/d-de.html.markdown | 54 ++++++++++++++++++++++++------------------------ 1 file changed, 27 insertions(+), 27 deletions(-) (limited to 'de-de') diff --git a/de-de/d-de.html.markdown b/de-de/d-de.html.markdown index 9cebd9f2..28ecc7ae 100644 --- a/de-de/d-de.html.markdown +++ b/de-de/d-de.html.markdown @@ -26,7 +26,7 @@ Die D-Sprache ist eine moderne, überall einsetzbare programmiersprache die von Low bis High Level verwendet werden kann und dabei viele Stile anbietet. D wird aktiv von Walter Bright und Andrei Alexandrescu entwickelt, zwei super schlaue, -richtig coole leute. Da das jetzt alles aus dem weg ist - auf zu den Beispielen! +richtig coole leute. Da das jetzt alles aus dem Weg ist - auf zu den Beispielen! ```c import std.stdio; @@ -38,7 +38,7 @@ void main() { writeln(i); } - auto n = 1; // auto um den typ vom Compiler bestimmen zu lassen + auto n = 1; // auto um den Typ vom Compiler bestimmen zu lassen // Zahlenliterale können _ verwenden für lesbarkeit while(n < 10_000) { @@ -68,21 +68,22 @@ void main() { } ``` -Neue Typen können mit `struct`, `class`, `union`, und `enum` definiert werden. Structs und unions -werden as-value (koppiert) an methoden übergeben wogegen Klassen als Referenz übergeben werden. -Templates können verwendet werden um alle typen zu parameterisieren. +Neue Typen können mit `struct`, `class`, `union`, und `enum` definiert werden. +Structs und unions werden as-value (koppiert) an Methoden übergeben wogegen +Klassen als Referenz übergeben werden. Templates können verwendet werden um +alle Typen zu parameterisieren. ```c // Hier, T ist ein Type-Parameter, Er funktioniert wie Generics in C#/Java/C++ struct LinkedList(T) { T data = null; - LinkedList!(T)* next; // Das ! wird verwendet um T zu übergeben. ( in C#/Java/C++) + LinkedList!(T)* next; // Das ! wird verwendet, um T zu übergeben. ( in C#/Java/C++) } class BinTree(T) { T data = null; - // Wenn es nur einen T parameter gibt können die Klammern um ihn weggelassen werden + // Wenn es nur einen T Parameter gibt, können die Klammern um ihn weggelassen werden BinTree!T left; BinTree!T right; } @@ -97,7 +98,7 @@ enum Day { Saturday, } -// Aliase können verwendet werden um die Entwicklung zu erleichtern +// Aliase können verwendet werden, um die Entwicklung zu erleichtern alias IntList = LinkedList!int; alias NumTree = BinTree!double; @@ -111,8 +112,8 @@ T max(T)(T a, T b) { return a; } -// Steht ref vor einem Parameter wird sichergestellt das er als Referenz übergeben wird. -// Selbst bei werten wird es immer eine Referenz sein. +// Steht ref vor einem Parameter, wird sichergestellt, dass er als Referenz +übergeben wird. Selbst bei Werten wird es immer eine Referenz sein. void swap(T)(ref T a, ref T b) { auto temp = a; @@ -120,18 +121,18 @@ void swap(T)(ref T a, ref T b) { b = temp; } -// Templates können ebenso werte parameterisieren. +// Templates können ebenso Werte parameterisieren. class Matrix(uint m, uint n, T = int) { T[m] rows; T[n] columns; } -auto mat = new Matrix!(3, 3); // Standardmäßig ist T vom typ Integer +auto mat = new Matrix!(3, 3); // Standardmäßig ist T vom Typ Integer ``` Wo wir schon bei Klassen sind - Wie wäre es mit Properties! Eine Property -ist eine Funktion die wie ein Wert agiert. Das gibt uns viel klarere Syntax +ist eine Funktion, die wie ein Wert agiert. Das gibt uns viel klarere Syntax im Stil von `structure.x = 7` was gleichgültig wäre zu `structure.setX(7)` ```c @@ -187,18 +188,17 @@ void main() { ``` Mit properties können wir sehr viel logik hinter unseren gettern -und settern hinter einer schönen syntax verstecken +und settern hinter einer schönen Syntax verstecken -Other object-oriented goodies at our disposal Andere Objektorientierte features sind beispielsweise `interface`s, `abstract class` und `override`. Vererbung funktioniert in D wie in Java: -Erben von einer Klasse, so viele interfaces wie man will. +Erben von einer Klasse, so viele Interfaces wie man will. -Jetzt haben wir Objektorientierung in D gesehen aber schauen +Jetzt haben wir Objektorientierung in D gesehen, aber schauen wir uns noch was anderes an. -D bietet funktionale programmierung mit _first-class functions_ -puren funktionen und unveränderbare daten. +D bietet funktionale Programmierung mit _first-class functions_ +puren Funktionen und unveränderbaren Daten. Zusätzlich können viele funktionale Algorithmen wie z.B map, filter, reduce und friends im `std.algorithm` Modul gefunden werden! @@ -207,11 +207,11 @@ import std.algorithm : map, filter, reduce; import std.range : iota; // builds an end-exclusive range void main() { - // Wir wollen die summe aller quadratzahlen zwischen + // Wir wollen die Summe aller Quadratzahlen zwischen // 1 und 100 ausgeben. Nichts leichter als das! - // Einfach eine lambda funktion als template parameter übergeben - // Es ist genau so gut möglich eine normale funktion hier zu übergeben + // Einfach eine Lambda-Funktion als Template Parameter übergeben + // Es ist genau so gut möglich eine normale Funktion hier zu übergeben // Lambdas bieten sich hier aber an. auto num = iota(1, 101).filter!(x => x % 2 == 0) .map!(y => y ^^ 2) @@ -221,13 +221,13 @@ void main() { } ``` -Ist dir aufgefallen wie wir eine Haskell-Style pipeline gebaut haben +Ist dir aufgefallen, wie wir eine Haskell-Style Pipeline gebaut haben um num zu berechnen? Das war möglich durch die Uniform Function Call Syntax. -Mit UFCS können wir auswählen ob wir eine Funktion als Methode oder +Mit UFCS können wir auswählen, ob wir eine Funktion als Methode oder als freie Funktion aufrufen. Walters artikel dazu findet ihr [hier.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) -Kurzgesagt kann man Funktionen deren erster parameter vom typ A ist, als +Kurzgesagt kann man Funktionen, deren erster Parameter vom typ A ist, als Methode auf A anwenden. Parrallel Computing ist eine Tolle sache, findest du nicht auch? @@ -239,10 +239,10 @@ import std.math : sqrt; void main() { // Wir wollen die Wurzel von jeder Zahl in unserem Array berechnen - // und dabei alle Kerne verwenden die wir zur verfügung haben + // und dabei alle Kerne verwenden, die wir zur verfügung haben auto arr = new double[1_000_000]; - // Wir verwenden den index und das element als referenz + // Wir verwenden den Index und das Element als Referenz // und rufen einfach parallel auf! foreach(i, ref elem; parallel(arr)) { ref = sqrt(i + 1.0); -- cgit v1.2.3 From ad9048580270350e751bb5734b57f59890fd2c4a Mon Sep 17 00:00:00 2001 From: caminsha Date: Mon, 10 Feb 2020 20:28:04 +0100 Subject: fixed some small typos in German translation --- de-de/python3-de.html.markdown | 33 ++++++++++++--------------------- 1 file changed, 12 insertions(+), 21 deletions(-) (limited to 'de-de') diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown index 4ef997a1..e9695fff 100644 --- a/de-de/python3-de.html.markdown +++ b/de-de/python3-de.html.markdown @@ -42,7 +42,7 @@ Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Pyth # Eine Division kann mit "//" für positive sowie negative Werte abgerundet werden. 5 // 3 # => 1 -5.0 // 3.0 # => 1.0 # works on floats too +5.0 // 3.0 # => 1.0 # funktioniert auch mit floats -5 // 3 # => -2 -5.0 // 3.0 # => -2.0 @@ -119,10 +119,10 @@ False or True #=> True "{name} will {food} essen".format(name="Bob", food="Lasagne") #=> "Bob will Lasagne kochen" -#Falls dein Python 3 Code auch unter Python 2.5 oder darunter laufen soll, kann das alte Format benutzt werden: +#Falls dein Python3 Code auch unter Python 2.5 oder darunter laufen soll, +# kann das alte Format benutzt werden: "%s können %s werden" % ("Strings", "interpoliert") - # None ist ein Objekt None #=> None @@ -131,8 +131,6 @@ None #=> None "etc" is None #=> False None is None #=> True - - # None, 0, und leere Strings/Listen werden alle als False bewertet. # Alle anderen Werte sind True bool(0) # => False @@ -140,7 +138,6 @@ bool("") # => False bool([]) #=> False bool({}) #=> False - #################################################### ## 2. Variablen und Collections #################################################### @@ -208,7 +205,6 @@ li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6] # Die Länge der Liste mit len ermitteln len(li) #=> 6 - # Tupel sind wie Listen, nur unveränderlich. tup = (1, 2, 3) tup[0] #=> 1 @@ -224,10 +220,9 @@ tup[:2] #=> (1, 2) a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3 # Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen d, e, f = 4, 5, 6 -# Es ist kinderleicht zwei Werte zu tauschen +# Es ist kinderleicht, zwei Werte zu tauschen e, d = d, e # d ist nun 5 und e ist nun 4 - # Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare empty_dict = {} # Hier ein gefülltes Wörterbuch @@ -270,7 +265,6 @@ filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} # Schlüssel von einem Wörterbuch entfernen del filled_dict["one"] # Entfert den Schlüssel "one" - # Sets speichern Mengen empty_set = set() # Initialisieren wir ein Set mit ein paar Werten @@ -379,7 +373,8 @@ with open("meineDatei.txt") as f: print(line) # Python bietet ein fundamentales Konzept der Iteration. -# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable". +# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode +# angewandt wird, heißt auf Englisch "iterable". # Die range Methode gibt ein solches Objekt aus. filled_dict = {"one": 1, "two": 2, "three": 3} @@ -390,14 +385,14 @@ print(our_iterable) #=> range(1,10). Dies ist ein "iterable" Objekt. for i in our_iterable: print(i) # Gibt one, two, three aus -# Allerdings können wir die einzelnen Elemente nicht mit ihrem index ausgeben +# Allerdings können wir die einzelnen Elemente nicht mit ihrem Index ausgeben our_iterable[1] # TypeError # Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft. our_iterator = iter(our_iterable) -# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat während wir durch es gehen. -# Das jeweils nächste Objekt bekommen wir mit "next()" +# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat +# während wir durch es gehen. Das jeweils nächste Objekt bekommen wir mit "next()" next(our_iterator) #=> "one" # Es hält den vorherigen Status @@ -410,8 +405,6 @@ next(our_iterator) # Gibt StopIteration aus # Alle Elemente können mit "list()" ausgegeben werden list(filled_dict.keys()) #=> ["one", "two", "three"] - - #################################################### ## 4. Funktionen #################################################### @@ -579,12 +572,11 @@ math.sqrt(16) == m.sqrt(16) #=> True import math dir(math) - #################################################### ## 7. Fortgeschritten #################################################### -# Generatoren helfen um Code schnell und einfach zu schreiben +# Generatoren helfen, um Code schnell und einfach zu schreiben def double_numbers(iterable): for i in iterable: yield i + i @@ -594,7 +586,7 @@ def double_numbers(iterable): # iteration. Das heißt, Werte größer als 15 werden nicht behandelt. # Die range-Methode ist auch ein Generator. Im Fall einer Liste von 1-900000000 # würde das sehr viel Zeit in Anspruch nehmen. -# Wenn wir eine variable mit einem Namen erschaffen wollen, das +# Wenn wir eine Variable mit einem Namen erschaffen wollen, das # normalerweise mit einem Python - Schlüsselwort kollidieren würde, # benutzen wir einen Unterstrich nach dem Wort. range_ = range(1, 900000000) @@ -604,10 +596,9 @@ for i in double_numbers(range_): if i >= 30: break - # Dekoratoren # In diesem Beispiel die Methode beg umwickelt say -# Beim Aufruf von beg, say wird aufgerufen +# Beim Aufruf von beg, wird say aufgerufen # Falls say_please true ist, ändert sich die ausgegebene Nachricht from functools import wraps -- cgit v1.2.3 From 1adab9bc3f80d82123987ff34083568030735db7 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 04:49:56 +0100 Subject: Rename Python 2 markdown files into 'pythonlegacy' ``` for f in $(find . -iname "*python*" | grep -vE 'python3|git|statcomp'); do flegacy=$(echo "$f" | sed 's/python/pythonlegacy/') git mv "$f" "$flegacy" done ``` --- de-de/python-de.html.markdown | 766 ------------------------------------ de-de/pythonlegacy-de.html.markdown | 766 ++++++++++++++++++++++++++++++++++++ 2 files changed, 766 insertions(+), 766 deletions(-) delete mode 100644 de-de/python-de.html.markdown create mode 100644 de-de/pythonlegacy-de.html.markdown (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown deleted file mode 100644 index ee77683e..00000000 --- a/de-de/python-de.html.markdown +++ /dev/null @@ -1,766 +0,0 @@ ---- -language: python -contributors: - - ["Louie Dinh", "http://ldinh.ca"] -translators: - - ["kultprok", "http:/www.kulturproktologie.de"] -filename: learnpython-de.py -lang: de-de ---- - -Anmerkungen des ursprünglichen Autors: -Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode. - -Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service] - -Hinweis: Dieser Beitrag bezieht sich besonders auf Python 2.7, er sollte aber auf Python 2.x anwendbar sein. Haltet Ausschau nach einem Rundgang durch Python 3, der bald erscheinen soll. - -```python -# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz) -""" Mehrzeilige Strings werden mit - drei '-Zeichen geschrieben und werden - oft als Kommentare genutzt. -""" - -#################################################### -## 1. Primitive Datentypen und Operatoren -#################################################### - -# Die Zahlen -3 #=> 3 - -# Mathematik funktioniert so, wie man das erwartet -1 + 1 #=> 2 -8 - 1 #=> 7 -10 * 2 #=> 20 -35 / 5 #=> 7 - -# Division ist ein wenig kniffliger. Ganze Zahlen werden ohne Rest dividiert -# und das Ergebnis wird automatisch abgerundet. -5 / 2 #=> 2 - -# Um das zu ändern, müssen wir Gleitkommazahlen einführen und benutzen -2.0 # Das ist eine Gleitkommazahl -11.0 / 4.0 #=> 2.75 Ahhh...schon besser - -# Rangfolge wird mit Klammern erzwungen -(1 + 3) * 2 #=> 8 - -# Boolesche Ausdrücke sind primitive Datentypen -True -False - -# Mit not wird negiert -not True #=> False -not False #=> True - -# Gleichheit ist == -1 == 1 #=> True -2 == 1 #=> False - -# Ungleichheit ist != -1 != 1 #=> False -2 != 1 #=> True - -# Ein paar weitere Vergleiche -1 < 10 #=> True -1 > 10 #=> False -2 <= 2 #=> True -2 >= 2 #=> True - -# Vergleiche können verknüpft werden! -1 < 2 < 3 #=> True -2 < 3 < 2 #=> False - -# Strings werden mit " oder ' gebildet -"Das ist ein String." -'Das ist auch ein String.' - -# Strings können addiert werden! -"Hello " + "world!" #=> "Hello world!" - -# Ein String kann wie eine Liste von Zeichen verwendet werden -"Das ist ein String"[0] #=> 'D' - -# Mit % können Strings formatiert werden, etwa so: -"%s können %s werden" % ("Strings", "interpoliert") - -# Ein modernerer Weg, um Strings zu formatieren, ist die format-Methode. -# Diese Methode wird bevorzugt -"{0} können {1} werden".format("Strings", "formatiert") -# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen. -"{name} will {food} essen".format(name="Bob", food="Lasagne") - -# None ist ein Objekt -None #=> None - -# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen -# Benutzt stattdessen `is` -"etc" is None #=> False -None is None #=> True - -# Der 'is'-Operator testet Objektidentität. Das ist nicht -# sehr nützlich, wenn wir mit primitiven Datentypen arbeiten, aber -# sehr nützlich bei Objekten. - -# None, 0, und leere Strings/Listen werden alle als False bewertet. -# Alle anderen Werte sind True -0 == False #=> True -"" == False #=> True - - -#################################################### -## 2. Variablen und Collections -#################################################### - -# Textausgabe ist sehr einfach -print "Ich bin Python. Schön, dich kennenzulernen!" - - -# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren. -some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm -some_var #=> 5 - -# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus. -# Unter "Kontrollstruktur" kann noch mehr über -# Ausnahmebehandlung erfahren werden. -some_other_var # Löst einen NameError aus - -# if kann als Ausdruck verwendet werden -"yahoo!" if 3 > 2 else 2 #=> "yahoo!" - -# Listen speichern Sequenzen -li = [] -# Wir können mit einer bereits gefüllten Liste anfangen -other_li = [4, 5, 6] - -# append fügt Daten am Ende der Liste ein -li.append(1) #li ist jetzt [1] -li.append(2) #li ist jetzt [1, 2] -li.append(4) #li ist jetzt [1, 2, 4] -li.append(3) #li ist jetzt [1, 2, 4, 3] -# Vom Ende der Liste mit pop entfernen -li.pop() #=> 3 und li ist jetzt [1, 2, 4] -# und dann wieder hinzufügen -li.append(3) # li ist jetzt wieder [1, 2, 4, 3]. - -# Greife auf Listen wie auf Arrays zu -li[0] #=> 1 -# Das letzte Element ansehen -li[-1] #=> 3 - -# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError -li[4] # Raises an IndexError - -# Wir können uns Ranges mit Slice-Syntax ansehen -li[1:3] #=> [2, 4] -# Den Anfang auslassen -li[2:] #=> [4, 3] -# Das Ende auslassen -li[:3] #=> [1, 2, 4] - -# Ein bestimmtes Element mit del aus der Liste entfernen -del li[2] # li ist jetzt [1, 2, 3] - -# Listen können addiert werden -li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen - -# Listen mit extend verknüpfen -li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6] - -# Mit in auf Existenz eines Elements prüfen -1 in li #=> True - -# Die Länge der Liste mit len ermitteln -len(li) #=> 6 - - -# Tupel sind wie Listen, nur unveränderlich. -tup = (1, 2, 3) -tup[0] #=> 1 -tup[0] = 3 # Löst einen TypeError aus - -# Wir können all diese Listen-Dinge auch mit Tupeln anstellen -len(tup) #=> 3 -tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) -tup[:2] #=> (1, 2) -2 in tup #=> True - -# Wir können Tupel (oder Listen) in Variablen entpacken -a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3 -# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen -d, e, f = 4, 5, 6 -# Es ist kinderleicht zwei Werte zu tauschen -e, d = d, e # d is now 5 and e is now 4 - - -# Dictionarys (Wörterbucher) speichern Key-Value-Paare -empty_dict = {} -# Hier ein gefülltes Wörterbuch -filled_dict = {"one": 1, "two": 2, "three": 3} - -# Wir können Einträge mit [] nachschlagen -filled_dict["one"] #=> 1 - -# So holen wir alle Keys (Schlüssel) als Liste -filled_dict.keys() #=> ["three", "two", "one"] -# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert. -# Einzelne Resultate können anders angeordnet sein. - -# Alle Values (Werte) als Liste -filled_dict.values() #=> [3, 2, 1] -# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln. - -# Das Vorhandensein eines Schlüssels im Wörterbuch mit in prüfen -"one" in filled_dict #=> True -1 in filled_dict #=> False - -# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus -filled_dict["four"] # KeyError - -# Mit der get-Methode verhindern wir das -filled_dict.get("one") #=> 1 -filled_dict.get("four") #=> None -# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt -filled_dict.get("one", 4) #=> 1 -filled_dict.get("four", 4) #=> 4 - -# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen -filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt -filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5 - - -# Sets speichern Mengen -empty_set = set() -# Initialisieren wir ein Set mit ein paar Werten -some_set = set([1,2,2,3,4]) # some_set ist jetzt set([1, 2, 3, 4]) - -# Seit Python 2.7 kann {} benutzt werden, um ein Set zu erstellen -filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} - -# Mehr Elemente hinzufügen -filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} - -# Schnittmengen werden mit & gebildet -other_set = {3, 4, 5, 6} -filled_set & other_set #=> {3, 4, 5} - -# Mengen werden mit | vereinigt -filled_set | other_set #=> {1, 2, 3, 4, 5, 6} - -# Die Differenz einer Menge mit - bilden -{1,2,3,4} - {2,3,5} #=> {1, 4} - -# Auf Vorhandensein von Elementen mit in prüfen -2 in filled_set #=> True -10 in filled_set #=> False - - -#################################################### -## 3. Kontrollstruktur -#################################################### - -# Erstellen wir mal eine Variable -some_var = 5 - -# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig! -# gibt "some_var ist kleiner als 10" aus -if some_var > 10: - print "some_var ist viel größer als 10." -elif some_var < 10: # Dieser elif-Absatz ist optional. - print "some_var ist kleiner als 10." -else: # Das hier ist auch optional. - print "some_var ist tatsächlich 10." - - -""" -For-Schleifen iterieren über Listen -Ausgabe: - hund ist ein Säugetier - katze ist ein Säugetier - maus ist ein Säugetier -""" -for animal in ["hund", "katze", "maus"]: - # Wir können Strings mit % formatieren - print "%s ist ein Säugetier" % animal - -""" -`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder -Ausgabe: - 0 - 1 - 2 - 3 -""" -for i in range(4): - print i - -""" -While-Schleifen laufen, bis eine Bedingung erfüllt ist. -Ausgabe: - 0 - 1 - 2 - 3 -""" -x = 0 -while x < 4: - print x - x += 1 # Kurzform für x = x + 1 - -# Ausnahmebehandlung mit einem try/except-Block - -# Funktioniert in Python 2.6 und höher: -try: - # Mit raise wird ein Fehler ausgegeben - raise IndexError("Das hier ist ein Index-Fehler") -except IndexError as e: - pass # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären. - - -#################################################### -## 4. Funktionen -#################################################### - -# Mit def neue Funktionen erstellen -def add(x, y): - print "x ist %s und y ist %s" % (x, y) - return x + y # Werte werden mit return zurückgegeben - -# Funktionen mit Parametern aufrufen -add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück - -# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente -add(y=6, x=5) # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden. - -# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren -def varargs(*args): - return args - -varargs(1, 2, 3) #=> (1,2,3) - - -# Wir können auch Funktionen mit beliebiger Anzahl -# Schlüsselwort-Argumenten definieren -def keyword_args(**kwargs): - return kwargs - -# Rufen wir es mal auf, um zu sehen, was passiert -keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} - -# Wir können beides gleichzeitig machem, wenn wir wollen -def all_the_args(*args, **kwargs): - print args - print kwargs -""" -all_the_args(1, 2, a=3, b=4) Ausgabe: - (1, 2) - {"a": 3, "b": 4} -""" - -# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen! -# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs. -args = (1, 2, 3, 4) -kwargs = {"a": 3, "b": 4} -all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4) -all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4) -all_the_args(*args, **kwargs) # äquivalent zu foo(1, 2, 3, 4, a=3, b=4) - -# Python hat First-Class-Funktionen -def create_adder(x): - def adder(y): - return x + y - return adder - -add_10 = create_adder(10) -add_10(3) #=> 13 - -# Es gibt auch anonyme Funktionen -(lambda x: x > 2)(3) #=> True - -# Es gibt auch Funktionen höherer Ordnung als Built-Ins -map(add_10, [1,2,3]) #=> [11, 12, 13] -filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] - -# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen -[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] -[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] - - -#################################################### -## 5. Module -#################################################### - -# Wir können Module importieren -import math -print math.sqrt(16) #=> 4.0 - -# Wir können auch nur spezielle Funktionen eines Moduls importieren -from math import ceil, floor -print ceil(3.7) #=> 4.0 -print floor(3.7) #=> 3.0 - -# Wir können auch alle Funktionen eines Moduls importieren -# Warnung: Dies wird nicht empfohlen -from math import * - -# Wir können Modulnamen abkürzen -import math as m -math.sqrt(16) == m.sqrt(16) #=> True - -# Module sind in Python nur gewöhnliche Dateien. Wir -# können unsere eigenen schreiben und importieren. Der Name des -# Moduls ist der Dateiname. - -# Wir können herausfinden, welche Funktionen und Attribute in einem -# Modul definiert sind. -import math -dir(math) - -# Wenn Sie ein Python-Skript namens math.py im selben Ordner -# wie Ihr aktuelles Skript haben, wird die Datei math.py -# anstelle des integrierten Python-Moduls geladen. -# Dies geschieht, weil der lokale Ordner Vorrang -# vor den in Python integrierten Bibliotheken hat. - - -#################################################### -## 6. Klassen -#################################################### - -# Wir verwenden das Schlüsselwort "class" um eine Klasse zu erzeugen. -class Human(object): - - # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt - species = "H. sapiens" - - # Ein simpler Konstruktor, wird aufgerufen, wenn diese Klasse instanziiert wird. - # Beachten Sie, dass die doppelten vorangestellten und nachgestellten - # Unterstriche Objekte oder Attribute bezeichnen, die von Python verwendet werden, - # aber in benutzergesteuerten Namespaces leben. - # Methoden (oder Objekte oder Attribute) wie: __init__, __str__, __repr__ usw. - # werden als Sondermethoden (oder manchmal als Dundermethoden bezeichnet) bezeichnet. - # Sie sollten solche Namen nicht selbst erfinden. - def __init__(self, name): - # Wir weisen das Argument name dem name-Attribut der Instanz zu - self.name = name - - # Eine Instanzmethode. Alle Methoden erhalten "self" als erstes Argument. - def say(self, msg): - return "%s: %s" % (self.name, msg) - - # Eine weitere Instanzmethode - def sing(self): - return 'yo... yo... microphone check... one two... one two...' - - # Eine Klassenmethode wird von allen Instanzen geteilt. - # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen - @classmethod - def get_species(cls): - return cls.species - - # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen - @staticmethod - def grunt(): - return "*grunt*" - - # Eine Eigenschaft (Property) ist wie ein Getter. -    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen. -    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben. - @property - def age(self): - return self._age - -    # Damit kann die Eigenschaft festgelegt werden - @age.setter - def age(self, age): - self._age = age - -    # Damit kann die Eigenschaft gelöscht werden - @age.deleter - def age(self): - del self._age - -# Wenn ein Python-Interpreter eine Quelldatei liest, führt er den gesamten Code aus. -# Diese __name__-Prüfung stellt sicher, dass dieser Codeblock nur ausgeführt wird, -# wenn dieses Modul das Hauptprogramm ist. -if __name__ == '__main__': - # Eine Instanz einer Klasse erstellen - i = Human(name="Ian") - i.say("hi") # "Ian: hi" - j = Human("Joel") - j.say("hello") # "Joel: hello" - # i und j sind Instanzen des Typs Mensch, oder anders ausgedrückt: Sie sind Objekte des Menschen - - # Rufen wir unsere Klassenmethode auf - i.say(i.get_species()) # "Ian: H. sapiens" - - # Ändern wir das gemeinsame Attribut - Human.species = "H. neanderthalensis" - i.say(i.get_species()) # => "Ian: H. neanderthalensis" - j.say(j.get_species()) # => "Joel: H. neanderthalensis" - - # Aufruf der statischen Methode - print(Human.grunt()) # => "*grunt*" - - # Kann keine statische Methode mit Instanz des Objekts aufrufen, - # da i.grunt () automatisch "self" (das Objekt i) als Argument verwendet - print(i.grunt()) # => TypeError: grunt() takes 0 positional arguments but 1 was given - - # Die Eigenschaft für diese Instanz aktualisieren - i.age = 42 - # die Eigenschaft auslesen - i.say(i.age) # => "Ian: 42" - j.say(j.age) # => "Joel: 0" - # die Eigenschaft löschen - del i.age - # i.age # => würde einen AttributeError werfen - -#################################################### -## 6.1 Inheritance -#################################################### - -# Vererbung ermöglicht die Definition neuer untergeordneter Klassen, -# die Methoden und Variablen von ihrer übergeordneten Klasse erben. - -# Wenn Sie die oben definierte Human-Klasse als Basis- oder Elternklasse verwenden, -# können Sie eine untergeordnete Klasse, Superhero, definieren, die die Klassenvariablen -# wie "species", "name" und "age" sowie Methoden wie "sing" und "grunzen" aus der Klasse Human erbt. -# Die Untergeordnete Klasse kann aber auch eigene Eigenschaften haben. - -# Um von der Modularisierung per Datei zu profitieren, können Sie die Klassen -# in ihren eigenen Dateien platzieren, z. B. human.py - -# Um Funktionen aus anderen Dateien zu importieren, verwenden Sie das folgende Format -# from "Dateiname-ohne-Erweiterung" impotr "Funktion-oder-Klasse" - -from human import Human - -# Geben Sie die übergeordnete(n) Klasse(n) als Parameter für die Klassendefinition an -class Superhero(Human): - - # Wenn die untergeordnete Klasse alle Definitionen des übergeordneten Elements - # ohne Änderungen erben soll, können Sie einfach das Schlüsselwort "pass" - # (und nichts anderes) verwenden. In diesem Fall wird jedoch auskommentiert, - # um eine eindeutige untergeordnete Klasse zuzulassen: - # pass - - # Kindklassen können die Attribute ihrer Eltern überschreiben - species = 'Superhuman' - - # Kinder erben automatisch den Konstruktor ihrer übergeordneten Klasse - # einschließlich ihrer Argumente, können aber auch zusätzliche Argumente oder - # Definitionen definieren und ihre Methoden zB den Klassenkonstruktor überschreiben. - # Dieser Konstruktor erbt das Argument "name" von der Klasse "Human" und - # fügt die Argumente "superpowers" und "movie" hinzu: - def __init__(self, name, movie=False, - superpowers=["super strength", "bulletproofing"]): - - # zusätzliche Klassenattribute hinzufügen: - self.fictional = True - self.movie = movie - # Beachten Sie die veränderlichen Standardwerte, da die Standardwerte gemeinsam genutzt werden - self.superpowers = superpowers - - # Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse - # zugreifen, die vom untergeordneten Objekt überschrieben werden, - # in diesem Fall die Methode __init__. -        # Dies ruft den Konstruktor der übergeordneten Klasse auf: - super().__init__(name) - - # überschreiben der "sing" Methode - def sing(self): - return 'Dun, dun, DUN!' - - # eine zusätzliche Instanzmethode hinzufügen - def boast(self): - for power in self.superpowers: - print("I wield the power of {pow}!".format(pow=power)) - -if __name__ == '__main__': - sup = Superhero(name="Tick") - - # Instanztypprüfungen - if isinstance(sup, Human): - print('I am human') - if type(sup) is Superhero: - print('I am a superhero') - - # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird. -    # Dieses Attribut ist dynamisch und kann aktualisiert werden. - print(Superhero.__mro__) # => (, - # => , ) - - # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut - print(sup.get_species()) # => Superhuman - - # Ruft die überschriebene Methode auf - print(sup.sing()) # => Dun, dun, DUN! - - # Ruft die Methode von Human auf - sup.say('Spoon') # => Tick: Spoon - - # Aufruf einer Methode, die nur in Superhero existiert - sup.boast() # => I wield the power of super strength! - # => I wield the power of bulletproofing! - - # Vererbtes Klassenattribut - sup.age = 31 - print(sup.age) # => 31 - - # Attribut, das nur in Superhero existiert - print('Am I Oscar eligible? ' + str(sup.movie)) - -#################################################### -## 6.2 Multiple Inheritance -#################################################### - -# Eine weitere Klassendefinition -# bat.py - -class Bat: - - species = 'Baty' - - def __init__(self, can_fly=True): - self.fly = can_fly - - # This class also has a say method - def say(self, msg): - msg = '... ... ...' - return msg - - # And its own method as well - def sonar(self): - return '))) ... (((' - -if __name__ == '__main__': - b = Bat() - print(b.say('hello')) - print(b.fly) - -# Und noch eine andere Klassendefinition, die von Superhero und Bat erbt -# superhero.py -from superhero import Superhero -from bat import Bat - -# Definieren Sie Batman als eine Kindklasse, das von Superheld und Bat erbt -class Batman(Superhero, Bat): - - def __init__(self, *args, **kwargs): - # In der Regel müssen Sie super aufrufen, um Attribute zu erben: - # super (Batman, selbst) .__ init__ (* args, ** kwargs) - # Allerdings handelt es sich hier um Mehrfachvererbung, und super() - # funktioniert nur mit der nächsten Basisklasse in der MRO-Liste. - # Stattdessen rufen wir explizit __init__ für alle Vorfahren auf. - # Die Verwendung von *args und **kwargs ermöglicht die saubere Übergabe von - # Argumenten, wobei jedes übergeordnete Element eine Schicht der Zwiebel "abschält". - Superhero.__init__(self, 'anonymous', movie=True, - superpowers=['Wealthy'], *args, **kwargs) - Bat.__init__(self, *args, can_fly=False, **kwargs) - # überschreibt den Wert für das Namensattribut - self.name = 'Sad Affleck' - - def sing(self): - return 'nan nan nan nan nan batman!' - -if __name__ == '__main__': - sup = Batman() - - # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, - # die sowohl von getattr() als auch von super() verwendet wird. - # Dieses Attribut ist dynamisch und kann aktualisiert werden. - print(Batman.__mro__) # => (, - # => , - # => , - # => , ) - - # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut - print(sup.get_species()) # => Superhuman - - # Ruft die überschriebene Methode auf - print(sup.sing()) # => nan nan nan nan nan batman! - - # Ruft die Methode von Human auf, weil die Reihenfolge der Vererbung wichtig ist - sup.say('I agree') # => Sad Affleck: I agree - - # Aufrufmethode, die nur im 2. Vorfahren existiert - print(sup.sonar()) # => ))) ... ((( - - # Vererbtes Klassenattribut - sup.age = 100 - print(sup.age) # => 100 - - # Vererbtes Attribut vom 2. Vorfahren, dessen Standardwert überschrieben wurde. - print('Can I fly? ' + str(sup.fly)) # => Can I fly? False - - -#################################################### -## 7. Fortgeschrittenes -#################################################### - -# Generatoren helfen Ihnen, lazy Code zu erstellen. -def double_numbers(iterable): - for i in iterable: - yield i + i - -# Generatoren sind speichereffizient, da sie nur die Daten laden, -# die zur Verarbeitung des nächsten Werts in der iterierbaren Komponente -# erforderlich sind. Dadurch können sie ansonsten unzulässig große Wertebereiche ausführen. -# HINWEIS: `range` ersetzt` xrange` in Python 3. -for i in double_numbers(range(1, 900000000)): # `range` ist ein Generator. - print(i) - if i >= 30: - break - -# Genauso wie Sie ein 'list comprehension' (Listen Abstraktion) erstellen können, können Sie auch 'generator comprehension' (Generator Abstraktion) erstellen. -values = (-x for x in [1,2,3,4,5]) -for x in values: - print(x) # prints -1 -2 -3 -4 -5 to console/terminal - -# Sie können eine Generator Abstraktion auch direkt in eine Liste umwandeln (casten). -values = (-x for x in [1,2,3,4,5]) -gen_to_list = list(values) -print(gen_to_list) # => [-1, -2, -3, -4, -5] - -# Decorators -# In diesem Beispiel umschliesst "beg" "say". Wenn say_please True ist, wird die zurückgegebene Nachricht geändert. -from functools import wraps - -def beg(target_function): - @wraps(target_function) - def wrapper(*args, **kwargs): - msg, say_please = target_function(*args, **kwargs) - if say_please: - return "{} {}".format(msg, "Please! I am poor :(") - return msg - - return wrapper - -@beg -def say(say_please=False): - msg = "Can you buy me a beer?" - return msg, say_please - - -print(say()) # Can you buy me a beer? -print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( - -``` - -## Lust auf mehr? - -### Kostenlos online (Englisch) - -* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) -* [Dive Into Python](http://www.diveintopython.net/) -* [The Official Docs](http://docs.python.org/2.6/) -* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) -* [Python Module of the Week](http://pymotw.com/2/) - -### Totholz (Englisch) - -* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) -* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) -* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) - diff --git a/de-de/pythonlegacy-de.html.markdown b/de-de/pythonlegacy-de.html.markdown new file mode 100644 index 00000000..ee77683e --- /dev/null +++ b/de-de/pythonlegacy-de.html.markdown @@ -0,0 +1,766 @@ +--- +language: python +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["kultprok", "http:/www.kulturproktologie.de"] +filename: learnpython-de.py +lang: de-de +--- + +Anmerkungen des ursprünglichen Autors: +Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode. + +Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service] + +Hinweis: Dieser Beitrag bezieht sich besonders auf Python 2.7, er sollte aber auf Python 2.x anwendbar sein. Haltet Ausschau nach einem Rundgang durch Python 3, der bald erscheinen soll. + +```python +# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz) +""" Mehrzeilige Strings werden mit + drei '-Zeichen geschrieben und werden + oft als Kommentare genutzt. +""" + +#################################################### +## 1. Primitive Datentypen und Operatoren +#################################################### + +# Die Zahlen +3 #=> 3 + +# Mathematik funktioniert so, wie man das erwartet +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# Division ist ein wenig kniffliger. Ganze Zahlen werden ohne Rest dividiert +# und das Ergebnis wird automatisch abgerundet. +5 / 2 #=> 2 + +# Um das zu ändern, müssen wir Gleitkommazahlen einführen und benutzen +2.0 # Das ist eine Gleitkommazahl +11.0 / 4.0 #=> 2.75 Ahhh...schon besser + +# Rangfolge wird mit Klammern erzwungen +(1 + 3) * 2 #=> 8 + +# Boolesche Ausdrücke sind primitive Datentypen +True +False + +# Mit not wird negiert +not True #=> False +not False #=> True + +# Gleichheit ist == +1 == 1 #=> True +2 == 1 #=> False + +# Ungleichheit ist != +1 != 1 #=> False +2 != 1 #=> True + +# Ein paar weitere Vergleiche +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# Vergleiche können verknüpft werden! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Strings werden mit " oder ' gebildet +"Das ist ein String." +'Das ist auch ein String.' + +# Strings können addiert werden! +"Hello " + "world!" #=> "Hello world!" + +# Ein String kann wie eine Liste von Zeichen verwendet werden +"Das ist ein String"[0] #=> 'D' + +# Mit % können Strings formatiert werden, etwa so: +"%s können %s werden" % ("Strings", "interpoliert") + +# Ein modernerer Weg, um Strings zu formatieren, ist die format-Methode. +# Diese Methode wird bevorzugt +"{0} können {1} werden".format("Strings", "formatiert") +# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen. +"{name} will {food} essen".format(name="Bob", food="Lasagne") + +# None ist ein Objekt +None #=> None + +# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen +# Benutzt stattdessen `is` +"etc" is None #=> False +None is None #=> True + +# Der 'is'-Operator testet Objektidentität. Das ist nicht +# sehr nützlich, wenn wir mit primitiven Datentypen arbeiten, aber +# sehr nützlich bei Objekten. + +# None, 0, und leere Strings/Listen werden alle als False bewertet. +# Alle anderen Werte sind True +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Variablen und Collections +#################################################### + +# Textausgabe ist sehr einfach +print "Ich bin Python. Schön, dich kennenzulernen!" + + +# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren. +some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm +some_var #=> 5 + +# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus. +# Unter "Kontrollstruktur" kann noch mehr über +# Ausnahmebehandlung erfahren werden. +some_other_var # Löst einen NameError aus + +# if kann als Ausdruck verwendet werden +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Listen speichern Sequenzen +li = [] +# Wir können mit einer bereits gefüllten Liste anfangen +other_li = [4, 5, 6] + +# append fügt Daten am Ende der Liste ein +li.append(1) #li ist jetzt [1] +li.append(2) #li ist jetzt [1, 2] +li.append(4) #li ist jetzt [1, 2, 4] +li.append(3) #li ist jetzt [1, 2, 4, 3] +# Vom Ende der Liste mit pop entfernen +li.pop() #=> 3 und li ist jetzt [1, 2, 4] +# und dann wieder hinzufügen +li.append(3) # li ist jetzt wieder [1, 2, 4, 3]. + +# Greife auf Listen wie auf Arrays zu +li[0] #=> 1 +# Das letzte Element ansehen +li[-1] #=> 3 + +# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError +li[4] # Raises an IndexError + +# Wir können uns Ranges mit Slice-Syntax ansehen +li[1:3] #=> [2, 4] +# Den Anfang auslassen +li[2:] #=> [4, 3] +# Das Ende auslassen +li[:3] #=> [1, 2, 4] + +# Ein bestimmtes Element mit del aus der Liste entfernen +del li[2] # li ist jetzt [1, 2, 3] + +# Listen können addiert werden +li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen + +# Listen mit extend verknüpfen +li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6] + +# Mit in auf Existenz eines Elements prüfen +1 in li #=> True + +# Die Länge der Liste mit len ermitteln +len(li) #=> 6 + + +# Tupel sind wie Listen, nur unveränderlich. +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Löst einen TypeError aus + +# Wir können all diese Listen-Dinge auch mit Tupeln anstellen +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Wir können Tupel (oder Listen) in Variablen entpacken +a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3 +# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen +d, e, f = 4, 5, 6 +# Es ist kinderleicht zwei Werte zu tauschen +e, d = d, e # d is now 5 and e is now 4 + + +# Dictionarys (Wörterbucher) speichern Key-Value-Paare +empty_dict = {} +# Hier ein gefülltes Wörterbuch +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Wir können Einträge mit [] nachschlagen +filled_dict["one"] #=> 1 + +# So holen wir alle Keys (Schlüssel) als Liste +filled_dict.keys() #=> ["three", "two", "one"] +# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert. +# Einzelne Resultate können anders angeordnet sein. + +# Alle Values (Werte) als Liste +filled_dict.values() #=> [3, 2, 1] +# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln. + +# Das Vorhandensein eines Schlüssels im Wörterbuch mit in prüfen +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus +filled_dict["four"] # KeyError + +# Mit der get-Methode verhindern wir das +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen +filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt +filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5 + + +# Sets speichern Mengen +empty_set = set() +# Initialisieren wir ein Set mit ein paar Werten +some_set = set([1,2,2,3,4]) # some_set ist jetzt set([1, 2, 3, 4]) + +# Seit Python 2.7 kann {} benutzt werden, um ein Set zu erstellen +filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Mehr Elemente hinzufügen +filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} + +# Schnittmengen werden mit & gebildet +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# Mengen werden mit | vereinigt +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# Die Differenz einer Menge mit - bilden +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Auf Vorhandensein von Elementen mit in prüfen +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Kontrollstruktur +#################################################### + +# Erstellen wir mal eine Variable +some_var = 5 + +# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig! +# gibt "some_var ist kleiner als 10" aus +if some_var > 10: + print "some_var ist viel größer als 10." +elif some_var < 10: # Dieser elif-Absatz ist optional. + print "some_var ist kleiner als 10." +else: # Das hier ist auch optional. + print "some_var ist tatsächlich 10." + + +""" +For-Schleifen iterieren über Listen +Ausgabe: + hund ist ein Säugetier + katze ist ein Säugetier + maus ist ein Säugetier +""" +for animal in ["hund", "katze", "maus"]: + # Wir können Strings mit % formatieren + print "%s ist ein Säugetier" % animal + +""" +`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder +Ausgabe: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +While-Schleifen laufen, bis eine Bedingung erfüllt ist. +Ausgabe: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Kurzform für x = x + 1 + +# Ausnahmebehandlung mit einem try/except-Block + +# Funktioniert in Python 2.6 und höher: +try: + # Mit raise wird ein Fehler ausgegeben + raise IndexError("Das hier ist ein Index-Fehler") +except IndexError as e: + pass # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären. + + +#################################################### +## 4. Funktionen +#################################################### + +# Mit def neue Funktionen erstellen +def add(x, y): + print "x ist %s und y ist %s" % (x, y) + return x + y # Werte werden mit return zurückgegeben + +# Funktionen mit Parametern aufrufen +add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück + +# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente +add(y=6, x=5) # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden. + +# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# Wir können auch Funktionen mit beliebiger Anzahl +# Schlüsselwort-Argumenten definieren +def keyword_args(**kwargs): + return kwargs + +# Rufen wir es mal auf, um zu sehen, was passiert +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# Wir können beides gleichzeitig machem, wenn wir wollen +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4) Ausgabe: + (1, 2) + {"a": 3, "b": 4} +""" + +# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen! +# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4) +all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4) +all_the_args(*args, **kwargs) # äquivalent zu foo(1, 2, 3, 4, a=3, b=4) + +# Python hat First-Class-Funktionen +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Es gibt auch anonyme Funktionen +(lambda x: x > 2)(3) #=> True + +# Es gibt auch Funktionen höherer Ordnung als Built-Ins +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + + +#################################################### +## 5. Module +#################################################### + +# Wir können Module importieren +import math +print math.sqrt(16) #=> 4.0 + +# Wir können auch nur spezielle Funktionen eines Moduls importieren +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Wir können auch alle Funktionen eines Moduls importieren +# Warnung: Dies wird nicht empfohlen +from math import * + +# Wir können Modulnamen abkürzen +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Module sind in Python nur gewöhnliche Dateien. Wir +# können unsere eigenen schreiben und importieren. Der Name des +# Moduls ist der Dateiname. + +# Wir können herausfinden, welche Funktionen und Attribute in einem +# Modul definiert sind. +import math +dir(math) + +# Wenn Sie ein Python-Skript namens math.py im selben Ordner +# wie Ihr aktuelles Skript haben, wird die Datei math.py +# anstelle des integrierten Python-Moduls geladen. +# Dies geschieht, weil der lokale Ordner Vorrang +# vor den in Python integrierten Bibliotheken hat. + + +#################################################### +## 6. Klassen +#################################################### + +# Wir verwenden das Schlüsselwort "class" um eine Klasse zu erzeugen. +class Human(object): + + # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt + species = "H. sapiens" + + # Ein simpler Konstruktor, wird aufgerufen, wenn diese Klasse instanziiert wird. + # Beachten Sie, dass die doppelten vorangestellten und nachgestellten + # Unterstriche Objekte oder Attribute bezeichnen, die von Python verwendet werden, + # aber in benutzergesteuerten Namespaces leben. + # Methoden (oder Objekte oder Attribute) wie: __init__, __str__, __repr__ usw. + # werden als Sondermethoden (oder manchmal als Dundermethoden bezeichnet) bezeichnet. + # Sie sollten solche Namen nicht selbst erfinden. + def __init__(self, name): + # Wir weisen das Argument name dem name-Attribut der Instanz zu + self.name = name + + # Eine Instanzmethode. Alle Methoden erhalten "self" als erstes Argument. + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # Eine weitere Instanzmethode + def sing(self): + return 'yo... yo... microphone check... one two... one two...' + + # Eine Klassenmethode wird von allen Instanzen geteilt. + # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen + @classmethod + def get_species(cls): + return cls.species + + # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen + @staticmethod + def grunt(): + return "*grunt*" + + # Eine Eigenschaft (Property) ist wie ein Getter. +    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen. +    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben. + @property + def age(self): + return self._age + +    # Damit kann die Eigenschaft festgelegt werden + @age.setter + def age(self, age): + self._age = age + +    # Damit kann die Eigenschaft gelöscht werden + @age.deleter + def age(self): + del self._age + +# Wenn ein Python-Interpreter eine Quelldatei liest, führt er den gesamten Code aus. +# Diese __name__-Prüfung stellt sicher, dass dieser Codeblock nur ausgeführt wird, +# wenn dieses Modul das Hauptprogramm ist. +if __name__ == '__main__': + # Eine Instanz einer Klasse erstellen + i = Human(name="Ian") + i.say("hi") # "Ian: hi" + j = Human("Joel") + j.say("hello") # "Joel: hello" + # i und j sind Instanzen des Typs Mensch, oder anders ausgedrückt: Sie sind Objekte des Menschen + + # Rufen wir unsere Klassenmethode auf + i.say(i.get_species()) # "Ian: H. sapiens" + + # Ändern wir das gemeinsame Attribut + Human.species = "H. neanderthalensis" + i.say(i.get_species()) # => "Ian: H. neanderthalensis" + j.say(j.get_species()) # => "Joel: H. neanderthalensis" + + # Aufruf der statischen Methode + print(Human.grunt()) # => "*grunt*" + + # Kann keine statische Methode mit Instanz des Objekts aufrufen, + # da i.grunt () automatisch "self" (das Objekt i) als Argument verwendet + print(i.grunt()) # => TypeError: grunt() takes 0 positional arguments but 1 was given + + # Die Eigenschaft für diese Instanz aktualisieren + i.age = 42 + # die Eigenschaft auslesen + i.say(i.age) # => "Ian: 42" + j.say(j.age) # => "Joel: 0" + # die Eigenschaft löschen + del i.age + # i.age # => würde einen AttributeError werfen + +#################################################### +## 6.1 Inheritance +#################################################### + +# Vererbung ermöglicht die Definition neuer untergeordneter Klassen, +# die Methoden und Variablen von ihrer übergeordneten Klasse erben. + +# Wenn Sie die oben definierte Human-Klasse als Basis- oder Elternklasse verwenden, +# können Sie eine untergeordnete Klasse, Superhero, definieren, die die Klassenvariablen +# wie "species", "name" und "age" sowie Methoden wie "sing" und "grunzen" aus der Klasse Human erbt. +# Die Untergeordnete Klasse kann aber auch eigene Eigenschaften haben. + +# Um von der Modularisierung per Datei zu profitieren, können Sie die Klassen +# in ihren eigenen Dateien platzieren, z. B. human.py + +# Um Funktionen aus anderen Dateien zu importieren, verwenden Sie das folgende Format +# from "Dateiname-ohne-Erweiterung" impotr "Funktion-oder-Klasse" + +from human import Human + +# Geben Sie die übergeordnete(n) Klasse(n) als Parameter für die Klassendefinition an +class Superhero(Human): + + # Wenn die untergeordnete Klasse alle Definitionen des übergeordneten Elements + # ohne Änderungen erben soll, können Sie einfach das Schlüsselwort "pass" + # (und nichts anderes) verwenden. In diesem Fall wird jedoch auskommentiert, + # um eine eindeutige untergeordnete Klasse zuzulassen: + # pass + + # Kindklassen können die Attribute ihrer Eltern überschreiben + species = 'Superhuman' + + # Kinder erben automatisch den Konstruktor ihrer übergeordneten Klasse + # einschließlich ihrer Argumente, können aber auch zusätzliche Argumente oder + # Definitionen definieren und ihre Methoden zB den Klassenkonstruktor überschreiben. + # Dieser Konstruktor erbt das Argument "name" von der Klasse "Human" und + # fügt die Argumente "superpowers" und "movie" hinzu: + def __init__(self, name, movie=False, + superpowers=["super strength", "bulletproofing"]): + + # zusätzliche Klassenattribute hinzufügen: + self.fictional = True + self.movie = movie + # Beachten Sie die veränderlichen Standardwerte, da die Standardwerte gemeinsam genutzt werden + self.superpowers = superpowers + + # Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse + # zugreifen, die vom untergeordneten Objekt überschrieben werden, + # in diesem Fall die Methode __init__. +        # Dies ruft den Konstruktor der übergeordneten Klasse auf: + super().__init__(name) + + # überschreiben der "sing" Methode + def sing(self): + return 'Dun, dun, DUN!' + + # eine zusätzliche Instanzmethode hinzufügen + def boast(self): + for power in self.superpowers: + print("I wield the power of {pow}!".format(pow=power)) + +if __name__ == '__main__': + sup = Superhero(name="Tick") + + # Instanztypprüfungen + if isinstance(sup, Human): + print('I am human') + if type(sup) is Superhero: + print('I am a superhero') + + # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird. +    # Dieses Attribut ist dynamisch und kann aktualisiert werden. + print(Superhero.__mro__) # => (, + # => , ) + + # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut + print(sup.get_species()) # => Superhuman + + # Ruft die überschriebene Methode auf + print(sup.sing()) # => Dun, dun, DUN! + + # Ruft die Methode von Human auf + sup.say('Spoon') # => Tick: Spoon + + # Aufruf einer Methode, die nur in Superhero existiert + sup.boast() # => I wield the power of super strength! + # => I wield the power of bulletproofing! + + # Vererbtes Klassenattribut + sup.age = 31 + print(sup.age) # => 31 + + # Attribut, das nur in Superhero existiert + print('Am I Oscar eligible? ' + str(sup.movie)) + +#################################################### +## 6.2 Multiple Inheritance +#################################################### + +# Eine weitere Klassendefinition +# bat.py + +class Bat: + + species = 'Baty' + + def __init__(self, can_fly=True): + self.fly = can_fly + + # This class also has a say method + def say(self, msg): + msg = '... ... ...' + return msg + + # And its own method as well + def sonar(self): + return '))) ... (((' + +if __name__ == '__main__': + b = Bat() + print(b.say('hello')) + print(b.fly) + +# Und noch eine andere Klassendefinition, die von Superhero und Bat erbt +# superhero.py +from superhero import Superhero +from bat import Bat + +# Definieren Sie Batman als eine Kindklasse, das von Superheld und Bat erbt +class Batman(Superhero, Bat): + + def __init__(self, *args, **kwargs): + # In der Regel müssen Sie super aufrufen, um Attribute zu erben: + # super (Batman, selbst) .__ init__ (* args, ** kwargs) + # Allerdings handelt es sich hier um Mehrfachvererbung, und super() + # funktioniert nur mit der nächsten Basisklasse in der MRO-Liste. + # Stattdessen rufen wir explizit __init__ für alle Vorfahren auf. + # Die Verwendung von *args und **kwargs ermöglicht die saubere Übergabe von + # Argumenten, wobei jedes übergeordnete Element eine Schicht der Zwiebel "abschält". + Superhero.__init__(self, 'anonymous', movie=True, + superpowers=['Wealthy'], *args, **kwargs) + Bat.__init__(self, *args, can_fly=False, **kwargs) + # überschreibt den Wert für das Namensattribut + self.name = 'Sad Affleck' + + def sing(self): + return 'nan nan nan nan nan batman!' + +if __name__ == '__main__': + sup = Batman() + + # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, + # die sowohl von getattr() als auch von super() verwendet wird. + # Dieses Attribut ist dynamisch und kann aktualisiert werden. + print(Batman.__mro__) # => (, + # => , + # => , + # => , ) + + # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut + print(sup.get_species()) # => Superhuman + + # Ruft die überschriebene Methode auf + print(sup.sing()) # => nan nan nan nan nan batman! + + # Ruft die Methode von Human auf, weil die Reihenfolge der Vererbung wichtig ist + sup.say('I agree') # => Sad Affleck: I agree + + # Aufrufmethode, die nur im 2. Vorfahren existiert + print(sup.sonar()) # => ))) ... ((( + + # Vererbtes Klassenattribut + sup.age = 100 + print(sup.age) # => 100 + + # Vererbtes Attribut vom 2. Vorfahren, dessen Standardwert überschrieben wurde. + print('Can I fly? ' + str(sup.fly)) # => Can I fly? False + + +#################################################### +## 7. Fortgeschrittenes +#################################################### + +# Generatoren helfen Ihnen, lazy Code zu erstellen. +def double_numbers(iterable): + for i in iterable: + yield i + i + +# Generatoren sind speichereffizient, da sie nur die Daten laden, +# die zur Verarbeitung des nächsten Werts in der iterierbaren Komponente +# erforderlich sind. Dadurch können sie ansonsten unzulässig große Wertebereiche ausführen. +# HINWEIS: `range` ersetzt` xrange` in Python 3. +for i in double_numbers(range(1, 900000000)): # `range` ist ein Generator. + print(i) + if i >= 30: + break + +# Genauso wie Sie ein 'list comprehension' (Listen Abstraktion) erstellen können, können Sie auch 'generator comprehension' (Generator Abstraktion) erstellen. +values = (-x for x in [1,2,3,4,5]) +for x in values: + print(x) # prints -1 -2 -3 -4 -5 to console/terminal + +# Sie können eine Generator Abstraktion auch direkt in eine Liste umwandeln (casten). +values = (-x for x in [1,2,3,4,5]) +gen_to_list = list(values) +print(gen_to_list) # => [-1, -2, -3, -4, -5] + +# Decorators +# In diesem Beispiel umschliesst "beg" "say". Wenn say_please True ist, wird die zurückgegebene Nachricht geändert. +from functools import wraps + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Please! I am poor :(") + return msg + + return wrapper + +@beg +def say(say_please=False): + msg = "Can you buy me a beer?" + return msg, say_please + + +print(say()) # Can you buy me a beer? +print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( + +``` + +## Lust auf mehr? + +### Kostenlos online (Englisch) + +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [The Official Docs](http://docs.python.org/2.6/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [Python Module of the Week](http://pymotw.com/2/) + +### Totholz (Englisch) + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) + -- cgit v1.2.3 From a3b0585374d69e392fdb724bde30bc4048358d31 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 04:54:36 +0100 Subject: Rename Python 3 markdown files into 'python' ``` for f in $(find . -iname "*python3*" | grep -vE 'git'); do fnew=$(echo "$f" | sed 's/python3/python/') git mv "$f" "$fnew" done --- de-de/python-de.html.markdown | 655 +++++++++++++++++++++++++++++++++++++++++ de-de/python3-de.html.markdown | 655 ----------------------------------------- 2 files changed, 655 insertions(+), 655 deletions(-) create mode 100644 de-de/python-de.html.markdown delete mode 100644 de-de/python3-de.html.markdown (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown new file mode 100644 index 00000000..4ef997a1 --- /dev/null +++ b/de-de/python-de.html.markdown @@ -0,0 +1,655 @@ +--- +language: python3 +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["kultprok", "http:/www.kulturproktologie.de"] + - ["matthiaskern", "https://github.com/matthiaskern"] +filename: learnpython3-de.py +lang: de-de +--- + +Anmerkungen des ursprünglichen Autors: +Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode. + +Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service]. + +Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter. + +```python + +# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz) + +""" Mehrzeilige Strings werden mit + drei '-Zeichen geschrieben und werden + oft als Kommentare genutzt. +""" + +#################################################### +## 1. Primitive Datentypen und Operatoren +#################################################### + +# Die Zahlen +3 #=> 3 + +# Mathematik funktioniert so, wie man das erwartet +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 + +# Außer Division, welche automatisch Gleitkommazahlen zurückgibt +35 / 5 # => 7.0 + +# Eine Division kann mit "//" für positive sowie negative Werte abgerundet werden. +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # works on floats too +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Benutzt man eine Gleitkommazahl, ist auch das Ergebnis eine solche +3 * 2.0 # => 6.0 + +# Der Rest einer Division +7 % 3 # => 1 + +# Potenz +2**4 # => 16 + +# Rangfolge wird mit Klammern erzwungen +(1 + 3) * 2 #=> 8 + +# Boolesche Ausdrücke sind primitive Datentypen +True +False + +# Mit not wird negiert +not True #=> False +not False #=> True + +# Boolesche Operatoren +# Hinweis: "and" und "or" müssen klein geschrieben werden +True and False #=> False +False or True #=> True + +# Für die Benutzung von Booleschen Operatoren und ganzen Zahlen +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + +# Gleichheit ist == +1 == 1 #=> True +2 == 1 #=> False + +# Ungleichheit ist != +1 != 1 #=> False +2 != 1 #=> True + +# Ein paar weitere Vergleiche +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# Vergleiche können verknüpft werden! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Strings werden mit " oder ' gebildet +"Das ist ein String." +'Das ist auch ein String.' + +# Strings können auch addiert werden! Vermeide dies aber lieber. +"Hallo " + "Welt!" #=> "Hallo Welt!" +# Strings können ohne "+" addiert werden +"Hallo " "welt!" # => "Hallo Welt!" + +# Ein String kann wie eine Liste von Zeichen verwendet werden +"Das ist ein String"[0] #=> 'D' + +# .format kann Strings formatieren +"{} können {} werden".format("Strings", "formatiert") + +# Schneller geht das mit Wiederholungen +"{0} mag Spagetthi, {0} liebt es zu Schwimmen und ganz besonders mag {0} {1}".format("Hans", "Blattsalat") +#=> "Hans mag Spagetthi, Hans liebt es zu Schwimmen und ganz besonders mag Hans Blattsalat" + +# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen. +"{name} will {food} essen".format(name="Bob", food="Lasagne") +#=> "Bob will Lasagne kochen" + +#Falls dein Python 3 Code auch unter Python 2.5 oder darunter laufen soll, kann das alte Format benutzt werden: +"%s können %s werden" % ("Strings", "interpoliert") + + +# None ist ein Objekt +None #=> None + +# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen +# Benutzt stattdessen `is`. Dieser Operator testet Objektidentität +"etc" is None #=> False +None is None #=> True + + + +# None, 0, und leere Strings/Listen werden alle als False bewertet. +# Alle anderen Werte sind True +bool(0) # => False +bool("") # => False +bool([]) #=> False +bool({}) #=> False + + +#################################################### +## 2. Variablen und Collections +#################################################### + +# Textausgabe ist sehr einfach +print("Ich bin Python. Schön, dich kennenzulernen!") + +# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren. +some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm +some_var #=> 5 + +# Das Ansprechen einer noch nicht deklarierten Variable löst eine Exception aus. +# Unter "Kontrollstruktur" kann noch mehr über +# Ausnahmebehandlung erfahren werden. +some_unknown_var # Löst einen NameError aus + +# Listen speichern Sequenzen +li = [] +# Wir können mit einer bereits gefüllten Liste anfangen +other_li = [4, 5, 6] + +# append fügt Daten am Ende der Liste ein +li.append(1) #li ist jetzt [1] +li.append(2) #li ist jetzt [1, 2] +li.append(4) #li ist jetzt [1, 2, 4] +li.append(3) #li ist jetzt [1, 2, 4, 3] +# Vom Ende der Liste mit pop entfernen +li.pop() #=> 3 und li ist jetzt [1, 2, 4] +# und dann wieder hinzufügen +li.append(3) # li ist jetzt wieder [1, 2, 4, 3]. + +# Greife auf Listen wie auf Arrays zu +li[0] #=> 1 +# Das letzte Element ansehen +li[-1] #=> 3 + +# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError +li[4] # Verursacht einen IndexError + +# Wir können uns Ranges mit Slice-Syntax ansehen +li[1:3] #=> [2, 4] +# Den Anfang auslassen +li[2:] #=> [4, 3] +# Das Ende auslassen +li[:3] #=> [1, 2, 4] +# Jeden Zweiten Eintrag auswählen +li[::2] # =>[1, 4] +# Eine umgekehrte Kopie zurückgeben +li[::-1] # => [3, 4, 2, 1] +# Jegliche Kombination dieser Syntax machen fortgeschrittene Slices möglich +# li[Start:Ende:Schritt] + +# Ein bestimmtes Element mit del aus der Liste entfernen +del li[2] # li ist jetzt [1, 2, 3] + +# Listen können addiert werden +li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen + +# Listen mit extend verknüpfen +li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6] + +# Mit in auf Existenz eines Elements prüfen +1 in li #=> True + +# Die Länge der Liste mit len ermitteln +len(li) #=> 6 + + +# Tupel sind wie Listen, nur unveränderlich. +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Löst einen TypeError aus + +# Wir können all diese Listen-Dinge auch mit Tupeln anstellen +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Wir können Tupel (oder Listen) in Variablen entpacken +a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3 +# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen +d, e, f = 4, 5, 6 +# Es ist kinderleicht zwei Werte zu tauschen +e, d = d, e # d ist nun 5 und e ist nun 4 + + +# Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare +empty_dict = {} +# Hier ein gefülltes Wörterbuch +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Wir können Einträge mit [] nachschlagen +filled_dict["one"] #=> 1 + +# So holen wir alle Keys (Schlüssel) als Liste +list(filled_dict.keys()) #=> ["three", "two", "one"] +# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert. +# Einzelne Resultate können anders angeordnet sein. + +# Alle Values (Werte) als Liste +list(filled_dict.values()) #=> [3, 2, 1] +# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln. + +# Das Vorhandensein eines Schlüssels im Wörterbuch mit "in" prüfen +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus +filled_dict["four"] # KeyError + +# Mit der get-Methode verhindern wir das +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen +filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt +filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5 + +# Einträge zu einem Wörterbuch hinzufügen +filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} +#filled_dict["four"] = 4 # noch ein Weg, Werte hinzuzufügen + +# Schlüssel von einem Wörterbuch entfernen +del filled_dict["one"] # Entfert den Schlüssel "one" + + +# Sets speichern Mengen +empty_set = set() +# Initialisieren wir ein Set mit ein paar Werten +some_set = {1, 1, 2, 2, 3, 4} # some_set ist jetzt {1, 2, 3, 4} + +# Neue Variablen können einer Menge gleichgesetzt werden +filled_set = some_set + +# Mehr Elemente hinzufügen +filled_set.add(5) # filled_set ist jetzt {1, 2, 3, 4, 5} + +# Schnittmengen werden mit & gebildet +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# Mengen werden mit | vereinigt +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# Die Differenz einer Menge mit - bilden +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Auf Vorhandensein von Elementen mit in prüfen +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Kontrollstruktur und Iteratoren +#################################################### + +# Erstellen wir mal eine Variable +some_var = 5 + +# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig! +# gibt "some_var ist kleiner als 10" aus +if some_var > 10: + print("some_var ist viel größer als 10.") +elif some_var < 10: # Dieser elif-Absatz ist optional. + print("some_var ist kleiner als 10.") +else: # Das hier ist auch optional. + print("some_var ist tatsächlich 10.") + + +""" +For-Schleifen iterieren über Listen +Ausgabe: + hund ist ein Säugetier + katze ist ein Säugetier + maus ist ein Säugetier +""" +for animal in ["hund", "katze", "maus"]: + # Wir können Strings mit format() formatieren + print("{} ist ein Säugetier".format(animal)) + +""" +`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder +Ausgabe: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +"range(unten, oben)" gibt eine Liste von der unteren Zahl bis zur oberen Zahl aus +Ausgabe: + 4 + 5 + 6 + 7 +""" +for i in range(4, 8): + print(i) + +""" +While-Schleifen laufen, bis eine Bedingung erfüllt ist. +Ausgabe: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Kurzform für x = x + 1 + +# Ausnahmebehandlung mit einem try/except-Block +try: + # Mit raise wird ein Fehler ausgegeben + raise IndexError("Das hier ist ein Index-Fehler") +except IndexError as e: + pass # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären. +except (TypeError, NameError): + pass # Mehrere Fehler können zusammen geklärt werden, falls erforderlich. +else: # Optional, hinter allen except-Blöcken + print("Keine Probleme!") # Wird nur ausgeführt, wenn keine Ausnahmen aufgetreten sind +finally: # Wird immer ausgeführt + print("Hier können wir Ressourcen aufräumen") + +# alternativ zu einem try/finally Block um Aufzuräumen: +with open("meineDatei.txt") as f: + for line in f: + print(line) + +# Python bietet ein fundamentales Konzept der Iteration. +# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable". +# Die range Methode gibt ein solches Objekt aus. + +filled_dict = {"one": 1, "two": 2, "three": 3} +our_iterable = filled_dict.keys() +print(our_iterable) #=> range(1,10). Dies ist ein "iterable" Objekt. + +# Über dieses können wir auch iterieren +for i in our_iterable: + print(i) # Gibt one, two, three aus + +# Allerdings können wir die einzelnen Elemente nicht mit ihrem index ausgeben +our_iterable[1] # TypeError + +# Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft. +our_iterator = iter(our_iterable) + +# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat während wir durch es gehen. +# Das jeweils nächste Objekt bekommen wir mit "next()" +next(our_iterator) #=> "one" + +# Es hält den vorherigen Status +next(our_iterator) #=> "two" +next(our_iterator) #=> "three" + +# Nachdem alle Daten ausgegeben worden sind, kommt eine StopIterator Ausnahme zurück +next(our_iterator) # Gibt StopIteration aus + +# Alle Elemente können mit "list()" ausgegeben werden +list(filled_dict.keys()) #=> ["one", "two", "three"] + + + +#################################################### +## 4. Funktionen +#################################################### + +# Mit def neue Funktionen erstellen +def add(x, y): + print("x ist %s und y ist %s" % (x, y)) + return x + y # Werte werden mit return zurückgegeben + +# Funktionen mit Parametern aufrufen +add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück + +# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente +add(y=6, x=5) # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden. + +# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# Wir können auch Funktionen mit beliebiger Anzahl +# Schlüsselwort-Argumenten definieren +def keyword_args(**kwargs): + return kwargs + +# Rufen wir es mal auf, um zu sehen, was passiert +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# Wir können beides gleichzeitig machen, wenn wir wollen +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) Ausgabe: + (1, 2) + {"a": 3, "b": 4} +""" + +# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen! +# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs. +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4) +all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4) +all_the_args(*args, **kwargs) # äquivalent zu foo(1, 2, 3, 4, a=3, b=4) + + +# Anwendungsbereich von Funktionen +x = 5 + +def setX(num): + # lokale Variable x ist nicht die globale Variable x + x = num # => 43 + print (x) # => 43 + +def setGlobalX(num): + global x + print (x) # => 5 + x = num # globale Variable x ist jetzt 6 + print (x) # => 6 + +setX(43) +setGlobalX(6) + + +# Python hat First-Class-Funktionen +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Es gibt auch anonyme Funktionen +(lambda x: x > 2)(3) #=> True + +# Es gibt auch Funktionen höherer Ordnung als Built-Ins +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen +[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] + +#################################################### +## 5. Klassen +#################################################### + +# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten. +class Human(object): + + # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt + species = "H. sapiens" + + # Ein simpler Konstruktor + def __init__(self, name): + # Wir weisen das Argument name dem name-Attribut der Instanz zu + self.name = name + + # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument. + def say(self, msg): + return "{name}: {message}".format(name=self.name, message=msg) + + # Eine Klassenmethode wird von allen Instanzen geteilt. + # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen + @classmethod + def get_species(cls): + return cls.species + + # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen + @staticmethod + def grunt(): + return "*grunt*" + + +# Eine Instanz einer Klasse erstellen +i = Human(name="Ian") +print(i.say("hi")) # gibt "Ian: hi" aus + +j = Human("Joel") +print(j.say("hello")) #gibt "Joel: hello" aus + +# Rufen wir mal unsere Klassenmethode auf +i.get_species() #=> "H. sapiens" + +# Ändern wir mal das gemeinsame Attribut +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Aufruf der statischen Methode +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. Module +#################################################### + +# Wir können Module importieren +import math +print(math.sqrt(16)) #=> 4.0 + +# Wir können auch nur spezielle Funktionen eines Moduls importieren +from math import ceil, floor +print(ceil(3.7)) #=> 4.0 +print(floor(3.7)) #=> 3.0 + +# Wir können auch alle Funktionen eines Moduls importieren +# Warnung: Dies wird nicht empfohlen +from math import * + +# Wir können Modulnamen abkürzen +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Module sind in Python nur gewöhnliche Dateien. Wir +# können unsere eigenen schreiben und importieren. Der Name des +# Moduls ist der Dateiname. + +# Wir können auch die Funktionen und Attribute eines +# Moduls herausfinden. +import math +dir(math) + + +#################################################### +## 7. Fortgeschritten +#################################################### + +# Generatoren helfen um Code schnell und einfach zu schreiben +def double_numbers(iterable): + for i in iterable: + yield i + i + +# Ein Generator erschafft Werte spontan +# Statt alle Werte auf einmal, wird bei jeder Iteration einer erschaffen. +# iteration. Das heißt, Werte größer als 15 werden nicht behandelt. +# Die range-Methode ist auch ein Generator. Im Fall einer Liste von 1-900000000 +# würde das sehr viel Zeit in Anspruch nehmen. +# Wenn wir eine variable mit einem Namen erschaffen wollen, das +# normalerweise mit einem Python - Schlüsselwort kollidieren würde, +# benutzen wir einen Unterstrich nach dem Wort. +range_ = range(1, 900000000) +# Alle Nummern bis zu einem Ergebnis von >=30 werden verdoppelt +for i in double_numbers(range_): + print(i) + if i >= 30: + break + + +# Dekoratoren +# In diesem Beispiel die Methode beg umwickelt say +# Beim Aufruf von beg, say wird aufgerufen +# Falls say_please true ist, ändert sich die ausgegebene Nachricht +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Please! I am poor :(") + return msg + + return wrapper + + +@beg +def say(say_please=False): + msg = "Can you buy me a beer?" + return msg, say_please + + +print(say()) # Can you buy me a beer? +print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( + +``` + +## Lust auf mehr? + +### Kostenlos online (Englisch) + +* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com) +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Ideas for Python Projects](http://pythonpracticeprojects.com) +* [The Official Docs](http://docs.python.org/3/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) +* [Python Course](http://www.python-course.eu/index.php) +* [First Steps With Python](https://realpython.com/learn/python-first-steps/) + +### Totholz (Englisch) + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown deleted file mode 100644 index 4ef997a1..00000000 --- a/de-de/python3-de.html.markdown +++ /dev/null @@ -1,655 +0,0 @@ ---- -language: python3 -contributors: - - ["Louie Dinh", "http://ldinh.ca"] -translators: - - ["kultprok", "http:/www.kulturproktologie.de"] - - ["matthiaskern", "https://github.com/matthiaskern"] -filename: learnpython3-de.py -lang: de-de ---- - -Anmerkungen des ursprünglichen Autors: -Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode. - -Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service]. - -Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter. - -```python - -# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz) - -""" Mehrzeilige Strings werden mit - drei '-Zeichen geschrieben und werden - oft als Kommentare genutzt. -""" - -#################################################### -## 1. Primitive Datentypen und Operatoren -#################################################### - -# Die Zahlen -3 #=> 3 - -# Mathematik funktioniert so, wie man das erwartet -1 + 1 #=> 2 -8 - 1 #=> 7 -10 * 2 #=> 20 - -# Außer Division, welche automatisch Gleitkommazahlen zurückgibt -35 / 5 # => 7.0 - -# Eine Division kann mit "//" für positive sowie negative Werte abgerundet werden. -5 // 3 # => 1 -5.0 // 3.0 # => 1.0 # works on floats too --5 // 3 # => -2 --5.0 // 3.0 # => -2.0 - -# Benutzt man eine Gleitkommazahl, ist auch das Ergebnis eine solche -3 * 2.0 # => 6.0 - -# Der Rest einer Division -7 % 3 # => 1 - -# Potenz -2**4 # => 16 - -# Rangfolge wird mit Klammern erzwungen -(1 + 3) * 2 #=> 8 - -# Boolesche Ausdrücke sind primitive Datentypen -True -False - -# Mit not wird negiert -not True #=> False -not False #=> True - -# Boolesche Operatoren -# Hinweis: "and" und "or" müssen klein geschrieben werden -True and False #=> False -False or True #=> True - -# Für die Benutzung von Booleschen Operatoren und ganzen Zahlen -0 and 2 #=> 0 --5 or 0 #=> -5 -0 == False #=> True -2 == True #=> False -1 == True #=> True - -# Gleichheit ist == -1 == 1 #=> True -2 == 1 #=> False - -# Ungleichheit ist != -1 != 1 #=> False -2 != 1 #=> True - -# Ein paar weitere Vergleiche -1 < 10 #=> True -1 > 10 #=> False -2 <= 2 #=> True -2 >= 2 #=> True - -# Vergleiche können verknüpft werden! -1 < 2 < 3 #=> True -2 < 3 < 2 #=> False - -# Strings werden mit " oder ' gebildet -"Das ist ein String." -'Das ist auch ein String.' - -# Strings können auch addiert werden! Vermeide dies aber lieber. -"Hallo " + "Welt!" #=> "Hallo Welt!" -# Strings können ohne "+" addiert werden -"Hallo " "welt!" # => "Hallo Welt!" - -# Ein String kann wie eine Liste von Zeichen verwendet werden -"Das ist ein String"[0] #=> 'D' - -# .format kann Strings formatieren -"{} können {} werden".format("Strings", "formatiert") - -# Schneller geht das mit Wiederholungen -"{0} mag Spagetthi, {0} liebt es zu Schwimmen und ganz besonders mag {0} {1}".format("Hans", "Blattsalat") -#=> "Hans mag Spagetthi, Hans liebt es zu Schwimmen und ganz besonders mag Hans Blattsalat" - -# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen. -"{name} will {food} essen".format(name="Bob", food="Lasagne") -#=> "Bob will Lasagne kochen" - -#Falls dein Python 3 Code auch unter Python 2.5 oder darunter laufen soll, kann das alte Format benutzt werden: -"%s können %s werden" % ("Strings", "interpoliert") - - -# None ist ein Objekt -None #=> None - -# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen -# Benutzt stattdessen `is`. Dieser Operator testet Objektidentität -"etc" is None #=> False -None is None #=> True - - - -# None, 0, und leere Strings/Listen werden alle als False bewertet. -# Alle anderen Werte sind True -bool(0) # => False -bool("") # => False -bool([]) #=> False -bool({}) #=> False - - -#################################################### -## 2. Variablen und Collections -#################################################### - -# Textausgabe ist sehr einfach -print("Ich bin Python. Schön, dich kennenzulernen!") - -# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren. -some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm -some_var #=> 5 - -# Das Ansprechen einer noch nicht deklarierten Variable löst eine Exception aus. -# Unter "Kontrollstruktur" kann noch mehr über -# Ausnahmebehandlung erfahren werden. -some_unknown_var # Löst einen NameError aus - -# Listen speichern Sequenzen -li = [] -# Wir können mit einer bereits gefüllten Liste anfangen -other_li = [4, 5, 6] - -# append fügt Daten am Ende der Liste ein -li.append(1) #li ist jetzt [1] -li.append(2) #li ist jetzt [1, 2] -li.append(4) #li ist jetzt [1, 2, 4] -li.append(3) #li ist jetzt [1, 2, 4, 3] -# Vom Ende der Liste mit pop entfernen -li.pop() #=> 3 und li ist jetzt [1, 2, 4] -# und dann wieder hinzufügen -li.append(3) # li ist jetzt wieder [1, 2, 4, 3]. - -# Greife auf Listen wie auf Arrays zu -li[0] #=> 1 -# Das letzte Element ansehen -li[-1] #=> 3 - -# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError -li[4] # Verursacht einen IndexError - -# Wir können uns Ranges mit Slice-Syntax ansehen -li[1:3] #=> [2, 4] -# Den Anfang auslassen -li[2:] #=> [4, 3] -# Das Ende auslassen -li[:3] #=> [1, 2, 4] -# Jeden Zweiten Eintrag auswählen -li[::2] # =>[1, 4] -# Eine umgekehrte Kopie zurückgeben -li[::-1] # => [3, 4, 2, 1] -# Jegliche Kombination dieser Syntax machen fortgeschrittene Slices möglich -# li[Start:Ende:Schritt] - -# Ein bestimmtes Element mit del aus der Liste entfernen -del li[2] # li ist jetzt [1, 2, 3] - -# Listen können addiert werden -li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen - -# Listen mit extend verknüpfen -li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6] - -# Mit in auf Existenz eines Elements prüfen -1 in li #=> True - -# Die Länge der Liste mit len ermitteln -len(li) #=> 6 - - -# Tupel sind wie Listen, nur unveränderlich. -tup = (1, 2, 3) -tup[0] #=> 1 -tup[0] = 3 # Löst einen TypeError aus - -# Wir können all diese Listen-Dinge auch mit Tupeln anstellen -len(tup) #=> 3 -tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) -tup[:2] #=> (1, 2) -2 in tup #=> True - -# Wir können Tupel (oder Listen) in Variablen entpacken -a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3 -# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen -d, e, f = 4, 5, 6 -# Es ist kinderleicht zwei Werte zu tauschen -e, d = d, e # d ist nun 5 und e ist nun 4 - - -# Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare -empty_dict = {} -# Hier ein gefülltes Wörterbuch -filled_dict = {"one": 1, "two": 2, "three": 3} - -# Wir können Einträge mit [] nachschlagen -filled_dict["one"] #=> 1 - -# So holen wir alle Keys (Schlüssel) als Liste -list(filled_dict.keys()) #=> ["three", "two", "one"] -# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert. -# Einzelne Resultate können anders angeordnet sein. - -# Alle Values (Werte) als Liste -list(filled_dict.values()) #=> [3, 2, 1] -# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln. - -# Das Vorhandensein eines Schlüssels im Wörterbuch mit "in" prüfen -"one" in filled_dict #=> True -1 in filled_dict #=> False - -# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus -filled_dict["four"] # KeyError - -# Mit der get-Methode verhindern wir das -filled_dict.get("one") #=> 1 -filled_dict.get("four") #=> None -# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt -filled_dict.get("one", 4) #=> 1 -filled_dict.get("four", 4) #=> 4 - -# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen -filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt -filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5 - -# Einträge zu einem Wörterbuch hinzufügen -filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} -#filled_dict["four"] = 4 # noch ein Weg, Werte hinzuzufügen - -# Schlüssel von einem Wörterbuch entfernen -del filled_dict["one"] # Entfert den Schlüssel "one" - - -# Sets speichern Mengen -empty_set = set() -# Initialisieren wir ein Set mit ein paar Werten -some_set = {1, 1, 2, 2, 3, 4} # some_set ist jetzt {1, 2, 3, 4} - -# Neue Variablen können einer Menge gleichgesetzt werden -filled_set = some_set - -# Mehr Elemente hinzufügen -filled_set.add(5) # filled_set ist jetzt {1, 2, 3, 4, 5} - -# Schnittmengen werden mit & gebildet -other_set = {3, 4, 5, 6} -filled_set & other_set #=> {3, 4, 5} - -# Mengen werden mit | vereinigt -filled_set | other_set #=> {1, 2, 3, 4, 5, 6} - -# Die Differenz einer Menge mit - bilden -{1,2,3,4} - {2,3,5} #=> {1, 4} - -# Auf Vorhandensein von Elementen mit in prüfen -2 in filled_set #=> True -10 in filled_set #=> False - - -#################################################### -## 3. Kontrollstruktur und Iteratoren -#################################################### - -# Erstellen wir mal eine Variable -some_var = 5 - -# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig! -# gibt "some_var ist kleiner als 10" aus -if some_var > 10: - print("some_var ist viel größer als 10.") -elif some_var < 10: # Dieser elif-Absatz ist optional. - print("some_var ist kleiner als 10.") -else: # Das hier ist auch optional. - print("some_var ist tatsächlich 10.") - - -""" -For-Schleifen iterieren über Listen -Ausgabe: - hund ist ein Säugetier - katze ist ein Säugetier - maus ist ein Säugetier -""" -for animal in ["hund", "katze", "maus"]: - # Wir können Strings mit format() formatieren - print("{} ist ein Säugetier".format(animal)) - -""" -`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder -Ausgabe: - 0 - 1 - 2 - 3 -""" -for i in range(4): - print(i) - -""" -"range(unten, oben)" gibt eine Liste von der unteren Zahl bis zur oberen Zahl aus -Ausgabe: - 4 - 5 - 6 - 7 -""" -for i in range(4, 8): - print(i) - -""" -While-Schleifen laufen, bis eine Bedingung erfüllt ist. -Ausgabe: - 0 - 1 - 2 - 3 -""" -x = 0 -while x < 4: - print(x) - x += 1 # Kurzform für x = x + 1 - -# Ausnahmebehandlung mit einem try/except-Block -try: - # Mit raise wird ein Fehler ausgegeben - raise IndexError("Das hier ist ein Index-Fehler") -except IndexError as e: - pass # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären. -except (TypeError, NameError): - pass # Mehrere Fehler können zusammen geklärt werden, falls erforderlich. -else: # Optional, hinter allen except-Blöcken - print("Keine Probleme!") # Wird nur ausgeführt, wenn keine Ausnahmen aufgetreten sind -finally: # Wird immer ausgeführt - print("Hier können wir Ressourcen aufräumen") - -# alternativ zu einem try/finally Block um Aufzuräumen: -with open("meineDatei.txt") as f: - for line in f: - print(line) - -# Python bietet ein fundamentales Konzept der Iteration. -# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable". -# Die range Methode gibt ein solches Objekt aus. - -filled_dict = {"one": 1, "two": 2, "three": 3} -our_iterable = filled_dict.keys() -print(our_iterable) #=> range(1,10). Dies ist ein "iterable" Objekt. - -# Über dieses können wir auch iterieren -for i in our_iterable: - print(i) # Gibt one, two, three aus - -# Allerdings können wir die einzelnen Elemente nicht mit ihrem index ausgeben -our_iterable[1] # TypeError - -# Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft. -our_iterator = iter(our_iterable) - -# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat während wir durch es gehen. -# Das jeweils nächste Objekt bekommen wir mit "next()" -next(our_iterator) #=> "one" - -# Es hält den vorherigen Status -next(our_iterator) #=> "two" -next(our_iterator) #=> "three" - -# Nachdem alle Daten ausgegeben worden sind, kommt eine StopIterator Ausnahme zurück -next(our_iterator) # Gibt StopIteration aus - -# Alle Elemente können mit "list()" ausgegeben werden -list(filled_dict.keys()) #=> ["one", "two", "three"] - - - -#################################################### -## 4. Funktionen -#################################################### - -# Mit def neue Funktionen erstellen -def add(x, y): - print("x ist %s und y ist %s" % (x, y)) - return x + y # Werte werden mit return zurückgegeben - -# Funktionen mit Parametern aufrufen -add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück - -# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente -add(y=6, x=5) # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden. - -# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren -def varargs(*args): - return args - -varargs(1, 2, 3) #=> (1,2,3) - - -# Wir können auch Funktionen mit beliebiger Anzahl -# Schlüsselwort-Argumenten definieren -def keyword_args(**kwargs): - return kwargs - -# Rufen wir es mal auf, um zu sehen, was passiert -keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} - -# Wir können beides gleichzeitig machen, wenn wir wollen -def all_the_args(*args, **kwargs): - print(args) - print(kwargs) -""" -all_the_args(1, 2, a=3, b=4) Ausgabe: - (1, 2) - {"a": 3, "b": 4} -""" - -# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen! -# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs. -args = (1, 2, 3, 4) -kwargs = {"a": 3, "b": 4} -all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4) -all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4) -all_the_args(*args, **kwargs) # äquivalent zu foo(1, 2, 3, 4, a=3, b=4) - - -# Anwendungsbereich von Funktionen -x = 5 - -def setX(num): - # lokale Variable x ist nicht die globale Variable x - x = num # => 43 - print (x) # => 43 - -def setGlobalX(num): - global x - print (x) # => 5 - x = num # globale Variable x ist jetzt 6 - print (x) # => 6 - -setX(43) -setGlobalX(6) - - -# Python hat First-Class-Funktionen -def create_adder(x): - def adder(y): - return x + y - return adder - -add_10 = create_adder(10) -add_10(3) #=> 13 - -# Es gibt auch anonyme Funktionen -(lambda x: x > 2)(3) #=> True - -# Es gibt auch Funktionen höherer Ordnung als Built-Ins -map(add_10, [1,2,3]) #=> [11, 12, 13] -filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] - -# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen -[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] -[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] - -#################################################### -## 5. Klassen -#################################################### - -# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten. -class Human(object): - - # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt - species = "H. sapiens" - - # Ein simpler Konstruktor - def __init__(self, name): - # Wir weisen das Argument name dem name-Attribut der Instanz zu - self.name = name - - # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument. - def say(self, msg): - return "{name}: {message}".format(name=self.name, message=msg) - - # Eine Klassenmethode wird von allen Instanzen geteilt. - # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen - @classmethod - def get_species(cls): - return cls.species - - # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen - @staticmethod - def grunt(): - return "*grunt*" - - -# Eine Instanz einer Klasse erstellen -i = Human(name="Ian") -print(i.say("hi")) # gibt "Ian: hi" aus - -j = Human("Joel") -print(j.say("hello")) #gibt "Joel: hello" aus - -# Rufen wir mal unsere Klassenmethode auf -i.get_species() #=> "H. sapiens" - -# Ändern wir mal das gemeinsame Attribut -Human.species = "H. neanderthalensis" -i.get_species() #=> "H. neanderthalensis" -j.get_species() #=> "H. neanderthalensis" - -# Aufruf der statischen Methode -Human.grunt() #=> "*grunt*" - - -#################################################### -## 6. Module -#################################################### - -# Wir können Module importieren -import math -print(math.sqrt(16)) #=> 4.0 - -# Wir können auch nur spezielle Funktionen eines Moduls importieren -from math import ceil, floor -print(ceil(3.7)) #=> 4.0 -print(floor(3.7)) #=> 3.0 - -# Wir können auch alle Funktionen eines Moduls importieren -# Warnung: Dies wird nicht empfohlen -from math import * - -# Wir können Modulnamen abkürzen -import math as m -math.sqrt(16) == m.sqrt(16) #=> True - -# Module sind in Python nur gewöhnliche Dateien. Wir -# können unsere eigenen schreiben und importieren. Der Name des -# Moduls ist der Dateiname. - -# Wir können auch die Funktionen und Attribute eines -# Moduls herausfinden. -import math -dir(math) - - -#################################################### -## 7. Fortgeschritten -#################################################### - -# Generatoren helfen um Code schnell und einfach zu schreiben -def double_numbers(iterable): - for i in iterable: - yield i + i - -# Ein Generator erschafft Werte spontan -# Statt alle Werte auf einmal, wird bei jeder Iteration einer erschaffen. -# iteration. Das heißt, Werte größer als 15 werden nicht behandelt. -# Die range-Methode ist auch ein Generator. Im Fall einer Liste von 1-900000000 -# würde das sehr viel Zeit in Anspruch nehmen. -# Wenn wir eine variable mit einem Namen erschaffen wollen, das -# normalerweise mit einem Python - Schlüsselwort kollidieren würde, -# benutzen wir einen Unterstrich nach dem Wort. -range_ = range(1, 900000000) -# Alle Nummern bis zu einem Ergebnis von >=30 werden verdoppelt -for i in double_numbers(range_): - print(i) - if i >= 30: - break - - -# Dekoratoren -# In diesem Beispiel die Methode beg umwickelt say -# Beim Aufruf von beg, say wird aufgerufen -# Falls say_please true ist, ändert sich die ausgegebene Nachricht -from functools import wraps - - -def beg(target_function): - @wraps(target_function) - def wrapper(*args, **kwargs): - msg, say_please = target_function(*args, **kwargs) - if say_please: - return "{} {}".format(msg, "Please! I am poor :(") - return msg - - return wrapper - - -@beg -def say(say_please=False): - msg = "Can you buy me a beer?" - return msg, say_please - - -print(say()) # Can you buy me a beer? -print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( - -``` - -## Lust auf mehr? - -### Kostenlos online (Englisch) - -* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com) -* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) -* [Dive Into Python](http://www.diveintopython.net/) -* [Ideas for Python Projects](http://pythonpracticeprojects.com) -* [The Official Docs](http://docs.python.org/3/) -* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) -* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) -* [Python Course](http://www.python-course.eu/index.php) -* [First Steps With Python](https://realpython.com/learn/python-first-steps/) - -### Totholz (Englisch) - -* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) -* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) -* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) -- cgit v1.2.3 From efe00fd06e2908f547ed8d47bd818301f96c4620 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 05:03:08 +0100 Subject: Switch links: 'python3 <-> python' and 'python <-> pythonlegacy' The list of references is exhausted by running 'ack docs/python'. --- de-de/python-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index 4ef997a1..2c1e9ae0 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -14,7 +14,7 @@ Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist he Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service]. -Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter. +Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/pythonlegacy/) weiter. ```python -- cgit v1.2.3 From 95c8b24ebf8b8e0ed02923787a9f793bdf295200 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 05:09:13 +0100 Subject: Python 2 'language': Python 2 (legacy) Instead of listing 'language: python' for Python 2, use language: Python 2 (legacy) ``` find . -iname "*pythonlegacy*" -exec \ sed -i 's/^language: .*/language: Python 2 (legacy)/' {} \; ``` --- de-de/pythonlegacy-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/pythonlegacy-de.html.markdown b/de-de/pythonlegacy-de.html.markdown index ee77683e..3f8f9783 100644 --- a/de-de/pythonlegacy-de.html.markdown +++ b/de-de/pythonlegacy-de.html.markdown @@ -1,5 +1,5 @@ --- -language: python +language: Python 2 (legacy) contributors: - ["Louie Dinh", "http://ldinh.ca"] translators: -- cgit v1.2.3 From 8f5fac98958098864b86e2a09d8131d6dafaaddd Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 05:15:29 +0100 Subject: Python 3: 'language: Python' Instead of listing 'language: python3' for Python 3, use language: Python as #3450 does. ``` find . -iname "python-*.markdown" -exec \ sed -i 's/language: python3/language: Python/' {} \; ``` --- de-de/python-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index 2c1e9ae0..28a705f2 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -1,5 +1,5 @@ --- -language: python3 +language: Python contributors: - ["Louie Dinh", "http://ldinh.ca"] translators: -- cgit v1.2.3 From 887cbee8af080034177734b528819491e73a7a16 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 05:50:44 +0100 Subject: Change 'filename:' for Python 2 (legacy) Before renaming, all Python 2 filenames were 'learnpython-*.py'. This commit renames them to 'learnpythonlegacy-*.py'. To verify that the filenames were named consistently across translations prior to this commit, and to change this: ``` find . -name "pythonlegacy*.markdown" -exec ack filename: {} \; find . -name "pythonlegacy*.markdown" -exec \ sed -i 's/^filename: learnpython/filename: learnpythonlegacy/' {} \; ``` --- de-de/pythonlegacy-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/pythonlegacy-de.html.markdown b/de-de/pythonlegacy-de.html.markdown index 3f8f9783..d66a8551 100644 --- a/de-de/pythonlegacy-de.html.markdown +++ b/de-de/pythonlegacy-de.html.markdown @@ -4,7 +4,7 @@ contributors: - ["Louie Dinh", "http://ldinh.ca"] translators: - ["kultprok", "http:/www.kulturproktologie.de"] -filename: learnpython-de.py +filename: learnpythonlegacy-de.py lang: de-de --- -- cgit v1.2.3 From ae848c481fabaca935ffbe33293a43a43434d268 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 06:23:31 +0100 Subject: Python 3: Use 'filename: learnpython*.py' (no '3') Before renaming, Python 3 filenames were 'learnpython3*.py'. This commit removes the '3' part from the filename. To verify that the filenames were named consistently across translations prior to this commit, and to change this: ``` ack -H 'filename:' python.html.markdown find . -name "python-*.markdown" -exec ack -H 'filename:' {} \; sed -i 's/^filename: learnpython3/filename: learnpython/' \ python.html.markdown find . -name "python-*.markdown" -exec \ sed -i 's/^filename: learnpython3/filename: learnpython/' {} \; ``` --- de-de/python-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index 28a705f2..9eebff41 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -5,7 +5,7 @@ contributors: translators: - ["kultprok", "http:/www.kulturproktologie.de"] - ["matthiaskern", "https://github.com/matthiaskern"] -filename: learnpython3-de.py +filename: learnpython-de.py lang: de-de --- -- cgit v1.2.3 From 5864aba42d2cf57dfe96049568b3a9689ea6a813 Mon Sep 17 00:00:00 2001 From: Leigh Brenecki Date: Thu, 13 Feb 2020 10:38:29 +1030 Subject: Purge my deadname --- de-de/javascript-de.html.markdown | 4 ++-- de-de/yaml-de.html.markdown | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/javascript-de.html.markdown b/de-de/javascript-de.html.markdown index f3917506..f817ee9f 100644 --- a/de-de/javascript-de.html.markdown +++ b/de-de/javascript-de.html.markdown @@ -1,7 +1,7 @@ --- language: javascript contributors: - - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Leigh Brenecki", "https://leigh.net.au"] translators: - ["ggb", "http://www.ideen-und-soehne.de"] filename: learnjavascript-de.js @@ -13,7 +13,7 @@ JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprün 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 [@adambrenecki](https://twitter.com/adambrenecki) oder [adam@brenecki.id.au](mailto:adam@brenecki.id.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de). +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 diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown index ff45dc8d..0332c912 100644 --- a/de-de/yaml-de.html.markdown +++ b/de-de/yaml-de.html.markdown @@ -1,7 +1,7 @@ --- language: yaml contributors: - - ["Adam Brenecki", "https://github.com/adambrenecki"] + - ["Leigh Brenecki", "https://github.com/adambrenecki"] translators: - ["Ruben M.", "https://github.com/switchhax"] filename: learnyaml-de.yaml -- cgit v1.2.3 From 1055a42304c3e944894442df3cc71d9ff733bf82 Mon Sep 17 00:00:00 2001 From: caminsha <31421093+caminsha@users.noreply.github.com> Date: Sat, 15 Feb 2020 00:01:53 +0100 Subject: Delete python3-de.html.markdown I deleted the old file. I'm sorry I had to commit twice. Was my first time to fetch upstream and merge it with old files. --- de-de/python3-de.html.markdown | 646 ----------------------------------------- 1 file changed, 646 deletions(-) delete mode 100644 de-de/python3-de.html.markdown (limited to 'de-de') diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown deleted file mode 100644 index e9695fff..00000000 --- a/de-de/python3-de.html.markdown +++ /dev/null @@ -1,646 +0,0 @@ ---- -language: python3 -contributors: - - ["Louie Dinh", "http://ldinh.ca"] -translators: - - ["kultprok", "http:/www.kulturproktologie.de"] - - ["matthiaskern", "https://github.com/matthiaskern"] -filename: learnpython3-de.py -lang: de-de ---- - -Anmerkungen des ursprünglichen Autors: -Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode. - -Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service]. - -Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter. - -```python - -# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz) - -""" Mehrzeilige Strings werden mit - drei '-Zeichen geschrieben und werden - oft als Kommentare genutzt. -""" - -#################################################### -## 1. Primitive Datentypen und Operatoren -#################################################### - -# Die Zahlen -3 #=> 3 - -# Mathematik funktioniert so, wie man das erwartet -1 + 1 #=> 2 -8 - 1 #=> 7 -10 * 2 #=> 20 - -# Außer Division, welche automatisch Gleitkommazahlen zurückgibt -35 / 5 # => 7.0 - -# Eine Division kann mit "//" für positive sowie negative Werte abgerundet werden. -5 // 3 # => 1 -5.0 // 3.0 # => 1.0 # funktioniert auch mit floats --5 // 3 # => -2 --5.0 // 3.0 # => -2.0 - -# Benutzt man eine Gleitkommazahl, ist auch das Ergebnis eine solche -3 * 2.0 # => 6.0 - -# Der Rest einer Division -7 % 3 # => 1 - -# Potenz -2**4 # => 16 - -# Rangfolge wird mit Klammern erzwungen -(1 + 3) * 2 #=> 8 - -# Boolesche Ausdrücke sind primitive Datentypen -True -False - -# Mit not wird negiert -not True #=> False -not False #=> True - -# Boolesche Operatoren -# Hinweis: "and" und "or" müssen klein geschrieben werden -True and False #=> False -False or True #=> True - -# Für die Benutzung von Booleschen Operatoren und ganzen Zahlen -0 and 2 #=> 0 --5 or 0 #=> -5 -0 == False #=> True -2 == True #=> False -1 == True #=> True - -# Gleichheit ist == -1 == 1 #=> True -2 == 1 #=> False - -# Ungleichheit ist != -1 != 1 #=> False -2 != 1 #=> True - -# Ein paar weitere Vergleiche -1 < 10 #=> True -1 > 10 #=> False -2 <= 2 #=> True -2 >= 2 #=> True - -# Vergleiche können verknüpft werden! -1 < 2 < 3 #=> True -2 < 3 < 2 #=> False - -# Strings werden mit " oder ' gebildet -"Das ist ein String." -'Das ist auch ein String.' - -# Strings können auch addiert werden! Vermeide dies aber lieber. -"Hallo " + "Welt!" #=> "Hallo Welt!" -# Strings können ohne "+" addiert werden -"Hallo " "welt!" # => "Hallo Welt!" - -# Ein String kann wie eine Liste von Zeichen verwendet werden -"Das ist ein String"[0] #=> 'D' - -# .format kann Strings formatieren -"{} können {} werden".format("Strings", "formatiert") - -# Schneller geht das mit Wiederholungen -"{0} mag Spagetthi, {0} liebt es zu Schwimmen und ganz besonders mag {0} {1}".format("Hans", "Blattsalat") -#=> "Hans mag Spagetthi, Hans liebt es zu Schwimmen und ganz besonders mag Hans Blattsalat" - -# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen. -"{name} will {food} essen".format(name="Bob", food="Lasagne") -#=> "Bob will Lasagne kochen" - -#Falls dein Python3 Code auch unter Python 2.5 oder darunter laufen soll, -# kann das alte Format benutzt werden: -"%s können %s werden" % ("Strings", "interpoliert") - -# None ist ein Objekt -None #=> None - -# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen -# Benutzt stattdessen `is`. Dieser Operator testet Objektidentität -"etc" is None #=> False -None is None #=> True - -# None, 0, und leere Strings/Listen werden alle als False bewertet. -# Alle anderen Werte sind True -bool(0) # => False -bool("") # => False -bool([]) #=> False -bool({}) #=> False - -#################################################### -## 2. Variablen und Collections -#################################################### - -# Textausgabe ist sehr einfach -print("Ich bin Python. Schön, dich kennenzulernen!") - -# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren. -some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm -some_var #=> 5 - -# Das Ansprechen einer noch nicht deklarierten Variable löst eine Exception aus. -# Unter "Kontrollstruktur" kann noch mehr über -# Ausnahmebehandlung erfahren werden. -some_unknown_var # Löst einen NameError aus - -# Listen speichern Sequenzen -li = [] -# Wir können mit einer bereits gefüllten Liste anfangen -other_li = [4, 5, 6] - -# append fügt Daten am Ende der Liste ein -li.append(1) #li ist jetzt [1] -li.append(2) #li ist jetzt [1, 2] -li.append(4) #li ist jetzt [1, 2, 4] -li.append(3) #li ist jetzt [1, 2, 4, 3] -# Vom Ende der Liste mit pop entfernen -li.pop() #=> 3 und li ist jetzt [1, 2, 4] -# und dann wieder hinzufügen -li.append(3) # li ist jetzt wieder [1, 2, 4, 3]. - -# Greife auf Listen wie auf Arrays zu -li[0] #=> 1 -# Das letzte Element ansehen -li[-1] #=> 3 - -# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError -li[4] # Verursacht einen IndexError - -# Wir können uns Ranges mit Slice-Syntax ansehen -li[1:3] #=> [2, 4] -# Den Anfang auslassen -li[2:] #=> [4, 3] -# Das Ende auslassen -li[:3] #=> [1, 2, 4] -# Jeden Zweiten Eintrag auswählen -li[::2] # =>[1, 4] -# Eine umgekehrte Kopie zurückgeben -li[::-1] # => [3, 4, 2, 1] -# Jegliche Kombination dieser Syntax machen fortgeschrittene Slices möglich -# li[Start:Ende:Schritt] - -# Ein bestimmtes Element mit del aus der Liste entfernen -del li[2] # li ist jetzt [1, 2, 3] - -# Listen können addiert werden -li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen - -# Listen mit extend verknüpfen -li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6] - -# Mit in auf Existenz eines Elements prüfen -1 in li #=> True - -# Die Länge der Liste mit len ermitteln -len(li) #=> 6 - -# Tupel sind wie Listen, nur unveränderlich. -tup = (1, 2, 3) -tup[0] #=> 1 -tup[0] = 3 # Löst einen TypeError aus - -# Wir können all diese Listen-Dinge auch mit Tupeln anstellen -len(tup) #=> 3 -tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) -tup[:2] #=> (1, 2) -2 in tup #=> True - -# Wir können Tupel (oder Listen) in Variablen entpacken -a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3 -# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen -d, e, f = 4, 5, 6 -# Es ist kinderleicht, zwei Werte zu tauschen -e, d = d, e # d ist nun 5 und e ist nun 4 - -# Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare -empty_dict = {} -# Hier ein gefülltes Wörterbuch -filled_dict = {"one": 1, "two": 2, "three": 3} - -# Wir können Einträge mit [] nachschlagen -filled_dict["one"] #=> 1 - -# So holen wir alle Keys (Schlüssel) als Liste -list(filled_dict.keys()) #=> ["three", "two", "one"] -# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert. -# Einzelne Resultate können anders angeordnet sein. - -# Alle Values (Werte) als Liste -list(filled_dict.values()) #=> [3, 2, 1] -# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln. - -# Das Vorhandensein eines Schlüssels im Wörterbuch mit "in" prüfen -"one" in filled_dict #=> True -1 in filled_dict #=> False - -# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus -filled_dict["four"] # KeyError - -# Mit der get-Methode verhindern wir das -filled_dict.get("one") #=> 1 -filled_dict.get("four") #=> None -# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt -filled_dict.get("one", 4) #=> 1 -filled_dict.get("four", 4) #=> 4 - -# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen -filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt -filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5 - -# Einträge zu einem Wörterbuch hinzufügen -filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} -#filled_dict["four"] = 4 # noch ein Weg, Werte hinzuzufügen - -# Schlüssel von einem Wörterbuch entfernen -del filled_dict["one"] # Entfert den Schlüssel "one" - -# Sets speichern Mengen -empty_set = set() -# Initialisieren wir ein Set mit ein paar Werten -some_set = {1, 1, 2, 2, 3, 4} # some_set ist jetzt {1, 2, 3, 4} - -# Neue Variablen können einer Menge gleichgesetzt werden -filled_set = some_set - -# Mehr Elemente hinzufügen -filled_set.add(5) # filled_set ist jetzt {1, 2, 3, 4, 5} - -# Schnittmengen werden mit & gebildet -other_set = {3, 4, 5, 6} -filled_set & other_set #=> {3, 4, 5} - -# Mengen werden mit | vereinigt -filled_set | other_set #=> {1, 2, 3, 4, 5, 6} - -# Die Differenz einer Menge mit - bilden -{1,2,3,4} - {2,3,5} #=> {1, 4} - -# Auf Vorhandensein von Elementen mit in prüfen -2 in filled_set #=> True -10 in filled_set #=> False - - -#################################################### -## 3. Kontrollstruktur und Iteratoren -#################################################### - -# Erstellen wir mal eine Variable -some_var = 5 - -# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig! -# gibt "some_var ist kleiner als 10" aus -if some_var > 10: - print("some_var ist viel größer als 10.") -elif some_var < 10: # Dieser elif-Absatz ist optional. - print("some_var ist kleiner als 10.") -else: # Das hier ist auch optional. - print("some_var ist tatsächlich 10.") - - -""" -For-Schleifen iterieren über Listen -Ausgabe: - hund ist ein Säugetier - katze ist ein Säugetier - maus ist ein Säugetier -""" -for animal in ["hund", "katze", "maus"]: - # Wir können Strings mit format() formatieren - print("{} ist ein Säugetier".format(animal)) - -""" -`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder -Ausgabe: - 0 - 1 - 2 - 3 -""" -for i in range(4): - print(i) - -""" -"range(unten, oben)" gibt eine Liste von der unteren Zahl bis zur oberen Zahl aus -Ausgabe: - 4 - 5 - 6 - 7 -""" -for i in range(4, 8): - print(i) - -""" -While-Schleifen laufen, bis eine Bedingung erfüllt ist. -Ausgabe: - 0 - 1 - 2 - 3 -""" -x = 0 -while x < 4: - print(x) - x += 1 # Kurzform für x = x + 1 - -# Ausnahmebehandlung mit einem try/except-Block -try: - # Mit raise wird ein Fehler ausgegeben - raise IndexError("Das hier ist ein Index-Fehler") -except IndexError as e: - pass # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären. -except (TypeError, NameError): - pass # Mehrere Fehler können zusammen geklärt werden, falls erforderlich. -else: # Optional, hinter allen except-Blöcken - print("Keine Probleme!") # Wird nur ausgeführt, wenn keine Ausnahmen aufgetreten sind -finally: # Wird immer ausgeführt - print("Hier können wir Ressourcen aufräumen") - -# alternativ zu einem try/finally Block um Aufzuräumen: -with open("meineDatei.txt") as f: - for line in f: - print(line) - -# Python bietet ein fundamentales Konzept der Iteration. -# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode -# angewandt wird, heißt auf Englisch "iterable". -# Die range Methode gibt ein solches Objekt aus. - -filled_dict = {"one": 1, "two": 2, "three": 3} -our_iterable = filled_dict.keys() -print(our_iterable) #=> range(1,10). Dies ist ein "iterable" Objekt. - -# Über dieses können wir auch iterieren -for i in our_iterable: - print(i) # Gibt one, two, three aus - -# Allerdings können wir die einzelnen Elemente nicht mit ihrem Index ausgeben -our_iterable[1] # TypeError - -# Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft. -our_iterator = iter(our_iterable) - -# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat -# während wir durch es gehen. Das jeweils nächste Objekt bekommen wir mit "next()" -next(our_iterator) #=> "one" - -# Es hält den vorherigen Status -next(our_iterator) #=> "two" -next(our_iterator) #=> "three" - -# Nachdem alle Daten ausgegeben worden sind, kommt eine StopIterator Ausnahme zurück -next(our_iterator) # Gibt StopIteration aus - -# Alle Elemente können mit "list()" ausgegeben werden -list(filled_dict.keys()) #=> ["one", "two", "three"] - -#################################################### -## 4. Funktionen -#################################################### - -# Mit def neue Funktionen erstellen -def add(x, y): - print("x ist %s und y ist %s" % (x, y)) - return x + y # Werte werden mit return zurückgegeben - -# Funktionen mit Parametern aufrufen -add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück - -# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente -add(y=6, x=5) # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden. - -# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren -def varargs(*args): - return args - -varargs(1, 2, 3) #=> (1,2,3) - - -# Wir können auch Funktionen mit beliebiger Anzahl -# Schlüsselwort-Argumenten definieren -def keyword_args(**kwargs): - return kwargs - -# Rufen wir es mal auf, um zu sehen, was passiert -keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} - -# Wir können beides gleichzeitig machen, wenn wir wollen -def all_the_args(*args, **kwargs): - print(args) - print(kwargs) -""" -all_the_args(1, 2, a=3, b=4) Ausgabe: - (1, 2) - {"a": 3, "b": 4} -""" - -# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen! -# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs. -args = (1, 2, 3, 4) -kwargs = {"a": 3, "b": 4} -all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4) -all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4) -all_the_args(*args, **kwargs) # äquivalent zu foo(1, 2, 3, 4, a=3, b=4) - - -# Anwendungsbereich von Funktionen -x = 5 - -def setX(num): - # lokale Variable x ist nicht die globale Variable x - x = num # => 43 - print (x) # => 43 - -def setGlobalX(num): - global x - print (x) # => 5 - x = num # globale Variable x ist jetzt 6 - print (x) # => 6 - -setX(43) -setGlobalX(6) - - -# Python hat First-Class-Funktionen -def create_adder(x): - def adder(y): - return x + y - return adder - -add_10 = create_adder(10) -add_10(3) #=> 13 - -# Es gibt auch anonyme Funktionen -(lambda x: x > 2)(3) #=> True - -# Es gibt auch Funktionen höherer Ordnung als Built-Ins -map(add_10, [1,2,3]) #=> [11, 12, 13] -filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] - -# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen -[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] -[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] - -#################################################### -## 5. Klassen -#################################################### - -# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten. -class Human(object): - - # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt - species = "H. sapiens" - - # Ein simpler Konstruktor - def __init__(self, name): - # Wir weisen das Argument name dem name-Attribut der Instanz zu - self.name = name - - # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument. - def say(self, msg): - return "{name}: {message}".format(name=self.name, message=msg) - - # Eine Klassenmethode wird von allen Instanzen geteilt. - # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen - @classmethod - def get_species(cls): - return cls.species - - # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen - @staticmethod - def grunt(): - return "*grunt*" - - -# Eine Instanz einer Klasse erstellen -i = Human(name="Ian") -print(i.say("hi")) # gibt "Ian: hi" aus - -j = Human("Joel") -print(j.say("hello")) #gibt "Joel: hello" aus - -# Rufen wir mal unsere Klassenmethode auf -i.get_species() #=> "H. sapiens" - -# Ändern wir mal das gemeinsame Attribut -Human.species = "H. neanderthalensis" -i.get_species() #=> "H. neanderthalensis" -j.get_species() #=> "H. neanderthalensis" - -# Aufruf der statischen Methode -Human.grunt() #=> "*grunt*" - - -#################################################### -## 6. Module -#################################################### - -# Wir können Module importieren -import math -print(math.sqrt(16)) #=> 4.0 - -# Wir können auch nur spezielle Funktionen eines Moduls importieren -from math import ceil, floor -print(ceil(3.7)) #=> 4.0 -print(floor(3.7)) #=> 3.0 - -# Wir können auch alle Funktionen eines Moduls importieren -# Warnung: Dies wird nicht empfohlen -from math import * - -# Wir können Modulnamen abkürzen -import math as m -math.sqrt(16) == m.sqrt(16) #=> True - -# Module sind in Python nur gewöhnliche Dateien. Wir -# können unsere eigenen schreiben und importieren. Der Name des -# Moduls ist der Dateiname. - -# Wir können auch die Funktionen und Attribute eines -# Moduls herausfinden. -import math -dir(math) - -#################################################### -## 7. Fortgeschritten -#################################################### - -# Generatoren helfen, um Code schnell und einfach zu schreiben -def double_numbers(iterable): - for i in iterable: - yield i + i - -# Ein Generator erschafft Werte spontan -# Statt alle Werte auf einmal, wird bei jeder Iteration einer erschaffen. -# iteration. Das heißt, Werte größer als 15 werden nicht behandelt. -# Die range-Methode ist auch ein Generator. Im Fall einer Liste von 1-900000000 -# würde das sehr viel Zeit in Anspruch nehmen. -# Wenn wir eine Variable mit einem Namen erschaffen wollen, das -# normalerweise mit einem Python - Schlüsselwort kollidieren würde, -# benutzen wir einen Unterstrich nach dem Wort. -range_ = range(1, 900000000) -# Alle Nummern bis zu einem Ergebnis von >=30 werden verdoppelt -for i in double_numbers(range_): - print(i) - if i >= 30: - break - -# Dekoratoren -# In diesem Beispiel die Methode beg umwickelt say -# Beim Aufruf von beg, wird say aufgerufen -# Falls say_please true ist, ändert sich die ausgegebene Nachricht -from functools import wraps - - -def beg(target_function): - @wraps(target_function) - def wrapper(*args, **kwargs): - msg, say_please = target_function(*args, **kwargs) - if say_please: - return "{} {}".format(msg, "Please! I am poor :(") - return msg - - return wrapper - - -@beg -def say(say_please=False): - msg = "Can you buy me a beer?" - return msg, say_please - - -print(say()) # Can you buy me a beer? -print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :( - -``` - -## Lust auf mehr? - -### Kostenlos online (Englisch) - -* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com) -* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) -* [Dive Into Python](http://www.diveintopython.net/) -* [Ideas for Python Projects](http://pythonpracticeprojects.com) -* [The Official Docs](http://docs.python.org/3/) -* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) -* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) -* [Python Course](http://www.python-course.eu/index.php) -* [First Steps With Python](https://realpython.com/learn/python-first-steps/) - -### Totholz (Englisch) - -* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) -* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) -* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) -- cgit v1.2.3 From d533a06ba06f3bda8365461a7e4965f3be5d7218 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 16 Feb 2020 22:02:27 +0100 Subject: Fixed explanation about legacy python --- de-de/python-de.html.markdown | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index bb1a555d..1de74bc4 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -14,7 +14,8 @@ Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist he Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service]. -Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/pythonlegacy/) weiter. +Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/pythonlegacy/) weiter. Beachte hierbei, +dass Python 2.7 als deprecated gilt und nicht mehr verwendet werden sollte. ```python @@ -119,10 +120,6 @@ False or True #=> True "{name} will {food} essen".format(name="Bob", food="Lasagne") #=> "Bob will Lasagne kochen" -#Falls dein Python3 Code auch unter Python 2.5 oder darunter laufen soll, -# kann das alte Format benutzt werden: -"%s können %s werden" % ("Strings", "interpoliert") - # None ist ein Objekt None #=> None -- cgit v1.2.3 From 9f1addce40a8b75bb78fb5ff8d97ce040cf27110 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 16 Feb 2020 22:07:55 +0100 Subject: removed section with different .format for stringformatting --- de-de/python-de.html.markdown | 4 ---- 1 file changed, 4 deletions(-) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index 1de74bc4..123a781d 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -116,10 +116,6 @@ False or True #=> True "{0} mag Spagetthi, {0} liebt es zu Schwimmen und ganz besonders mag {0} {1}".format("Hans", "Blattsalat") #=> "Hans mag Spagetthi, Hans liebt es zu Schwimmen und ganz besonders mag Hans Blattsalat" -# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen. -"{name} will {food} essen".format(name="Bob", food="Lasagne") -#=> "Bob will Lasagne kochen" - # None ist ein Objekt None #=> None -- cgit v1.2.3 From b27296c82a06dffc0a7149f31518ae5e324f3bbe Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 16 Feb 2020 22:27:19 +0100 Subject: made a whitespace after character I changed the indentation because of a discussion in PR #3839 --- de-de/c-de.html.markdown | 54 ++++++++++++++++++++++++------------------------ 1 file changed, 27 insertions(+), 27 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 3dcb5ab9..9a938b22 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -75,7 +75,7 @@ int add_two_ints(int x1, int x2); // Funktionsprototyp // Der Einstiegspunkt deines Programms ist eine Funktion mit dem Namen main und // einem Integer als Rückgabewert. -int main(void){ +int main(void) { // dein Programm } @@ -87,7 +87,7 @@ int main(void){ // Argumente beinhaltet. // argv[0] = Name des Programms // argv[1] = erstes Argument usw. -int main (int argc, char** argv){ +int main (int argc, char** argv) { // Ausgabe mit Hilfe von printf (print formatted) // %d ist ein Integer. // \n steht für eine neue Zeile @@ -303,19 +303,19 @@ int main (int argc, char** argv){ //////////////////////////////////////////////// // Kontrollstrukturen //////////////////////////////////////////////// - if (0){ + if (0) { printf("Ich werde nie ausgeführt."); } - else if (0){ + else if (0) { printf("Ich werde auch nie ausgeführt."); } - else{ + else { printf("Ich gebe etwas aus."); } // While-Schleifen existieren auch int ii = 0; - while (ii < 10){ // JEDER Wert unter zehn ist wahr + while (ii < 10) { // JEDER Wert unter zehn ist wahr printf("%d, " ii++); //i++ inkrementiert ii NACHDEM der Wert gebraucht // wurde. } // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " @@ -323,16 +323,16 @@ int main (int argc, char** argv){ printf("\n"); int kk = 0; - do{ + do { printf("%d, ", kk); - }while(++kk < 10); //++kk inkrementiert kk BEVOR der Wert gebraucht wurde. + } while(++kk < 10); //++kk inkrementiert kk BEVOR der Wert gebraucht wurde. // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " printf("\n"); // In C gibt es auch for-Schleifen int jj; - for (jj = 0; jj < 10; jj++){ + for (jj = 0; jj < 10; jj++) { printf("%d, ", jj); } // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " @@ -342,14 +342,14 @@ int main (int argc, char** argv){ // Schleifen und Funktionen müssen einen Rumpf haben. Wenn kein Rumpf gebraucht // wird, kann folgendes gemacht werden: int i; - for (i = 0; i <= 5; i++){ + for (i = 0; i <= 5; i++) { ; // Semikolon wird als Rumpf behandelt (Null-Anweisung) } // Alternativ kann auch folgendes geschrieben werden: for (i = 0; i <= 5; i++); // Verzweigungen mit mehreren Möglichkeiten: `switch()` - switch (a){ + switch (a) { case 0: // Labels müssen integrale *konstante* Ausdrücke sein (z.B. Enums) printf("Hey, 'a' ist gleich 0!\n"); break; //Wenn du kein break einsetzt, so geht der Kontrollfluss @@ -441,7 +441,7 @@ int main (int argc, char** argv){ int x_array[20]; // deklariert einen Array der Größe 20 (Größe kann // nicht geändert werden.) int xx; - for (xx =0; xx < 20; xx++){ + for (xx =0; xx < 20; xx++) { x_array[xx] 20 -xx; } // Initialisiere x_array zu 20, 19, 18, ... 2, 1 @@ -478,7 +478,7 @@ int main (int argc, char** argv){ // aus dem Heap - dies kann auf eingebetteten Systemen unterschiedlichen sein. // Der C Standard sagt nichts darüber.) int *my_ptr = malloc(sizeof(*my_ptr) * 20); - for (xx = 0; xx < 20; xx++){ + for (xx = 0; xx < 20; xx++) { *(my_ptr + xx) = 20 -xx; //my_ptr[xx] = 20-xx } // initialisiere Speicher zu 20, 19, 18, 17, ... 2, 1 (als `int`) @@ -497,7 +497,7 @@ int main (int argc, char** argv){ // Füge dem Array ein Element hinzu size++; my_array = realloc(my_array, sizeof(int) *size); - if (my_array == NULL){ + if (my_array == NULL) { // Denke daran, realloc-Fehler zu prüfen return } @@ -538,7 +538,7 @@ int main (int argc, char** argv){ // Syntax einer Funktionsdeklaration // () -int add_two_ints(int x1, int x2){ +int add_two_ints(int x1, int x2) { return x1 + x2; // verwendet return, um einen Wert zurückzugeben } @@ -555,14 +555,14 @@ Beispiel: */ // Eine `void`-Funktion gibt keinen Wert zurück -void str_reverse(char *str_in){ +void str_reverse(char *str_in) { char tmp; size_t ii = 0; size_t size = strlen(str_in); // `strlen()` ist ein Teil der C Standard-Bibliothek. // Merke: Die Länge, welche von `strlen` zurückgegeben wird, ist ohne den // Null-Byte Terminator. - for (ii = 0; i < size /2; ii++){ // in C99 kann man `ii` hier deklarieren. + for (ii = 0; i < size /2; ii++) { // in C99 kann man `ii` hier deklarieren. tmp = str_in[ii]; str_in[ii] = str_in[size - ii - 1]; //#ii'tes Zeichen vom Ende her str_in[size - ii- 1] = tmp; @@ -579,7 +579,7 @@ printf("%s\n", c), => "tseT nie tsi saD" // Weil wir lediglich eine Variable zurückgeben können, kann zum Ändern mehrerer // Variablen das Konzept call-by-reference verwendet werden. -void swap_two_numbers(int *a, int *b){ +void swap_two_numbers(int *a, int *b) { int temp = *a; *a = *b; *b = temp; @@ -600,9 +600,9 @@ Größe eines dynamischen Arrays herausgefunden werden kann. */ // Die Größe des Arrays muss unbedingt mitgegeben werden. // Sonst hat die Funktion keine Ahnung wie groß das Array ist. -void print_int_arrray(int *arr, size_t size){ +void print_int_arrray(int *arr, size_t size) { int i; - for (i = 0; i < size; i++){ + for (i = 0; i < size; i++) { printf("arr[%d] ist %d\n", i, arr[i]); } } @@ -615,7 +615,7 @@ print_int_array(my_array, size); // Wenn man auf externe Variable (außerhalb der Funktion) referenziert, sollte // man das Schlüsselwort `extern` verwenden. int i = 0; -void test_function(){ +void test_function() { extern int i; // i braucht nun die externe Variable i } @@ -643,7 +643,7 @@ my_type my_type_var = 0; // Structs sind lediglich Sammlungen von Daten, die Inhalte werden // (in der Reihenfolge wie sie geschrieben wurden) sequentiell alloziert. -struct rectangle{ +struct rectangle { int width; int height; }; @@ -653,7 +653,7 @@ struct rectangle{ // Dies ist so, weil potentiell ein Padding zwischen den Struktur-Inhalten // möglich ist). (siehe [1, Englisch]) -void function_1(){ +void function_1() { struct rectangle my_rectangle; // Greife auf Struct-Inhalte mit `.` zu. @@ -674,13 +674,13 @@ void function_1(){ // Aus Bequemlichkeitsgründen ist es möglich einem `struct` ein `typedef` hinzuzufügen. typedef struct rectangle rect; -int area(rect r){ +int area(rect r) { return r.width * r.height; } // Wenn du große Structs hast, kannst du diese mit dem Pointer kopieren, // damit große Kopiervorgänge vermieden werden. -int area_ptr(const rect *r){ +int area_ptr(const rect *r) { return r->width * r->height; } @@ -697,7 +697,7 @@ Wie auch immer, die Syntax kann zu Beginn verwirrend wirken. Zum Beispiel: Verwende str_reverse von einem Pointer */ -void str_reverse_through_pointer(char *str_in){ +void str_reverse_through_pointer(char *str_in) { // Definiere eine Funktionspointer-Variable, welche f genannt wird. void (*f)(char *); // Signatur sollte genau der Funktion entsprechen. f = &str_reverse; // weise die Adresse der wirklichen Funktion zu @@ -823,7 +823,7 @@ befindet wie die C-Quelldatei. // Strukturen und Typendefinitionen können verwendet werden, um die Konsistenz // zwischen unterschiedlichen Dateien beizubehalten. -typedef struct Node{ +typedef struct Node { int value; struct Node *next; }Node; -- cgit v1.2.3 From 254a6098761eb8f1f05eef31a84853ba0dbabc86 Mon Sep 17 00:00:00 2001 From: caminsha Date: Mon, 17 Feb 2020 00:24:53 +0100 Subject: Changed sentence about deprecated python 2 --- de-de/python-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index 123a781d..39908f5c 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -15,7 +15,7 @@ Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist he Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service]. Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/pythonlegacy/) weiter. Beachte hierbei, -dass Python 2.7 als deprecated gilt und nicht mehr verwendet werden sollte. +dass Python 2 als veraltet gilt und für neue Projekte nicht mehr verwendet werden sollte. ```python -- cgit v1.2.3 From c5362aaed1d4df5c6bc57c8d65db1b985c546b1d Mon Sep 17 00:00:00 2001 From: caminsha Date: Mon, 17 Feb 2020 00:26:43 +0100 Subject: Added example for f-strings --- de-de/python-de.html.markdown | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'de-de') diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown index 39908f5c..337f1224 100644 --- a/de-de/python-de.html.markdown +++ b/de-de/python-de.html.markdown @@ -116,6 +116,14 @@ False or True #=> True "{0} mag Spagetthi, {0} liebt es zu Schwimmen und ganz besonders mag {0} {1}".format("Hans", "Blattsalat") #=> "Hans mag Spagetthi, Hans liebt es zu Schwimmen und ganz besonders mag Hans Blattsalat" +# Die Formatierung kann auch mit `f-strings` oder formattierten Strings gemacht +# werden (ab Python 3.6+) +name = "Sandra" +f"Sie hat gesagt, ihr name sei {name}." # => Sie hat gesagt, ihr Name sei Sandra." +# Es ist möglich, andere Anweisungen innerhalb der geschweiften Klammern zu +# setzen, welche dann im Output des Strings angezeigt werden. +f"{name} ist {len(name)} Zeichen lang" # => Sandra ist 6 Zeichen lang. + # None ist ein Objekt None #=> None -- cgit v1.2.3 From 2533ae9d9ed1fcafda296ffc79740f6ca5f6c090 Mon Sep 17 00:00:00 2001 From: caminsha Date: Tue, 25 Feb 2020 17:13:36 +0100 Subject: reworded variable declaration comment I reworded the comment so that the English and the German version have the same content. See PR #3864 --- de-de/c-de.html.markdown | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 9a938b22..f9090518 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -180,11 +180,12 @@ int main (int argc, char** argv) { // Typen //////////////////////////////////////////////// - // Alle Variablen müssen am Anfang des jetzigen Blocks deklariert werden. - // Wir deklarieren die Variablen dynamisch im Code um die Lesbarkeit im - // Tutorial zu verbessern. + // Compiler, welche nicht C99-kompatibel sind, verlangen, dass sämtliche + // Variablen zu Beginn des Blocks deklariert werden. // C99-Konforme Compiler erlauben die Variablendeklaration an dem Punkt, an // welchem die Variable verwendet wird. + // Wir deklarieren die Variablen dynamisch im Code um die Lesbarkeit im + // Tutorial zu verbessern. // integer sind normalerweise 4 Bytes groß int x_int = 0; -- cgit v1.2.3 From 20ff967de5b7e3ec517e4bbb504132cb6aee79b1 Mon Sep 17 00:00:00 2001 From: caminsha Date: Tue, 25 Feb 2020 22:44:53 +0100 Subject: Started with German translation of processing --- de-de/processing-de.html.markdown | 161 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 de-de/processing-de.html.markdown (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown new file mode 100644 index 00000000..484300b5 --- /dev/null +++ b/de-de/processing-de.html.markdown @@ -0,0 +1,161 @@ +--- +language: processing +filename: learnprocessing.pde +contributors: + - ["Phone Thant Ko", "http://github.com/phonethantko"] + - ["Divay Prakash", "https://github.com/divayprakash"] +translators: + - ["caminsha", "https://github.com/caminsha"] +filename: processing-de.md +lang: de-de +--- + +## Einführung + +Processing ist eine Programmiersprache, welche es ermöglicht digitale Kunst +und multimediale Inhalte zu erstellen. Mit Processing können Personen ohne +Programmiererfahrung die Grundlagen der Computererfahrung in einem visuellen +Kontext erlernen. + +Obwohl Processing von Java beeinflusst wurde und auf Java basiert, ist die Syntax +sowohl von Java als auch Javascript beeinflusst worden. Weitere Informationen +sind [hier](https://processing.org/reference/) zu finden. + +Die Programmiersprache wird statisch programmiert und kommt mit einer eigenen +offiziellen IDE, damit die Programmie kompiliert und ausgeführt werden können. + +``` +/* ------------ + Mehrzeilige Kommentare werden so gemacht +*/ + +// Einzeilige Kommentare funktionieren so // + +/* + Da Processing von Java abstammt, ist die Syntax für Kommentare gleich + wie bei Java (wie du vielleicht oben bemerkt hast)! + Mehrzeilige Kommentare werden wie hier umschlossen. +*/ + +/* ------------------------------------------------- + Schreiben und Ausführen von Processing Programmen + ------------------------------------------------- +*/ + +// In Processing ist der Startpunkt eines Programms die Funktion `setup()` +// mit dem Rückgabewert `void`. +// Beachte: Die Syntax ist derjenigen von C++ ziemlich ähnlich. +void setup() { + // Dies gibt beim Ausführen "Hallo Welt!" auf der Konsole aus. + println("Hallo Welt!"); // eine weitere Sprache mit einem Semikolon am Ende. +} + +// Normalerweise wird der Code für statische Elemente innerhalb der Methode +// `setup()` geschrieben, da diese lediglich einmal ausgeführt wird. +// Dies kann zum Beispiel das Setzen der Hintergrundfarbe oder das Bestimmen +// der Canvas-Grösse sein. +background(color); // Setze die Hintergrundfarbe +size(width, height, [renderer]); // bestimme die Canvasgrösse mit dem optionalen + // Parameter `renderer`. +// Du wirst innerhalb dieses Dokuments noch weitere Parameter sehen. + +// Wenn du möchstest, dass Code unendlich oft ausgeführt wird, so muss dieser +// Code innerhalb der `draw()`-Methode stehen. +// `draw()` muss existieren, wenn du möchtest, dass das Programm durchgehend +// läuft. Die `draw()`-Methode darf nur einmal vorkommen. + +int i = 0; +void draw() { + // Dieser Codeblock wird ausgeführt bis er gestoppt wird. + print(i); + i++; // Inkrement Operator! +} + +// Da wir nun wissen, wie man ein funktionierendes Skript erstellen kann und wie +// dieses ausgeführt wird, fahren wir mit den unterschiedlichen Datentypen und +// Collections weiter, welche in Processing unterstützt werden. + +/* ------------------------------------------------- + Datentypen und Collections + ------------------------------------------------- +*/ + +// Gemäss den Angaben in der Processingreferenz, unterstützt Processing die +// folgenden acht primitive Datentypen: +boolean booleanValue = true; // Boolean +byte byteValueOfA = 23; // Byte +char charValueOfA = 'A'; // Char (einzelnes Zeichen) +color colorValueOfWhiteM = color(255, 255, 255); // Farben (angegeben durch die + // `color()`-Methode) +color colorValueOfWhiteH = #FFFFFF; // Farbe (angegeben mit der Hexadezimal- + // schreibweise. +int intValue = 5; // Integer (ganze Zahl) +long longValue = 2147483648L; // "L" wird hinzugefügt, um es als `long` zu + // markieren. +float floatValue = 1.12345; // Float (32-Bit Gleitkommazahl) +double doubleValue = 1.12345D // Double (64-Bit Gleitkommazahl) + +//BEACHTE! +// Auch wenn es die Datentypen "long" und "double" gibt und auch funktionieren, +// verwenden Processing-Funktionen diese Datentypen nicht. Das bedeutet, dass +// diese zu "int" resp. "float" konvertiert werden müssen. +// Dies geschieht, indem man `(int)` oder `(float)` vor die Variable schreibt, +// bevor diese einer Funktion übergeben werden. + +// Es gibt eine ganze Reiher zusammengesetzter Datentypen, welche in Processing +// gebraucht werden können. Um Zeit zu sparen, gehen wir in diesem Tutorial +// lediglich die wichtigsten durch. + +// String +// Während der Datentyp `char` einfache Anzührungszeichen (' ') braucht, haben +// Strings doppelte Anführungszeichen (" "). +String sampleString = "Hallo, Processing!"; +// Strings können auch durch ein Array von `char`s erstellt werden. +// Wir werden Arrays gleich anschauen. +char source = {'H', 'A', 'L', 'L', 'O'}; +String stringFromSource = new String(source); // HALLO +// Wie auch in Java können in Processing Strings auch zusammengefügt werden +// mit dem +-Operator. +print("Hallo " + "Welt!"); // => Hallo Welt! + + +// Arrays +// In Processing können Arrays jeden Datentypen beinhalten, sogar Objekte. +// Da Arrays ähnlich wie Objekte sind, müssen diese mit dem Schlüsselwort `new` +// erstellt werden. +int[] intArray = new int[5]; +int[] intArrayWithValues = {1, 2, 3} // Arrays können auch mit Daten gefüllt + // werden. +// ArrayList +// Die Funktionen einer ArrayList sind ähnlich wie die eines Arrays und können +// auch jegliche Datentypen beinhalten. Der einzige Unterschied zwischen Arrays +// und `ArrayList`s ist, dass eine ArrayList die Grösse dynamisch anpassen kann, +// da es eine Implementierung des "List" Interface in Java ist. +ArrayList intArrayList = new ArrayList(); + +// Objekte +// Da Processing auf Java basiert, unterstützt Processing die Objektorientierte +// Programmierung. Dies bedeutet, dass du grundsätzlich jegliche Datentypen +// selber erstellen kannst und diese nach deinen Bedürfnissen manipulieren kannst. +// Selbstverständlich muss eine Klasse definiert werden bevor du ein Objekt +// instanzieren kannst. +// Format: ClassName InstanceName +SomeRandomClass myObject // hier musst du das Objekt später instazieren +// Hier wird das Objekt direkt instanziert: +SomeRandomClass myObjectInstantiated = new SomeRandomClass(); + +// Processing hat noch weitere Collection (wie zum Beispiel Dictionaries und +// Listen). Aus Einfachheitsgründen wird dies in diesem Tutorial weggelassen. + +/* ------------------------------------------------- + Mathematik + ------------------------------------------------- +*/ + +// Arithmetik +1 + 1 // => 2 +2 -1 // => 1 +2 * 3 // => 6 +3 / 2 // => 1 +3.0 / 2 // => 1.5 +3.0 % 2 // => 1.0 (Modulo) -- cgit v1.2.3 From 99da0047a64df63bf7e6451fe46faac4b2468407 Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 27 Feb 2020 23:08:33 +0100 Subject: finished section mathematics --- de-de/processing-de.html.markdown | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 484300b5..1be66b32 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -159,3 +159,29 @@ SomeRandomClass myObjectInstantiated = new SomeRandomClass(); 3 / 2 // => 1 3.0 / 2 // => 1.5 3.0 % 2 // => 1.0 (Modulo) + +// Processing beinhaltet auch einige Funktionen, welche mathematische +// Operationen vereinfachen +float f = sq(3); // Quadrat => f = 9.0 +float p = pow(3, 3); // Potenz => p = 27.0 +int a = abs(-13); // Absolute Zahl => a = 13 +int r1 = round(3.1); // Runden => r1 = 3 +int r2 = round(3.7); // Runden => r2 = 4 +int sr = sqrt(25); // Quadratwurzel => sr = 5.0 + +// Vektoren +// Processing bietet eine einfache Möglichkeit an, mit Vektoren zu arbeiten mit +// der Klasse PVector. Die Klasse kann zwei- und dreidimensionale Vektoren +// darstellen und bietet Methoden an, welche nützlich sein können für Matrizen- +// Operationen. Weitere Informationen findest du hier: +// (https://processing.org/reference/PVector.html) + +// Trigonometrie +// Processing unterstützt auch trigonometrische Operationen mit Hilfe dieser +// Funktionen: `sin()`, `cos()`, `tan()`, `asin()`, `atan()`. Für die einfache +// Konvertierung gibt es ausserdem noch die Funktionen `degrees()` und `radians()`. +// Die trigonometrischen Funktionen rechnen mit dem Winkelmass Radian, wodurch +// die Gradzahlen zuerst konvertiert werden müssen. +float one = sin(PI/2); // => one = 1.0 +// Wie du vielleicht bemerkt hast, existieren einige Konstanten für trigo- +// metrische Operationen; `PI`, `HALF_PI`, `QUARTER_PI` und so weiter ... -- cgit v1.2.3 From 0a4f6f111a7df78aea121f3bd969fc3d51d5bc2c Mon Sep 17 00:00:00 2001 From: caminsha Date: Thu, 27 Feb 2020 23:34:03 +0100 Subject: added control flows --- de-de/processing-de.html.markdown | 62 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 1be66b32..5e626d5e 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -185,3 +185,65 @@ int sr = sqrt(25); // Quadratwurzel => sr = 5.0 float one = sin(PI/2); // => one = 1.0 // Wie du vielleicht bemerkt hast, existieren einige Konstanten für trigo- // metrische Operationen; `PI`, `HALF_PI`, `QUARTER_PI` und so weiter ... + +/* ------------------------------------------------- + Kontrollstrukturen + ------------------------------------------------- +*/ + +// Bedingte Anweisungen +// Bedinge Anweisungen werden gleich wie in Java geschrieben. +if (author.getAppearence().equals("hot")) { + print("Narzissmus vom Feinsten!") +} else { + // Du kannst hier weitere Bedingungen prüfen. + print("Irgendetwas ist falsch hier!"); +} +// Für die `if`-Anweisungen gibt es auch eine Kurzschreibweise +// Dies sind sogenannte ternäre Operatoren. +int i = 3; +String value = (i > 5) ? "Gross" : "Klein"; // => "Klein" + +// Die Switch-Case-Anweisung kann verwendet werden, um mehrere Bedingungen +// zu prüfen. +// Wichtig ist, dass nach jeder Bedingung ein `break`-Statement verwendet wird, +// sonst werden alle folgenden ausgeführt und es wird nicht mehr überprüft, ob +// die Bedingung wahr ist. +int value = 2; +switch(value) { + case 0: + print("Auf keinen Fall!"); // Dies wird nicht ausgeführt. + break; // Geht zum nächsten Statement und prüft dieses + case 1: + print("Wir kommen näher..."); // Auch dies wird nicht ausgeführt + break; + case 2: + print("Bravo!"); // Dies wird ausgeführt. + break; + default: + print("Nicht gefunden."); // Diese Zeile wird ausgeführt, wenn keine + // der anderen Operatoren wahr sind. + break; +} + +// Wiederholungen +// For-Statements - Auch hier ist die Syntax wieder gleich wie in Java +for(int i = 0; i < 5; i++){ + print(i); // Gibt die Zahlen 0 bis 4 aus. +} + +// While-Statements +int j = 3; +while(j > 0) { + print(j); + j--; // Dies ist wichtig, dass der Code nicht unendlich lange läuft. +} + +// `loop()` | `noloop()` | `redraw()` | `exit()` +// Dies sind spezifische Funktionen, welche in Processing verwendet werden +// können, um den Programmablauf zu steuern. +loop(); // erlaubt es der `draw()`-Methode immer zu laufen, während +noloop(); // dies nur für einmal erlaubt. +redraw(); // führt die `draw()`-Methode noch einmal aus. +exit(); // Diese Methode stoppt das Programm. Dies kann nützlich sein, wenn die + // Methode `draw()` immer läuft. -- cgit v1.2.3 From 93133f9a7f3be5fa9065f4ac5746fed1b283c9db Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 29 Feb 2020 17:51:13 +0100 Subject: Started to translate the drawing part --- de-de/processing-de.html.markdown | 51 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 5e626d5e..31d126a1 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -247,3 +247,54 @@ noloop(); // dies nur für einmal erlaubt. redraw(); // führt die `draw()`-Methode noch einmal aus. exit(); // Diese Methode stoppt das Programm. Dies kann nützlich sein, wenn die // Methode `draw()` immer läuft. +``` + +## Mit Processing zeichnen + +Da du nun die Grundsätze der Programmiersprache verstanden hast, schauen wir +uns nun das Beste an Processing an - Das Zeichnen! + +``` + +/* ------------------------------------------------- + Figuren + ------------------------------------------------- +*/ + +// 2D-Figuren + +// Punkte +point(x,y); // im zweidimensionalen Raum +point(x, y, z); // im dreidimensionalen Raum +// Diese Befehle zeichnen einen Punkt an der Koordinate. + +// Linien +line(x1, y1, x2, y2); // im zweidimensionalen Raum +line(x1, y1, z1, x2, y2, z2); // im dreidimensionalen Raum +// Dies zeichnet eine Linie, welche durch die zwei Punkte (x1, y1) und (x2, y2) +// definiert wird. + +// Dreieck +triangle(x1, y1, x2, y2, x3, y3); +// Zeichnet ein Dreieck, welches als Eckpunkte die drei Koordinaten hat. + +// Rechteck +rect(a, b, c, d, [r]); // Mit dem optionalen Parameter kann der Winkel aller + // vier Ecken definiert werden +rect(a, b, c, d, [tl, tr, br, bl]); // Mit weiteren optionalen Parametern kann + // jeder Winkel des Rechtecks definiert werden. +// Dies zeichnet ein Quadrat mit der Koordinate {a, b} als linke obere Ecke; +// die Parameter c und d sind für die Breite und Höhe. + +// Vierecke +quad(x, y, x2, y2, x3, y3, x4, y4); +// Dies zeichnet ein Viereck, welches die einzelnen Koordinaten als Eckpunkte hat. + +// Ellipse +ellipse(x, y, x2, y2, x3, y3, x4, y4); +// Zeichnet eine Ellipse beim Punkt {x. y}. Die Parameter Breite und Höhre +// sind auch definiert. + +// Arc +arc(x, y, width, height, start, stop, [mode]); + -- cgit v1.2.3 From 2cc553e15b7228330a76d3e32d7d830872cee72a Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 1 Mar 2020 21:57:37 +0100 Subject: added some new things in drawing shapes --- de-de/processing-de.html.markdown | 46 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 31d126a1..779d3add 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -297,4 +297,50 @@ ellipse(x, y, x2, y2, x3, y3, x4, y4); // Arc arc(x, y, width, height, start, stop, [mode]); +// Die ersten vier Parameter sollten selbsterklärend sein. +// start und end definieren die Winkel, bei welchen `arc` starten resp. enden +// (in Radians) +// Der optionale Parameter `mode` definiert, ob der Kreisbogen gefüllt wird +// oder nicht. +// Die möglichen Optionen für `mode` sind: PIE, CHORD und OPEN. + +// Kurven +// Processing bietet zwei mögliche Kurven an, welche verwendet werden können. +// Da es hier darum geht, dass es möglichst simpel ist, werden hier keine +// weiteren Details genannt. Wenn du Kurven in deinem Programm verwenden möchtest, +// sind die folgenden Links empfehlenswert: +// https://processing.org/reference/curve_.html +// https://processing.org/reference/bezier_.html + + +// 3D-Figuren + +// Der dreidimensionale Raum kann aktiviert werden, indem man den Renderer- +// Parameter in der Methode `size()` zu "P3D" setzt. +size(width, height, P3D); +// Im dreidimensionalen Raum müssen die Koordinaten übersetzt werden, damit +// diese korrekt gerendert werden. + +// Box +box(size); // Würfel mit der Seitenlänge `size` +box(w, h, d); // Quader definiert durch Breite, Hoehe und Tiefe + +// Kugel +sphere(radius); // Die Grösse wird definiert durch den Parameter `radius` +// Der Mechanismus hinter dem Rendern von Kugeln wurde durch mosaikartige +// Dreiecke implementiert. +// Mit der folgenden Funktion ist es möglich, zu bestimmen wie detailliert die +// Kugel gerendert wird. +// spereDetail(res); +// Weitere Informationen sind hier zu finden: (https://processing.org/reference/sphereDetail_.html) + +// Unregelmässige Figuren +// Was ist, wenn du etwas zeichnen möchtest, was nicht durch Processing-Funktionen +// abgedeckt ist? +// Es ist möglich, die Funktionen `beginShape()`, `endShape()` und `vertex(x,y) +// zu verwenden. +// Weitere Informationen findest du hier: (https://processing.org/reference/beginShape_.html) +// Du kannst selber gemachte Formen auch verwenden mit der PShape-Klasse. +// Informationen zu PShape gibt es hier: (https://processing.org/reference/PShape.html) + -- cgit v1.2.3 From 3be8d1867f855afa665ac12340afdeb8158d58a9 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 1 Mar 2020 22:36:56 +0100 Subject: Added transformamtions sections to translation --- de-de/processing-de.html.markdown | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 779d3add..bc6e542b 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -343,4 +343,28 @@ sphere(radius); // Die Grösse wird definiert durch den Parameter `radius` // Du kannst selber gemachte Formen auch verwenden mit der PShape-Klasse. // Informationen zu PShape gibt es hier: (https://processing.org/reference/PShape.html) +/* ------------------------------------------------- + Transformationen + ------------------------------------------------- +*/ +// Tranformationen sind nützlich, um ständig zu wissen, wo die Koordinaten und +// die Ecken einer Form sind, welche du gezeichnet hast. Grundsätzlich sind dies +// Matrizenoperationen. `pushMatrix()`, `popMatrix()` und `translate()`. +pushMatrix(); // Speichert das aktuelle Koordinatensystem auf dem Stack +// ... alle Transformationen werden hier angewendet. +popMatrix(); // Stellt das gespeicherte Koordinatensystem wieder her. +// Wenn du diese Funktionen verwendest, kann das Koordinatensystem gespeichert +// und visualisiert werden, ohne dass es Konflikte gibt. + +// Translate +translate(x,y); // Setzt den Ursprung zu diesem Punkt. +translate(x, y, z); // Pendant zu der oberen Funktion im dreidimensionalen Raum + +// Rotationen +rotate(angle); // Rotiere, um den Betrag, welcher spezifiert wurde. +// Es gibt drei Pendants im dreidimensionalen Raum. +// Namentlich sind dies: `rotateX(angle)`, `rotateY(angle)` und `rotateZ(angle)` + +// Skalierung +scale(s); // Skaliert das Koordinatensystem (entweder erweitern oder verkleinern) -- cgit v1.2.3 From f49bfb839890343b36359b026e303b4b8c62efcf Mon Sep 17 00:00:00 2001 From: caminsha Date: Mon, 2 Mar 2020 09:46:30 +0100 Subject: Added styling and textures --- de-de/processing-de.html.markdown | 42 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index bc6e542b..3513529d 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -368,3 +368,45 @@ rotate(angle); // Rotiere, um den Betrag, welcher spezifiert wurde. // Skalierung scale(s); // Skaliert das Koordinatensystem (entweder erweitern oder verkleinern) + +/* ------------------------------------------------- + Styling und Texturen + ------------------------------------------------- +*/ + +// Farben +// Wie ich zuvor schon erklärt habe, kann die Hintergrundfarbe mit der Funktion +// `background()` definiert werden. Ausserdem ist es möglich, dass man zuerst +// eine Farbe definiert und diese erst danach der Funktion übergeben wird. +color c = color(255, 255, 255); // WEISS! +// Standardmässig verwendet Processing das RGB-Farbschema, aber dies kann +// zu HSB konfiguriert werden, indem die Funktion `colorMode()` verwendet wird. +// Weitere Informationen findest du hier: (https://processing.org/reference/colorMode_.html) +background(c); // Ab jetzt ist der Hintergrund in weiss. +// Du kannst die Funktion `fill()` verwenden, um die Farbe auszuwählen, mit +// welcher die Formen ausgefüllt werden. +// Dies muss konfiguriert werden bevor Formen und Figuren gezeichnet werden. +fill(color(0, 0, 0)); +// Wenn du nur die Farbe der Umrandungen definieren möchtest, kannst du die +// Funktion `stroke()` verwenden. +stroke(255, 255, 0, 200); // Linienfarbe wird zu gelb mit einer höheren + // Transparenz geändert. + +// Bilder +// Processing kann Bilder rendern und diese unterschiedlich verwenden. Die +// meisten Bilder sind im Datentyp `PImage` gespeichert. +filter(shader); // Processing unterstützt mehrere Filter-Funktionen, damit + // Bilder verändert werden können. +texture(image); // PImage kann als Argument, weiteren Funktionen übergeben + // werden, um die Figuren zu "Text" zu machen. +``` + +Wenn du weitere Dinge mit Processing kennenlernen willst, dann gibt es unzählige +Dinge, welche du mit Processing machen kannst. Das Rendern von Modellen, +Schattierungen und viele mehr. Für ein kurzes Tutorial bietet Processing zu viel, +daher verweise ich dich, falls du interessiert bist, auf die offizielle +Dokumentaion. + +``` +// Bevor wir weiterfahren, werde ich einige Aspekte zum Importieren von +// Bibliotheken und Paketen sagen, damit du Processing erweitern kannst.. -- cgit v1.2.3 From b7aea95d260e3812cf28b516636d6e3b34d435bc Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 8 Mar 2020 20:00:57 +0100 Subject: added import section --- de-de/processing-de.html.markdown | 12 ++++++++++++ 1 file changed, 12 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 3513529d..08b58e3f 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -410,3 +410,15 @@ Dokumentaion. ``` // Bevor wir weiterfahren, werde ich einige Aspekte zum Importieren von // Bibliotheken und Paketen sagen, damit du Processing erweitern kannst.. + +/* ------------------------------------------------- + Import + ------------------------------------------------- +*/ + +// Die Macht von Processing kann besser veranschaulicht werden, wenn wir +// Bibliotheken und Pakete importieren. +// Die Import-Anweisung kann wie unten geschrieben zu Beginn des Quelltextes +// geschrieben werden. +import processing.something.*; +``` -- cgit v1.2.3 From b55cdf0fcc1ec33880fb62c073d2f60a297fc87b Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 20 Mar 2020 20:59:09 +0100 Subject: added example program --- de-de/processing-de.html.markdown | 73 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 08b58e3f..76de2f47 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -422,3 +422,76 @@ Dokumentaion. // geschrieben werden. import processing.something.*; ``` + +## Beispielprogramm + +Lass uns ein Beispiel von openprocessing.org ansehen, welches verdeutlicht, +was man in Processing mit nur wenigen Zeilen Code machen kann. + +Kopiere den nachfolgenden Code in deine Processing IDE. + +``` +// Disclaimer: Ich habe das Porgramm nicht selbst geschriben. Diese Skizze +// stammt aus openprocessing, allerdings soll dieses Programm zeigen, wie wenig +// Zeilen Code notwendig sind, um etwas Cooles zu machen. +// Abgerufen von: (https://www.openprocessing.org/sketch/559769) + +float theta; +float a; +float col; +float num; + +void setup() { + size(600,600); +} + +void draw() { + background(#F2F2F2); + translate(width/2, height/2); + theta = map(sin(millis()/1000.0), -1, 1, 0, PI/6); + + float num=6; + for (int i=0; i30) { + pushMatrix(); + translate(0, -30); + rotate(theta); + branch(len); + popMatrix(); + + pushMatrix(); + translate(0, -30); + rotate(-theta); + branch(len); + popMatrix(); + } +} +``` + +Processing ist einfach zu erlernen und ist vorallem nützlich, um Multimedia- +Inhalte (auch in 3D) zu erstellen ohne viel Code zu schreiben. Es ist so einfach +gehalten, dass man den Code durchlesen kann und man versteht den Programmablauf +bereits. + +Wenn du externe Bibliotheken, Pakete oder eigene Klassen einbindest, kann ein +Programm, welches mit Processing geschrieben wurde, durchaus auch kompliziert +werden. + +## Einige nützliche Links + +- [Processing Webseite](http://processing.org) +- [Processing Sketches](http://openprocessing.org) -- cgit v1.2.3 From 88e91516cf7058392d8ebedd208f708fd03ee576 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 20 Mar 2020 20:59:40 +0100 Subject: =?UTF-8?q?changed=20ss=20to=20=C3=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- de-de/processing-de.html.markdown | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index 76de2f47..af44b6fd 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -34,7 +34,7 @@ offiziellen IDE, damit die Programmie kompiliert und ausgeführt werden können. /* Da Processing von Java abstammt, ist die Syntax für Kommentare gleich wie bei Java (wie du vielleicht oben bemerkt hast)! - Mehrzeilige Kommentare werden wie hier umschlossen. + Mehrzeilige Kommentare werden wie hier umschloßen. */ /* ------------------------------------------------- @@ -53,9 +53,9 @@ void setup() { // Normalerweise wird der Code für statische Elemente innerhalb der Methode // `setup()` geschrieben, da diese lediglich einmal ausgeführt wird. // Dies kann zum Beispiel das Setzen der Hintergrundfarbe oder das Bestimmen -// der Canvas-Grösse sein. +// der Canvas-Größe sein. background(color); // Setze die Hintergrundfarbe -size(width, height, [renderer]); // bestimme die Canvasgrösse mit dem optionalen +size(width, height, [renderer]); // bestimme die Canvasgröße mit dem optionalen // Parameter `renderer`. // Du wirst innerhalb dieses Dokuments noch weitere Parameter sehen. @@ -80,7 +80,7 @@ void draw() { ------------------------------------------------- */ -// Gemäss den Angaben in der Processingreferenz, unterstützt Processing die +// Gemäß den Angaben in der Processingreferenz, unterstützt Processing die // folgenden acht primitive Datentypen: boolean booleanValue = true; // Boolean byte byteValueOfA = 23; // Byte @@ -129,7 +129,7 @@ int[] intArrayWithValues = {1, 2, 3} // Arrays können auch mit Daten gefüllt // ArrayList // Die Funktionen einer ArrayList sind ähnlich wie die eines Arrays und können // auch jegliche Datentypen beinhalten. Der einzige Unterschied zwischen Arrays -// und `ArrayList`s ist, dass eine ArrayList die Grösse dynamisch anpassen kann, +// und `ArrayList`s ist, dass eine ArrayList die Größe dynamisch anpassen kann, // da es eine Implementierung des "List" Interface in Java ist. ArrayList intArrayList = new ArrayList(); @@ -179,8 +179,8 @@ int sr = sqrt(25); // Quadratwurzel => sr = 5.0 // Trigonometrie // Processing unterstützt auch trigonometrische Operationen mit Hilfe dieser // Funktionen: `sin()`, `cos()`, `tan()`, `asin()`, `atan()`. Für die einfache -// Konvertierung gibt es ausserdem noch die Funktionen `degrees()` und `radians()`. -// Die trigonometrischen Funktionen rechnen mit dem Winkelmass Radian, wodurch +// Konvertierung gibt es außerdem noch die Funktionen `degrees()` und `radians()`. +// Die trigonometrischen Funktionen rechnen mit dem Winkelmaß Radian, wodurch // die Gradzahlen zuerst konvertiert werden müssen. float one = sin(PI/2); // => one = 1.0 // Wie du vielleicht bemerkt hast, existieren einige Konstanten für trigo- @@ -202,7 +202,7 @@ if (author.getAppearence().equals("hot")) { // Für die `if`-Anweisungen gibt es auch eine Kurzschreibweise // Dies sind sogenannte ternäre Operatoren. int i = 3; -String value = (i > 5) ? "Gross" : "Klein"; // => "Klein" +String value = (i > 5) ? "Groß" : "Klein"; // => "Klein" // Die Switch-Case-Anweisung kann verwendet werden, um mehrere Bedingungen // zu prüfen. @@ -326,7 +326,7 @@ box(size); // Würfel mit der Seitenlänge `size` box(w, h, d); // Quader definiert durch Breite, Hoehe und Tiefe // Kugel -sphere(radius); // Die Grösse wird definiert durch den Parameter `radius` +sphere(radius); // Die Größe wird definiert durch den Parameter `radius` // Der Mechanismus hinter dem Rendern von Kugeln wurde durch mosaikartige // Dreiecke implementiert. // Mit der folgenden Funktion ist es möglich, zu bestimmen wie detailliert die @@ -334,7 +334,7 @@ sphere(radius); // Die Grösse wird definiert durch den Parameter `radius` // spereDetail(res); // Weitere Informationen sind hier zu finden: (https://processing.org/reference/sphereDetail_.html) -// Unregelmässige Figuren +// Unregelmäßige Figuren // Was ist, wenn du etwas zeichnen möchtest, was nicht durch Processing-Funktionen // abgedeckt ist? // Es ist möglich, die Funktionen `beginShape()`, `endShape()` und `vertex(x,y) @@ -376,13 +376,13 @@ scale(s); // Skaliert das Koordinatensystem (entweder erweitern oder verkleinern // Farben // Wie ich zuvor schon erklärt habe, kann die Hintergrundfarbe mit der Funktion -// `background()` definiert werden. Ausserdem ist es möglich, dass man zuerst +// `background()` definiert werden. Außerdem ist es möglich, dass man zuerst // eine Farbe definiert und diese erst danach der Funktion übergeben wird. color c = color(255, 255, 255); // WEISS! -// Standardmässig verwendet Processing das RGB-Farbschema, aber dies kann +// Standardmäßig verwendet Processing das RGB-Farbschema, aber dies kann // zu HSB konfiguriert werden, indem die Funktion `colorMode()` verwendet wird. // Weitere Informationen findest du hier: (https://processing.org/reference/colorMode_.html) -background(c); // Ab jetzt ist der Hintergrund in weiss. +background(c); // Ab jetzt ist der Hintergrund in weiß. // Du kannst die Funktion `fill()` verwenden, um die Farbe auszuwählen, mit // welcher die Formen ausgefüllt werden. // Dies muss konfiguriert werden bevor Formen und Figuren gezeichnet werden. -- cgit v1.2.3 From 06aa701d87a13d2d6f145f946e0cc24bdde1db26 Mon Sep 17 00:00:00 2001 From: caminsha Date: Fri, 20 Mar 2020 21:14:54 +0100 Subject: Fixed some typos in translation --- de-de/processing-de.html.markdown | 41 ++++++++++++++++++++------------------- 1 file changed, 21 insertions(+), 20 deletions(-) (limited to 'de-de') diff --git a/de-de/processing-de.html.markdown b/de-de/processing-de.html.markdown index af44b6fd..42ae2233 100644 --- a/de-de/processing-de.html.markdown +++ b/de-de/processing-de.html.markdown @@ -12,17 +12,17 @@ lang: de-de ## Einführung -Processing ist eine Programmiersprache, welche es ermöglicht digitale Kunst +Processing ist eine Programmiersprache, welche es ermöglicht, digitale Kunst und multimediale Inhalte zu erstellen. Mit Processing können Personen ohne -Programmiererfahrung die Grundlagen der Computererfahrung in einem visuellen -Kontext erlernen. +Programmiererfahrung die Grundlagen der Computerprogrammierung in einem +visuellen Kontext erlernen. Obwohl Processing von Java beeinflusst wurde und auf Java basiert, ist die Syntax sowohl von Java als auch Javascript beeinflusst worden. Weitere Informationen sind [hier](https://processing.org/reference/) zu finden. Die Programmiersprache wird statisch programmiert und kommt mit einer eigenen -offiziellen IDE, damit die Programmie kompiliert und ausgeführt werden können. +offiziellen IDE, damit die Programme kompiliert und ausgeführt werden können. ``` /* ------------ @@ -43,7 +43,7 @@ offiziellen IDE, damit die Programmie kompiliert und ausgeführt werden können. */ // In Processing ist der Startpunkt eines Programms die Funktion `setup()` -// mit dem Rückgabewert `void`. +// mit dem Rückgabetyp `void`. // Beachte: Die Syntax ist derjenigen von C++ ziemlich ähnlich. void setup() { // Dies gibt beim Ausführen "Hallo Welt!" auf der Konsole aus. @@ -68,7 +68,7 @@ int i = 0; void draw() { // Dieser Codeblock wird ausgeführt bis er gestoppt wird. print(i); - i++; // Inkrement Operator! + i++; // Inkrement-Operator } // Da wir nun wissen, wie man ein funktionierendes Skript erstellen kann und wie @@ -81,14 +81,14 @@ void draw() { */ // Gemäß den Angaben in der Processingreferenz, unterstützt Processing die -// folgenden acht primitive Datentypen: +// folgenden acht primitiven Datentypen: boolean booleanValue = true; // Boolean byte byteValueOfA = 23; // Byte char charValueOfA = 'A'; // Char (einzelnes Zeichen) color colorValueOfWhiteM = color(255, 255, 255); // Farben (angegeben durch die // `color()`-Methode) color colorValueOfWhiteH = #FFFFFF; // Farbe (angegeben mit der Hexadezimal- - // schreibweise. + // schreibweise.) int intValue = 5; // Integer (ganze Zahl) long longValue = 2147483648L; // "L" wird hinzugefügt, um es als `long` zu // markieren. @@ -129,7 +129,7 @@ int[] intArrayWithValues = {1, 2, 3} // Arrays können auch mit Daten gefüllt // ArrayList // Die Funktionen einer ArrayList sind ähnlich wie die eines Arrays und können // auch jegliche Datentypen beinhalten. Der einzige Unterschied zwischen Arrays -// und `ArrayList`s ist, dass eine ArrayList die Größe dynamisch anpassen kann, +// und `ArrayList`s ist, dass eine `ArrayList` die Größe dynamisch anpassen kann, // da es eine Implementierung des "List" Interface in Java ist. ArrayList intArrayList = new ArrayList(); @@ -138,13 +138,13 @@ ArrayList intArrayList = new ArrayList(); // Programmierung. Dies bedeutet, dass du grundsätzlich jegliche Datentypen // selber erstellen kannst und diese nach deinen Bedürfnissen manipulieren kannst. // Selbstverständlich muss eine Klasse definiert werden bevor du ein Objekt -// instanzieren kannst. +// davon instanzieren kannst. // Format: ClassName InstanceName SomeRandomClass myObject // hier musst du das Objekt später instazieren // Hier wird das Objekt direkt instanziert: SomeRandomClass myObjectInstantiated = new SomeRandomClass(); -// Processing hat noch weitere Collection (wie zum Beispiel Dictionaries und +// Processing hat noch weitere Collections (wie zum Beispiel Dictionaries und // Listen). Aus Einfachheitsgründen wird dies in diesem Tutorial weggelassen. /* ------------------------------------------------- @@ -227,8 +227,8 @@ switch(value) { } // Wiederholungen -// For-Statements - Auch hier ist die Syntax wieder gleich wie in Java -for(int i = 0; i < 5; i++){ +// For-Schleifen - Auch hier ist die Syntax wieder gleich wie in Java +for(int i = 0; i < 5; i++) { print(i); // Gibt die Zahlen 0 bis 4 aus. } @@ -270,9 +270,10 @@ point(x, y, z); // im dreidimensionalen Raum // Linien line(x1, y1, x2, y2); // im zweidimensionalen Raum -line(x1, y1, z1, x2, y2, z2); // im dreidimensionalen Raum // Dies zeichnet eine Linie, welche durch die zwei Punkte (x1, y1) und (x2, y2) // definiert wird. +line(x1, y1, z1, x2, y2, z2); // im dreidimensionalen Raum +// Analog wird hier eine Linie gezeichnet mit drei Punkten // Dreieck triangle(x1, y1, x2, y2, x3, y3); @@ -283,7 +284,7 @@ rect(a, b, c, d, [r]); // Mit dem optionalen Parameter kann der Winkel aller // vier Ecken definiert werden rect(a, b, c, d, [tl, tr, br, bl]); // Mit weiteren optionalen Parametern kann // jeder Winkel des Rechtecks definiert werden. -// Dies zeichnet ein Quadrat mit der Koordinate {a, b} als linke obere Ecke; +// Dies zeichnet ein Quadrat mit der Koordinate {a, b} als linke obere Ecke // die Parameter c und d sind für die Breite und Höhe. // Vierecke @@ -291,9 +292,9 @@ quad(x, y, x2, y2, x3, y3, x4, y4); // Dies zeichnet ein Viereck, welches die einzelnen Koordinaten als Eckpunkte hat. // Ellipse -ellipse(x, y, x2, y2, x3, y3, x4, y4); -// Zeichnet eine Ellipse beim Punkt {x. y}. Die Parameter Breite und Höhre -// sind auch definiert. +ellipse(x, y, width, height); +// Zeichnet eine Ellipse beim Punkt {x. y}. Die Breite und die Höhe werden durch +// die Parameter width und height definiert. // Arc arc(x, y, width, height, start, stop, [mode]); @@ -323,7 +324,7 @@ size(width, height, P3D); // Box box(size); // Würfel mit der Seitenlänge `size` -box(w, h, d); // Quader definiert durch Breite, Hoehe und Tiefe +box(w, h, d); // Quader definiert durch Breite, Höhe und Tiefe // Kugel sphere(radius); // Die Größe wird definiert durch den Parameter `radius` @@ -352,7 +353,7 @@ sphere(radius); // Die Größe wird definiert durch den Parameter `radius` // die Ecken einer Form sind, welche du gezeichnet hast. Grundsätzlich sind dies // Matrizenoperationen. `pushMatrix()`, `popMatrix()` und `translate()`. pushMatrix(); // Speichert das aktuelle Koordinatensystem auf dem Stack -// ... alle Transformationen werden hier angewendet. + // alle Transformationen werden hier angewendet. popMatrix(); // Stellt das gespeicherte Koordinatensystem wieder her. // Wenn du diese Funktionen verwendest, kann das Koordinatensystem gespeichert // und visualisiert werden, ohne dass es Konflikte gibt. -- cgit v1.2.3 From f94cd548b3f047be4f6af37d56b95a123d8edb3d Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 26 Apr 2020 04:04:54 +0200 Subject: started translation of vim --- de-de/vim-de.html.markdown | 274 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 274 insertions(+) create mode 100644 de-de/vim-de.html.markdown (limited to 'de-de') diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown new file mode 100644 index 00000000..a5d0519f --- /dev/null +++ b/de-de/vim-de.html.markdown @@ -0,0 +1,274 @@ +--- +category: tool +tool: vim +lang = de-de +contributors: + - ["RadhikaG", "https://github.com/RadhikaG"] +translators: + - ["caminsha", "https://github.com/caminsha"] +filename: LearnVim-de.txt +--- + + +[Vim](http://www.vim.org) +(Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein +Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt +wurde. +Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten +einer Datei. + +## Grundlagen, um in Vim zu navigieren + +``` + vim # Öffne in Vim + :help # Open up built-in help docs about if any exists + :q # Schliesse vim + :w # Speichere diese Datei + :wq # Speichere diese Datei und schliesse vim + ZZ # Speichere diese Datei und schliesse vim + :q! # Schliesse vim ohne die Datei zu speichern + # ! *zwingt* die Ausführung von :q, + # daher wird die Datei nicht gespeichert. + ZQ # Beende vim ohne die Datei zu speichern + :x # Speichere die Datei und beende vim + # Dies ist eine kürzere Version von :wq + + u # Änderung rückgängig machen + CTRL+R # Änderung wiederherstellen + + h # Den Cursor um ein Zeichen nach links bewegen + j # Den Cursor eine Zeile nach unten bewegen + k # Den Cursor eine Zeile nach oben bewegen + l # Den Cursor um ein Zeichen nach rechts bewegen + + Ctrl+B # Gehe eine Bildschirmanzeige zurück + Ctrl+F # Gehe eine Bildschirmanzeige vorwärts + Ctrl+D # Gehe eine halbe Bildschirmanzeige vorwärts + Ctrl+U # Gehe eine halbe Bildschirmanzeige zurück + + # Navigieren innerhalb einer Zeile + + 0 # Navigiere zum Anfang der Zeile + $ # Navigiere zum Ende der Zeile + ^ # Navigiere zum ersten Zeichen, welchen kein Leerzeichen ist + + # Im Text suchen + + /word # Hebt alle Ergebnisse nach dem Cursor hervor + ?word # Hebt alle Ergebnisse vor dem Cursor hervor + n # Bewegt den Cursor zum nächsten Ergebnis nach der Suche + N # Bewegt den Cursor zum vorherigen Ergebnis der Suche + + :%s/foo/bar/g # Ersetze "foo" durch "bar" in allen Zeilen + :s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile + :%s/\n/\r/g # Replace new line characters with new line characters + + # Jumping to characters + + f # Jump forward and land on + t # Jump forward and land right before + + # For example, + f< # Jump forward and land on < + t< # Jump forward and land right before < + + # Moving by word + + w # Move forward by one word + b # Move back by one word + e # Move to end of current word + + # Other characters for moving around + + gg # Go to the top of the file + G # Go to the bottom of the file + :NUM # Go to line number NUM (NUM is any number) + H # Move to the top of the screen + M # Move to the middle of the screen + L # Move to the bottom of the screen +``` + +## Help docs: + +Vim has built in help documentation that can accessed with `:help `. +For example `:help navigation` will pull up documentation about how to navigate +your workspace! + +`:help` can also be used without an option. This will bring up a default help dialog +that aims to make getting started with vim more approachable! + +## Modes: + +Vim is based on the concept on **modes**. + +- Command Mode - vim starts up in this mode, used to navigate and write commands +- Insert Mode - used to make changes in your file +- Visual Mode - used to highlight text and do operations to them +- Ex Mode - used to drop down to the bottom with the ':' prompt to enter commands + +``` + i # Puts vim into insert mode, before the cursor position + a # Puts vim into insert mode, after the cursor position + v # Puts vim into visual mode + : # Puts vim into ex mode + # 'Escapes' from whichever mode you're in, into Command mode + + # Copying and pasting text + + y # Yank whatever is selected + yy # Yank the current line + d # Delete whatever is selected + dd # Delete the current line + p # Paste the copied text after the current cursor position + P # Paste the copied text before the current cursor position + x # Deleting character under current cursor position +``` + +## The 'Grammar' of vim + +Vim can be thought of as a set of commands in a +'Verb-Modifier-Noun' format, where: + +- Verb - your action +- Modifier - how you're doing your action +- Noun - the object on which your action acts on + +A few important examples of 'Verbs', 'Modifiers', and 'Nouns': + +``` + # 'Verbs' + + d # Delete + c # Change + y # Yank (copy) + v # Visually select + + # 'Modifiers' + + i # Inside + a # Around + NUM # Number (NUM is any number) + f # Searches for something and lands on it + t # Searches for something and stops before it + / # Finds a string from cursor onwards + ? # Finds a string before cursor + + # 'Nouns' + + w # Word + s # Sentence + p # Paragraph + b # Block + + # Sample 'sentences' or commands + + d2w # Delete 2 words + cis # Change inside sentence + yip # Yank inside paragraph (copy the para you're in) + ct< # Change to open bracket + # Change the text from where you are to the next open bracket + d$ # Delete till end of line +``` + +## Some shortcuts and tricks + + +``` + > # Indent selection by one block + < # Dedent selection by one block + :earlier 15m # Reverts the document back to how it was 15 minutes ago + :later 15m # Reverse above command + ddp # Swap position of consecutive lines, dd then p + . # Repeat previous action + :w !sudo tee % # Save the current file as root + :set syntax=c # Set syntax highlighting to 'c' + :sort # Sort all lines + :sort! # Sort all lines in reverse + :sort u # Sort all lines and remove duplicates + ~ # Toggle letter case of selected text + u # Selected text to lower case + U # Selected text to upper case + + # Fold text + zf # Create fold from selected text + zo # Open current fold + zc # Close current fold + zR # Open all folds + zM # Close all folds +``` + +## Macros + +Macros are basically recordable actions. +When you start recording a macro, it records **every** action and command +you use, until you stop recording. On invoking a macro, it applies the exact +same sequence of actions and commands again on the text selection. + +``` + qa # Start recording a macro named 'a' + q # Stop recording + @a # Play back the macro +``` + +### Configuring ~/.vimrc + +The .vimrc file can be used to configure Vim on startup. + +Here's a sample ~/.vimrc file: + +``` +" Example ~/.vimrc +" 2015.10 + +" Required for vim to be iMproved +set nocompatible + +" Determines filetype from name to allow intelligent auto-indenting, etc. +filetype indent plugin on + +" Enable syntax highlighting +syntax on + +" Better command-line completion +set wildmenu + +" Use case insensitive search except when using capital letters +set ignorecase +set smartcase + +" When opening a new line and no file-specific indenting is enabled, +" keep same indent as the line you're currently on +set autoindent + +" Display line numbers on the left +set number + +" Indentation options, change according to personal preference + +" Number of visual spaces per TAB +set tabstop=4 + +" Number of spaces in TAB when editing +set softtabstop=4 + +" Number of spaces indented when reindent operations (>> and <<) are used +set shiftwidth=4 + +" Convert TABs to spaces +set expandtab + +" Enable intelligent tabbing and spacing for indentation and alignment +set smarttab +``` + +### References + +[Vim | Home](http://www.vim.org/index.php) + +`$ vimtutor` + +[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/) + +[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) + +[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) -- cgit v1.2.3 From 9943c1e0260c077223ea8e431af91cb3f44b7028 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 26 Apr 2020 23:13:57 +0200 Subject: Translation of vim to german --- de-de/vim-de.html.markdown | 268 +++++++++++++++++++++++---------------------- 1 file changed, 137 insertions(+), 131 deletions(-) (limited to 'de-de') diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown index a5d0519f..d2d2fb84 100644 --- a/de-de/vim-de.html.markdown +++ b/de-de/vim-de.html.markdown @@ -61,214 +61,220 @@ einer Datei. :%s/foo/bar/g # Ersetze "foo" durch "bar" in allen Zeilen :s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile - :%s/\n/\r/g # Replace new line characters with new line characters + :%s/\n/\r/g # Ersetze das newline-Zeichen durch ein carriage return. - # Jumping to characters + # Zu einzelnen Zeichen springen - f # Jump forward and land on - t # Jump forward and land right before + f # Springe vorwärts und auf dem Zeichen + t # Springe vorwärts und lande vor dem Zeichen - # For example, - f< # Jump forward and land on < - t< # Jump forward and land right before < + # Zum Beispiel, + f< # Springe vorwärts und lande auf < + t< # Springe vorwärts und lande vor < - # Moving by word + # Wortweise navigieren - w # Move forward by one word - b # Move back by one word - e # Move to end of current word + w # Springe um ein Wort vorwärts + b # Gehe ein Wort zurück + e # Springe zum Ende des aktuellen Wortes - # Other characters for moving around + # Weitere Befehle, um zu navigieren - gg # Go to the top of the file - G # Go to the bottom of the file - :NUM # Go to line number NUM (NUM is any number) - H # Move to the top of the screen - M # Move to the middle of the screen - L # Move to the bottom of the screen + gg # Gehe an den Start der Datei + G # Gehe an das Ende der Datei + :NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein) + H # Navigiere zum Start des aktuellen Screens + M # Navigiere in die Mitte des aktuellen Screens + L # Navigiere an das Ende des aktuellen Screens ``` -## Help docs: +## Hilfsdokumente: -Vim has built in help documentation that can accessed with `:help `. -For example `:help navigation` will pull up documentation about how to navigate -your workspace! +Vim hat eine eingebaute Dokumentation, welche mit `:help ` aufgerufen +werden kann. +Zum Beispiel öffnet `:help navigation` die Dokumentation über das Navigieren -`:help` can also be used without an option. This will bring up a default help dialog +`:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard- +Hilfsdialog an, welcher den Start mit vim einfacher macht. that aims to make getting started with vim more approachable! -## Modes: +## Modi: -Vim is based on the concept on **modes**. +Vim basiert auf dem Konzept von **modes**. -- Command Mode - vim starts up in this mode, used to navigate and write commands -- Insert Mode - used to make changes in your file -- Visual Mode - used to highlight text and do operations to them -- Ex Mode - used to drop down to the bottom with the ':' prompt to enter commands +- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und + Befehle eingeben +- Insert Mode - Wird verwendet, um Änderungen in der Datei zu machen. +- Visual Mode - Wird verwendet, um Text zu markieren und Operationen durchzuführen +- Ex Mode - Wird verwendet, um im ':'-Prompt Befehle einzugeben ``` - i # Puts vim into insert mode, before the cursor position - a # Puts vim into insert mode, after the cursor position - v # Puts vim into visual mode - : # Puts vim into ex mode - # 'Escapes' from whichever mode you're in, into Command mode - - # Copying and pasting text - - y # Yank whatever is selected - yy # Yank the current line - d # Delete whatever is selected - dd # Delete the current line - p # Paste the copied text after the current cursor position - P # Paste the copied text before the current cursor position - x # Deleting character under current cursor position + i # Führt vim in den Insert Mode, vor der Cursorposition + a # Führt vim in den Insert Mode, nach der Cursorposition + v # Führt vim in den Visual Mode + : # Führt vim in den Ex Mode + # Führt zurück in den Command Mode, egal in welchem Mode + # man sich gerade befindet. + + # Kopieren und einfügen von Text + + y # Kopiere alles, was im Moment ausgewählt ist + yy # Kopiert die aktuelle Zeile + d # Löscht alles, was im Moment ausgewählt ist + dd # Löscht die aktuelle Zeile + p # Fügt den kopierten Text nach dem Cursor ein + P # Fügt den kopierten Text vor dem Cursor ein + x # Löscht das Zeichen unter dem Cursor ``` -## The 'Grammar' of vim +## Die 'Grammatik' von Vim -Vim can be thought of as a set of commands in a -'Verb-Modifier-Noun' format, where: +Vim kann als Satz von Kommandos angesehen werden, welche im Format +'Verb-Modifier-Noun' sind. Hierbei gilt: -- Verb - your action -- Modifier - how you're doing your action -- Noun - the object on which your action acts on +- Verb - die Aktion, du machen willst +- Modifier - wie die Aktion gemacht wird +- Noun - das Objekt, auf welchem die Aktion ausgeführt wird. -A few important examples of 'Verbs', 'Modifiers', and 'Nouns': +Einige wichtige Beispiele von 'Verben', 'Modifier' und 'Nouns': ``` - # 'Verbs' + # 'Verben' - d # Delete - c # Change - y # Yank (copy) - v # Visually select + d # löschen + c # ändern + y # kopieren + v # visuelles auswählen # 'Modifiers' - i # Inside - a # Around - NUM # Number (NUM is any number) - f # Searches for something and lands on it - t # Searches for something and stops before it - / # Finds a string from cursor onwards - ? # Finds a string before cursor + i # innerhalb + a # ausserhalb + NUM # Nummer (NUM kann irgendeine Zahl sein) + f # Sucht nach etwas und landet darauf + t # Sucht nach etwas und stoppt davor + / # Suche eine Zeichenfolge ab dem Cursor + ? # Suche eine Zeichenfolge vor dem Cursor # 'Nouns' - w # Word - s # Sentence - p # Paragraph + w # Wort + s # Satz + p # Abschnitt b # Block - # Sample 'sentences' or commands + # Beispielsätze resp. Kommandos - d2w # Delete 2 words - cis # Change inside sentence - yip # Yank inside paragraph (copy the para you're in) - ct< # Change to open bracket - # Change the text from where you are to the next open bracket - d$ # Delete till end of line + d2w # lösche zwei Wörter + cis # Ändere innerhalb des Satzes. + yip # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt, + # in welchem du bist) + ct< # Ändere bis zur spitzen Klammer + # Ändere den Text von deiner aktuellen Cursorposition bis + # zur nächsten spitzen Klammer + d$ # Lösche bis zum Ende der Zeile ``` -## Some shortcuts and tricks +## Einige Shortcuts und Tricks - ``` - > # Indent selection by one block - < # Dedent selection by one block - :earlier 15m # Reverts the document back to how it was 15 minutes ago - :later 15m # Reverse above command - ddp # Swap position of consecutive lines, dd then p - . # Repeat previous action - :w !sudo tee % # Save the current file as root - :set syntax=c # Set syntax highlighting to 'c' - :sort # Sort all lines - :sort! # Sort all lines in reverse - :sort u # Sort all lines and remove duplicates - ~ # Toggle letter case of selected text - u # Selected text to lower case - U # Selected text to upper case + > # Rücke die Auswahl um einen Block ein + < # Lösche eine Einrückung der Auswahl + :earlier 15m # Stellt das Dokument so wieder her, wie es vor 15 + # Minuten war + :later 15m # den oberen Befehl rückgängig machen + ddp # Vertauschen zweier aufeinanderfolgenden Zeilen + # Zuerst dd, dann p + . # Wiederhole die vorherige Aktion + :w !sudo tee % # Speichere die Datei als Root + :set syntax=c # Stelle das Syntax-Highlighting für 'C' ein + :sort # Alle Zeilen sortieren + :sort! # Alle Zeilen rückwärts sortieren + :sort u # Alle Zeilen sortieren und Duplikate entfernen + ~ # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes + u # Ausgewählten Text zu Kleinschreibung ändern + U # Ausgewählten Text zu Großschreibung ändern - # Fold text - zf # Create fold from selected text - zo # Open current fold - zc # Close current fold - zR # Open all folds - zM # Close all folds + # Text-Folding (Textfaltung) + zf # Erstelle eine Faltung des ausgewählten Textes + zo # Öffne die aktuelle Faltung + zc # Schliesse die aktuelle Faltung + zR # Öffne alle Faltungen + zM # Schliesse alle Faltungen ``` -## Macros +## Makros -Macros are basically recordable actions. -When you start recording a macro, it records **every** action and command -you use, until you stop recording. On invoking a macro, it applies the exact -same sequence of actions and commands again on the text selection. +Makros sind grundsätzlich einfach aufgezeichnete Aktionen +Wenn du mit dem Aufnehmen eines Makros beginnst, werden **alle** Aktionen und +Kommandos, welche du braucht, aufgenommen bis die Aufnahme gestoppt wird. +Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht. ``` - qa # Start recording a macro named 'a' - q # Stop recording - @a # Play back the macro + qa # Starte das Aufnehmen des Makros 'a' + q # Beende das Aufnehmen + @a # Führe ein Makro aus ``` -### Configuring ~/.vimrc +### Konfigurieren mit ~/.vimrc -The .vimrc file can be used to configure Vim on startup. +Die Datei .vimrc kann verwendet werden, um Vim beim Starten zu konfigurieren -Here's a sample ~/.vimrc file: +Hier ist eine Beispiel ~/.vimrc Datei: ``` -" Example ~/.vimrc -" 2015.10 +" Beispiel ~/.vimrc -" Required for vim to be iMproved +" Erforderlich für vim, dass es iMproved ist. set nocompatible -" Determines filetype from name to allow intelligent auto-indenting, etc. +" Bestimme den Dateityp anhand des Namens, um ein intelligentes Einrücken etc. +" zu ermöglichen filetype indent plugin on -" Enable syntax highlighting +" Aktiviere das Syntax-Highlighting syntax on -" Better command-line completion +" Bessere Kommandozeile Vervollständigung set wildmenu -" Use case insensitive search except when using capital letters +" Verwende die Suche ohne die Berücksichtigung der Groß-/Kleinschreibung, ausser +" wenn mit Grossbuchstaben gesucht wird. set ignorecase set smartcase -" When opening a new line and no file-specific indenting is enabled, -" keep same indent as the line you're currently on +" Wenn eine neue Zeile erstellt wird und kein Dateispezifisches Einrücken +" aktiviert ist, behält die neue Zeile die gleiche Einrückung wie die aktuelle +" Zeile set autoindent -" Display line numbers on the left +" Zeige links die Zeilennummern an set number -" Indentation options, change according to personal preference +" Einrückungsoptionen, ändere diese nach deinen Vorlieben -" Number of visual spaces per TAB +" Anzahl sichtbarer Leerzeichen bei einem TAB set tabstop=4 -" Number of spaces in TAB when editing +" Anzahl der Leerzeichen während des Bearbeitens bei einem TAB set softtabstop=4 -" Number of spaces indented when reindent operations (>> and <<) are used +" Anzahl der Einrückungstiefe bei den Operationen (>> und <<) set shiftwidth=4 -" Convert TABs to spaces +" Konvertiere TABs zu Leerzeichen set expandtab " Enable intelligent tabbing and spacing for indentation and alignment +" Aktiviere intelligente Tabs und Leerzeichen bei der Einrückung und Ausrichtung set smarttab ``` -### References +### Verweise -[Vim | Home](http://www.vim.org/index.php) - -`$ vimtutor` - -[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/) - -[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) - -[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) +- [Vim | Homepage](http://www.vim.org/index.php) +- In der Shell eingeben: `vimtutor` +- [Ein vim Tutorial und Primer, englisch](https://danielmiessler.com/study/vim/) +- [Deutsches Arch Linux Wiki](https://wiki.archlinux.de/title/Vim) +- [Arch Linux Wiki, englisch (dafür ausführlicher)](https://wiki.archlinux.org/index.php/Vim) +- [What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) -- cgit v1.2.3 From ec64fcbedadb38c42cf8a288f1cfe8e41c66fb6c Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 26 Apr 2020 23:17:30 +0200 Subject: =?UTF-8?q?replaced=20'ss'=20with=20'=C3=9F'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- de-de/vim-de.html.markdown | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'de-de') diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown index d2d2fb84..ffceaec2 100644 --- a/de-de/vim-de.html.markdown +++ b/de-de/vim-de.html.markdown @@ -22,11 +22,11 @@ einer Datei. ``` vim # Öffne in Vim :help # Open up built-in help docs about if any exists - :q # Schliesse vim + :q # Schließe vim :w # Speichere diese Datei - :wq # Speichere diese Datei und schliesse vim - ZZ # Speichere diese Datei und schliesse vim - :q! # Schliesse vim ohne die Datei zu speichern + :wq # Speichere diese Datei und schließe vim + ZZ # Speichere diese Datei und schließe vim + :q! # Schließe vim ohne die Datei zu speichern # ! *zwingt* die Ausführung von :q, # daher wird die Datei nicht gespeichert. ZQ # Beende vim ohne die Datei zu speichern @@ -149,7 +149,7 @@ Einige wichtige Beispiele von 'Verben', 'Modifier' und 'Nouns': # 'Modifiers' i # innerhalb - a # ausserhalb + a # außerhalb NUM # Nummer (NUM kann irgendeine Zahl sein) f # Sucht nach etwas und landet darauf t # Sucht nach etwas und stoppt davor @@ -198,9 +198,9 @@ Einige wichtige Beispiele von 'Verben', 'Modifier' und 'Nouns': # Text-Folding (Textfaltung) zf # Erstelle eine Faltung des ausgewählten Textes zo # Öffne die aktuelle Faltung - zc # Schliesse die aktuelle Faltung + zc # Schließe die aktuelle Faltung zR # Öffne alle Faltungen - zM # Schliesse alle Faltungen + zM # Schließe alle Faltungen ``` ## Makros @@ -238,8 +238,8 @@ syntax on " Bessere Kommandozeile Vervollständigung set wildmenu -" Verwende die Suche ohne die Berücksichtigung der Groß-/Kleinschreibung, ausser -" wenn mit Grossbuchstaben gesucht wird. +" Verwende die Suche ohne die Berücksichtigung der Groß-/Kleinschreibung, außer +" wenn mit Großbuchstaben gesucht wird. set ignorecase set smartcase -- cgit v1.2.3 From 1b29d50730baefd80f16e1c1b99a6ed22841ea13 Mon Sep 17 00:00:00 2001 From: caminsha Date: Sun, 26 Apr 2020 23:57:37 +0200 Subject: fixed small typos --- de-de/vim-de.html.markdown | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) (limited to 'de-de') diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown index ffceaec2..2800b949 100644 --- a/de-de/vim-de.html.markdown +++ b/de-de/vim-de.html.markdown @@ -22,6 +22,8 @@ einer Datei. ``` vim # Öffne in Vim :help # Open up built-in help docs about if any exists + :help # Öffne die eingebaute Hilfe zum Thema , wenn + # es existiert :q # Schließe vim :w # Speichere diese Datei :wq # Speichere diese Datei und schließe vim @@ -50,7 +52,7 @@ einer Datei. 0 # Navigiere zum Anfang der Zeile $ # Navigiere zum Ende der Zeile - ^ # Navigiere zum ersten Zeichen, welchen kein Leerzeichen ist + ^ # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist # Im Text suchen @@ -61,7 +63,8 @@ einer Datei. :%s/foo/bar/g # Ersetze "foo" durch "bar" in allen Zeilen :s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile - :%s/\n/\r/g # Ersetze das newline-Zeichen durch ein carriage return. + :%s/\n/\r/g # Ersetze das newline-Zeichen bei allen Zeilen durch + # ein carriage return # Zu einzelnen Zeichen springen @@ -83,9 +86,9 @@ einer Datei. gg # Gehe an den Start der Datei G # Gehe an das Ende der Datei :NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein) - H # Navigiere zum Start des aktuellen Screens - M # Navigiere in die Mitte des aktuellen Screens - L # Navigiere an das Ende des aktuellen Screens + H # Navigiere zum Start der aktuellen Bildschirmanzeige + M # Navigiere in die Mitte der aktuellen Bildschirmanzeige + L # Navigiere an das Ende der aktuellen Bildschirmanzeige ``` ## Hilfsdokumente: @@ -102,8 +105,7 @@ that aims to make getting started with vim more approachable! Vim basiert auf dem Konzept von **modes**. -- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und - Befehle eingeben +- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und Befehle eingeben - Insert Mode - Wird verwendet, um Änderungen in der Datei zu machen. - Visual Mode - Wird verwendet, um Text zu markieren und Operationen durchzuführen - Ex Mode - Wird verwendet, um im ':'-Prompt Befehle einzugeben @@ -136,10 +138,10 @@ Vim kann als Satz von Kommandos angesehen werden, welche im Format - Modifier - wie die Aktion gemacht wird - Noun - das Objekt, auf welchem die Aktion ausgeführt wird. -Einige wichtige Beispiele von 'Verben', 'Modifier' und 'Nouns': +Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns': ``` - # 'Verben' + # 'Verb' d # löschen c # ändern @@ -213,7 +215,7 @@ Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht. ``` qa # Starte das Aufnehmen des Makros 'a' q # Beende das Aufnehmen - @a # Führe ein Makro aus + @a # Führe das Makro 'a' aus ``` ### Konfigurieren mit ~/.vimrc @@ -235,7 +237,7 @@ filetype indent plugin on " Aktiviere das Syntax-Highlighting syntax on -" Bessere Kommandozeile Vervollständigung +" Bessere Kommandozeilen-Vervollständigung set wildmenu " Verwende die Suche ohne die Berücksichtigung der Groß-/Kleinschreibung, außer -- cgit v1.2.3 From f420555c64bfe3503970b4496acfb160b065e96b Mon Sep 17 00:00:00 2001 From: caminsha Date: Sat, 2 May 2020 02:44:21 +0200 Subject: Fixed a small typo Elemenent -> Elementen --- de-de/elm-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/elm-de.html.markdown b/de-de/elm-de.html.markdown index b74a975f..08832327 100644 --- a/de-de/elm-de.html.markdown +++ b/de-de/elm-de.html.markdown @@ -62,7 +62,7 @@ List.range 1 5 ++ List.range 6 10 == List.range 1 10 -- True 0 :: List.range 1 5 -- [0, 1, 2, 3, 4, 5] -- Die Funktionen "head" und "tail" haben als Rückgabewert den "Maybe" Typ. --- Dadurch wird die Fehlerbehandlung von fehlenden Elemenent explizit, weil +-- Dadurch wird die Fehlerbehandlung von fehlenden Elementen explizit, weil -- man immer mit jedem möglichen Fall umgehen muss. List.head (List.range 1 5) -- Just 1 List.tail (List.range 1 5) -- Just [2, 3, 4, 5] -- cgit v1.2.3 From 2d5b9890c5d11e86c8f89fb4074045efaa817e6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul=20G=C3=B6tze?= Date: Thu, 21 May 2020 00:07:24 +0200 Subject: [ruby/de] Update to be in sync with English version --- de-de/ruby-de.html.markdown | 782 ++++++++++++++++++++++++-------------------- 1 file changed, 429 insertions(+), 353 deletions(-) (limited to 'de-de') diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown index e14603cd..8025a8c0 100644 --- a/de-de/ruby-de.html.markdown +++ b/de-de/ruby-de.html.markdown @@ -1,5 +1,6 @@ --- language: ruby +filename: ruby-de.rb contributors: - ["David Underwood", "http://theflyingdeveloper.com"] - ["Joel Walden", "http://joelwalden.net"] @@ -11,602 +12,677 @@ contributors: - ["Dzianis Dashkevich", "https://github.com/dskecse"] - ["Levi Bostian", "https://github.com/levibostian"] - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gabriel Halley", "https://github.com/ghalley"] + - ["Persa Zula", "http://persazula.com"] + - ["Jake Faris", "https://github.com/farisj"] + - ["Corey Ward", "https://github.com/coreyward"] + - ["Jannik Siebert", "https://github.com/janniks"] + - ["Keith Miyake", "https://github.com/kaymmm"] translators: - ["Christian Albrecht", "https://github.com/coastalchief"] - ["Dennis Keller", "https://github.com/denniskeller"] -filename: ruby-de.rb + - ["Paul Götze", "https://gitub.com/paulgoetze"] lang: de-de --- -# Dies ist ein Kommentar +```ruby +# Das ist ein Kommentar =begin -Dies sind multi-line -Kommentare. Niemand benutzt -die wirklich. +Das ist ein mehrzeiliger Kommentar. +Die Anfangszeile muss mit "=begin" beginnen +und die Endzeile muss mit "=end" beginnen. + +Alternativ kannst du jede Zeile in einem +mehrzeiligen Kommentar mit dem # Zeichen beginnen. =end -# Objekte - Alles ist ein Objekt +# In Ruby ist (fast) alles ein Objekt. +# Das schließt Zahlen ein... +3.class #=> Integer -## Zahlen sind Objekte -``` -3.class #=> Fixnum -3.to_s #=> "3" -``` +# ...und Zeichenketten (Strings)... +"Hallo".class #=> String -### Simple Arithmetik -``` +# ...und sogar Methoden! +"Hallo".method(:class).class #=> Method + +# Simple Arithmetik 1 + 1 #=> 2 8 - 1 #=> 7 10 * 2 #=> 20 35 / 5 #=> 7 -2**5 #=> 32 -``` +2 ** 5 #=> 32 +5 % 3 #=> 2 -// Arithmetik ist aber eigentlich nur syntaktischer Zucker -// um eine Methode eines Objekt aufzurufen -``` +# Bitweise Operatoren +3 & 5 #=> 1 +3 | 5 #=> 7 +3 ^ 5 #=> 6 + +# Arithmetik ist aber eigentlich nur syntaktischer Zucker +# um eine Methode eines Objekts aufzurufen 1.+(3) #=> 4 10.* 5 #=> 50 -``` +100.methods.include?(:/) #=> true -## Special values sind Objekte -``` -nil # Nothing to see here -true # truth -false # falsehood +## Spezielle Werte sind Objekte +nil # Equivalent zu null in anderen Sprachen +true # Wahrheitswert +false # Falschheitswert nil.class #=> NilClass true.class #=> TrueClass false.class #=> FalseClass -``` -## Objektvergleiche -### Gleicheit -``` +# Gleicheit 1 == 1 #=> true 2 == 1 #=> false -``` -### Ungleichheit -``` + +# Ungleichheit 1 != 1 #=> false 2 != 1 #=> true -``` -### Neben false selbst, nil ist ein anderer 'falsey' Wert -``` -!nil #=> true -!false #=> true -!0 #=> false -``` -### Weitere Vergleiche -``` + +# Neben false selbst, ist nil der einzige andere +# zu Falsch evaluierende Wert + +!!nil #=> false +!!false #=> false +!!0 #=> true +!!"" #=> true + +# Weitere Vergleiche 1 < 10 #=> true 1 > 10 #=> false 2 <= 2 #=> true 2 >= 2 #=> true -``` + +# Kombinierter Vergleichsoperator (gibt `1` zurück wenn das erste Argument +# größer ist, und `-1`, wenn das zweite Argument größer ist, sonst `0`) +1 <=> 10 #=> -1 (1 < 10) +10 <=> 1 #=> 1 (10 > 1) +1 <=> 1 #=> 0 (1 == 1) + ### Logische Operatoren -``` true && false #=> false true || false #=> true -!true #=> false -``` -Es gibt alternative Versionen der logischen Operatoren mit niedrigerer -Wertigkeit. Diese werden meistens bei Flow-Control eingesetzt, um -verschiedenen Ausdrücke zu verketten bis einer true oder false zurück -liefert. +# Es gibt alternative Versionen der logischen Operatoren mit niedrigerer +# Wertigkeit. Diese werden meistens zur Flusskontrolle eingesetzt, um +# verschiedenen Ausdrücke zu verketten bis einer true oder false zurück +# liefert. -#### and -##### `do_something_else` wird nur ausgewertet wenn `do_something` true ist. +# `do_something_else` wird nur ausgewertet wenn `do_something` true ist. do_something() and do_something_else() - -#### or -#####`log_error` wird nur ausgewertet wenn `do_something` false ist. +# `log_error` wird nur ausgewertet wenn `do_something` false ist. do_something() or log_error() -## Strings sind Objekte -``` -'I am a string'.class #=> String -"I am a string too".class #=> String +# String Interpolation +placeholder = 'Ruby' +"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungszeichen füllen." +#=> "Ich kann in Ruby Platzhalter mit doppelten Anführungszeichen füllen." -platzhalter = 'Ruby' -"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungsstrichen füllen." -``` -Einfache Anführungszeichen sollten bevorzugt werden. -Doppelte Anführungszeichen führen interne Berechnungen durch. +# Du kannst Strings mit `+` verbinden, nicht jedoch mit anderen Typen +'hallo ' + 'Welt' #=> "hallo Welt" +'Hallo ' + 3 #=> TypeError: no implicit conversion of Integer into String +'hallo ' + 3.to_s #=> "hallo 3" +"hallo #{3}" #=> "hallo 3" + +# ...oder Strings mit Operatoren kombinieren +'hallo ' * 3 #=> "hallo hallo hallo " + +# ...oder Strings an andere Strings anhängen +'hallo' << ' Welt' #=> "hallo Welt" + +# Du kannst Text mit einer neuen Zeile am Ende ausgeben +puts "Ich gebe Text aus!" +#=> Ich gebe Text aus! +#=> nil + +# ...oder Text ohne einen Zeilenumbruch ausgeben +print "Ich gebe Text aus!" +#=> "Ich gebe Text aus!" => nil -### Strings können verbunden werden, aber nicht mit Zahlen -``` -'hello ' + 'world' #=> "hello world" -'hello ' + 3 #=> TypeError: can't convert Fixnum into String -``` -#### Zahl muss in String konvertiert werden -``` -'hello ' + 3.to_s #=> "hello 3" -``` -### Text ausgeben -``` -puts "I'm printing!" -``` # Variablen -## Zuweisungen -### Diese Zuweisung gibt den zugeordneten Wert zurück -``` x = 25 #=> 25 x #=> 25 -``` -### Damit funktionieren auch mehrfache Zuweisungen -``` + +# Beachte, dass Zuweisungen den zugewiesenen Wert zurückgeben. +# D.h. du kannst mehrfache Zuweisungen machen. + x = y = 10 #=> 10 x #=> 10 y #=> 10 -``` -## Benennung -### Konvention ist snake_case -``` + +# Nutze snake_case für Variablennamen. snake_case = true -``` -### Benutze verständliche Variablennamen -``` -path_to_project_root = '/good/name/' -path = '/bad/name/' -``` -# Symbols (sind auch Objekte) -Symbols sind unveränderliche, wiederverwendbare Konstanten, welche intern -als integer repräsentiert werden. Sie werden häufig anstelle von Strings -verwendet, um sinnvoll Werte zu übermitteln. -Symbols werden mit dem Doppelpunkt gekennzeichnet. -``` +# Nutze verständliche Variablennamen. +path_to_project_root = '/guter/Name/' +m = '/schlechter/Name/' + + +# Symbole sind unveränderliche, wiederverwendbare Konstanten, welche intern +# als Integer repräsentiert werden. Sie werden häufig anstelle von Strings +# verwendet, um semantisch sinnvoll Werte zu übermitteln. +# Symbols werden mit dem Doppelpunkt gekennzeichnet. + :pending.class #=> Symbol + status = :pending + status == :pending #=> true + status == 'pending' #=> false + status == :approved #=> false -``` + +# Strings können in Symbole konvertiert werden und umgekehrt. +status.to_s #=> "pending" +"argon".to_sym #=> :argon + # Arrays -## Ein Array anlegen -``` +# Das ist ein Array. array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] -``` -## Array können verschiedene Typen beinhalten -``` +# Array können verschiedene Typen beinhalten [1, 'hello', false] #=> [1, "hello", false] -``` -## Wie bei arithmetischen Ausdrücken auch wird beim Zugriff auf -## [0] eigentlich die Methode [] des Array Objekts aufgerufen. -``` -array.[] 0 #=> 1 -array.[] 12 #=> nil -``` +## Arrays könnenindiziert werden. -## Arrays können von vorne indiziert werden -``` +# Von vorne... array[0] #=> 1 +array.first #=> 1 array[12] #=> nil -``` -## Arrays können von hinten indiziert werden -``` +# ...oder von hinten... array[-1] #=> 5 -``` +array.last #=> 5 -## Arrays können mit Start Index und Länge indiziert werden -``` +# ...oder mit einem Startindex und einer Länge... array[2, 3] #=> [3, 4, 5] -``` -## Arrays können mit einer Range indiziert werden -``` +# ...oder mit einem Range... array[1..3] #=> [2, 3, 4] -``` -## Einen Wert hinzufügen -``` +# Du kanns ein Array umkehren. +# Gib ein neues Array mit umgkehrten Werten zurück +[1,2,3].reverse #=> [3,2,1] + +# Kehre ein Array an Ort und Stelle um, um die Variable mit den +# umgekehrten Werten zu aktualisieren. +a = [1,2,3] +a.reverse! #=> a==[3,2,1] wegen des Aufrufs von reverse mit Ausrufezeichens ('!') + +# Wie bei der Arithmetik, ist Zugriff mit [index] nur +# syntaktischer Zucker für den Aufruf der `[]` Methode auf dem Objekt. +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# Du kannst Werte zu einem Array hinzufügen... array << 6 #=> [1, 2, 3, 4, 5, 6] +# Oder so array.push(6) #=> [1, 2, 3, 4, 5, 6] -``` -## Testen, ob ein Element schon vorhanden ist -``` +# ...und testen ob ein Element schon vorhanden ist array.include?(1) #=> true -``` -# Hashes -Hashes sind das Hauptfeature um Key/Values zu speichern +# Hashes sind Rubys Hauptdatenstruktur for Schlüssel/Wert Paare. +# Hashes werden durch geschweifte Klammern gekennzeichnet. +hash = { 'Farbe' => 'grün', 'Nummer' => 5 } -## Ein Hash anlegen -``` -hash = { 'color' => 'green', 'number' => 5 } -hash.keys #=> ['color', 'number'] -``` +hash.keys #=> ['farbe', 'nummer'] -## Wert per key herausfinden -``` -hash['color'] #=> 'green' -hash['number'] #=> 5 -hash['nothing here'] #=> nil -// Fragen an einen Hash nach einem Schlüssel, der nicht existiert, ruft nil hervor: -``` +# Hashes can be quickly looked up by key. +hash['Farbe'] #=> "grün" +hash['Nummer'] #=> 5 -## Symbols können auch keys sein -``` -new_hash = { defcon: 3, action: true } -new_hash.keys #=> [:defcon, :action] -``` +# Abfragen eines nicht vorhandenen Schlüssels, gibt nil zurück. +hash['nicht vorhanden'] #=> nil -## Testen ob ein Key oder ein Value existiert -``` -new_hash.has_key?(:defcon) #=> true -new_hash.has_value?(3) #=> true -``` +# Wenn du Symbole als Schlüssel in einem Hash verwendest, kannst du +# eine alternative Syntax verwenden. +hash = { :defcon => 3, :action => true } +hash.keys #=> [:defcon, :action] -### Tipp: Arrays und Hashes sind Enumerable -### Und haben gemeinsame, hilfreiche Methoden wie: -### each, map, count, and more +hash = { defcon: 3, action: true } +hash.keys #=> [:defcon, :action] + +# Testen ob ein Schlüssel oder Wert im Hash existiert +hash.key?(:defcon) #=> true +hash.value?(3) #=> true + +# Tipp: Arrays und Hashes sind Enumerables! +# Sie haben viele nützliche Methoden gemein, wie each, map, count, und andere. # Kontrolstrukturen -## if -``` + +# Bedingungen if true - 'if statement' + 'wenn Bedingung' elsif false - 'else if, optional' + 'sonst wenn, optional' else - 'else, also optional' + 'sonst, auch optional' end -``` -## for - Allerdings werden for Schleifen nicht oft vewendet. -``` -for counter in 1..5 - puts "iteration #{counter}" -end -``` -## Stattdessen: "each" Methode und einen Bloch übergeben -Ein Block ist ein Codeteil, den man einer Methode übergeben kann -Ähnelt stark lambdas, anonymen Funktionen oder Closures in anderen -Programmiersprachen. -``` +# Wenn eine Kontrollstruktur keinen Code-Block, sondern einen einzigen +# Ausdruck ausführt, dann kannst du die nachgestellte if-Notation verwenden +warnings = ['Nachname fehlt', 'Adresse zu kurz'] +puts("Vorhandene Warnungen:\n" + warnings.join("\n")) if !warnings.empty? + +# Formuliere die Bedingung um, wenn sich `unless` besser liest als `if` +puts("Vorhandene Warnungen:\n" + warnings.join("\n")) unless warnings.empty? + +# Schleifen +# Traditionell ist das Benutzen von `for` Schleifen in Ruby eher unüblich. +# Stattdessen werden diese mit Hilfe von Enumerables implementiert, was mit +# dem Aufrufen von `each` einhergeht. (1..5).each do |counter| - puts "iteration #{counter}" + puts "Iteration #{counter}" +end + +# Was in etwa das selbe ist wie Folgendes (selten in Ruby zu sehen). +for counter in 1..5 + puts "Iteration #{counter}" end -``` -Die each Methode einer Range führt den Block für jedes Element der Range aus. +# Das `do |variable| ... end` Konstrukt wird `block` genannt. +# Blocks sind vergleichbar mit Lambdas, anonymen Funktionen +# oder Closures in anderen Programmiersprachen. +# Sie können als Objekte übergeben, aufgerufen oder als Methoden +# zugewiesen werden. -Dem Block wird ein "counter" parameter übergeben. +# Die `each` Methode eines Ranges führt den Block einmal für jedes +# Element des Ranges aus. +# Dem Block wird eine counter Variable als Parameter übergeben. -### Den Block kann man auch in geschweiften Klammern schreiben -``` -(1..5).each { |counter| puts "iteration #{counter}" } -``` +# Du kannst einen Block auch mit geschweiften Klammern schreiben. +(1..5).each { |counter| puts "Iteration #{counter}" } -### Each kann auch über den Inhalt von Datenstrukturen iterieren -``` +# Each kann auch über den Inhalt von Datenstrukturen iterieren. array.each do |element| - puts "#{element} is part of the array" + puts "#{element} is Teil des Arrays" end + hash.each do |key, value| - puts "#{key} is #{value}" + puts "#{key} ist #{value}" +end + +# Um auf den Laufindex zuzugreifen kannst du `each_with_index` verwenden +# und eine index Variable definieren. +array.each_with_index do |element, index| + puts "#{element} ist Nummer #{index} im Array" end counter = 1 while counter <= 5 do - puts "iteration #{counter}" + puts "Iteration #{counter}" counter += 1 end -``` +#=> Iteration 1 +#=> Iteration 2 +#=> Iteration 3 +#=> Iteration 4 +#=> Iteration 5 + +# Es gibt einige andere hilfreiche Schleifenfunktionen in Ruby. +# Wie etwa 'map', 'reduce', 'inject' und viele andere mehr. +# Map zum Beispiel iteriert über das Array, führt für jedes Element +# die Anweisungen aus, +# die im Block definiert sind und gibt ein völlig neues Array zurück. +array = [1,2,3,4,5] +doubled = array.map do |element| + element * 2 +end +puts doubled +#=> [2,4,6,8,10] +puts array +#=> [1,2,3,4,5] -## case -``` +# Case Konstruct grade = 'B' case grade when 'A' - puts 'Way to go kiddo' + puts 'So wird’s gemacht' when 'B' - puts 'Better luck next time' + puts 'Viel Glück beim nächsten Mal' when 'C' - puts 'You can do better' + puts 'Das kannst du besser' when 'D' - puts 'Scraping through' + puts 'Gerade so durch' when 'F' - puts 'You failed!' + puts 'Durchgefallen!' else - puts 'Alternative grading system, eh?' + puts 'Anderes Bewertungssystem, was?' end -=> "Better luck next time" -``` +#=> "Viel Glück beim nächsten Mal" -### Case können auch ranges -``` +# Case kann auch Ranges benutzen grade = 82 case grade when 90..100 - puts 'Hooray!' + puts 'Hurra!' when 80...90 - puts 'OK job' + puts 'OK gemacht' else - puts 'You failed!' + puts 'Durchgefallen!' end -=> "OK job" -``` +#=> "OK gemacht" -# Exception handling: -``` +# Fehlerbehandlung begin - # code here that might raise an exception - raise NoMemoryError, 'You ran out of memory.' + # Code der einen Fehler wirft... + raise NoMemoryError, 'Dein Speicher ist voll.' rescue NoMemoryError => exception_variable - puts 'NoMemoryError was raised', exception_variable + puts 'NoMemoryError ist aufgetreten', exception_variable rescue RuntimeError => other_exception_variable - puts 'RuntimeError was raised now' + puts 'RuntimeError ist aufgetreten' else - puts 'This runs if no exceptions were thrown at all' + puts 'Das wird ausgeführt, wenn keine Fehler geworfen wurden' ensure - puts 'This code always runs no matter what' + puts 'Dieser Code wird immer ausgeführt, egal was vorher passiert' end -``` -# Funktionen -``` + +# Methoden + def double(x) x * 2 end -``` -## Funktionen (und Blocks) -## geben implizit den Wert des letzten Statements zurück -``` + +# Methoden (und Blocks) geben implizit den Wert des letzten Anweisung zurück. double(2) #=> 4 -``` -### Klammern sind optional wenn das Ergebnis nicht mehrdeutig ist -``` +# Klammern sind optional wenn die Anweisung dadurch nicht mehrdeutig wird. double 3 #=> 6 + double double 3 #=> 12 + def sum(x, y) x + y end -``` -### Methoden Parameter werden per Komma getrennt -``` +# Die Argumente einer Methode werden durch ein Komma getrennt. sum 3, 4 #=> 7 + sum sum(3, 4), 5 #=> 12 -``` -## yield -### Alle Methoden haben einen impliziten, optionalen block Parameter -### Dieser wird mit dem Schlüsselword "yield" aufgerufen -``` +# yield +# Alle Methoden haben implizit einen optionalen block Parameter. +# Dieser kann durch das Schlüsselwort 'yield' ausgeführt werden. def surround puts '{' yield puts '}' end -surround { puts 'hello world' } -``` -## Einen Block kann man auch einer Methoden übergeben -### "&" kennzeichnet die Referenz zum übergebenen Block -``` +surround { puts 'hallo Welt' } + +#=> { +#=> hallo Welt +#=> } + +# Blocks können in ein 'Proc' Objekt umgewandelt werden. +# Dieses ist eine Art Container um den Block und erlaubt ihn an eine +# andere Methode zu übergeben, ihn in einen anderen Gültigkeitsbereicht +# einzubinden oder ihn andersweitig zu verändern. +# Am häufigsten findet man dies bei Parameterlisten von Methoden, in Form +# eines letzten '&block' Parameters, der den Block – wenn es einen gibt – +# entgegen nimmt und ihn in ein 'Proc' umwandelt. Die Benennung '&block' ist +# hier nur eine Konvention; es würde genauso mit '&pineapple' funktionieren. def guests(&block) - block.call 'some_argument' + block.class #=> Proc + block.call(4) end -``` -### Eine Liste von Parametern kann man auch übergeben, -### Diese wird in ein Array konvertiert -### "*" kennzeichnet dies. -``` +# Die 'call' Methode eines Proc ist ganz ähnlich zum Aufruf von 'yield', wenn +# ein Block vorhanden ist. Die Argumente, die 'call' übergeben werden, werden +# als Argumente and den Block weitergereicht. + +guests { |n| "Du hast #{n} Gäste." } +# => "Du hast 4 Gäste." + +# Du kannst eine Liste von Argumenten übergeben, die dann in ein Array +# umgewandelt werden. Dafür gibt es den splat-Operator (`*`). def guests(*array) array.each { |guest| puts guest } end -``` + +# Destrukturierung + +# Ruby destrukturiert Arrays automatisch beim Zuweisen mehrerer Variablen. +a, b, c = [1, 2, 3] +a #=> 1 +b #=> 2 +c #=> 3 + +# In manchen Fällen will man den splat-Operator (`*`) verwenden um ein Array in +# eine Liste zu destrukturieren. +ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"] + +def best(first, second, third) + puts "Gewinner sind #{first}, #{second} und #{third}." +end + +best *ranked_competitors.first(3) #=> Gewinner sind John, Sally and Dingus. + +# Der splat-Operator kann auch in Parametern verwendet werden. +def best(first, second, third, *others) + puts "Gewinner sind #{first}, #{second} und #{third}." + puts "Es gab #{others.count} andere Teilnehmer." +end + +best *ranked_competitors +#=> Gewinner sind John, Sally und Dingus. +#=> Es gab 2 andere Teilnehmer. + +# Per Konvention enden alle Methoden, die einen Wahrheitswert zurück geben, mit einem +# Fragezeichen. +5.even? #=> false +5.odd? #=> true + +# Wenn ein Methodenname mit einem Ausrufezeichen endet, dann tut diese Methode +# per Konvention etwas Destruktives, wie z.B. das aufrufende Objekt zu +# verändern. +# Viele Mehtoden haben eine !-Version um eine direkte Änderung zu machen und +# eine Nicht-!-Version, die ein neues Objekt mit den Veränderungen zurück gibt. +company_name = "Dunder Mifflin" +company_name.upcase #=> "DUNDER MIFFLIN" +company_name #=> "Dunder Mifflin" +# Diesmal verändern wir company_name direkt. +company_name.upcase! #=> "DUNDER MIFFLIN" +company_name #=> "DUNDER MIFFLIN" + # Klassen -## Werden mit dem class Schlüsselwort definiert -``` + +# Du kannst eine Klasse mit dem Schlüsselwort 'class' definieren. class Human -``` -### Konstruktor bzw. Initializer -``` + # Eine Klassenvariable. Sie wird von allen Instanzen einer Klasse geteilt. + @@species = 'H. sapiens' + + # Konstruktor bzw. Initializer def initialize(name, age = 0) - # Assign the argument to the "name" instance variable for the instance + # Weise das Argument der Instanzvariable 'name' zu. @name = name - # If no age given, we will fall back to the default in the arguments list. + # Wenn kein 'age' angegeben wurde wird der Standartwert aus der Argumentenlist verwendet. @age = age end -``` -### setter Methode -``` + # Setter Methode def name=(name) @name = name end -``` -### getter Methode -``` + + # Getter Methode def name @name end -``` -#### getter können mit der attr_accessor Methode vereinfacht definiert werden -``` + # Getter & Setter können auch kürzer mit der attr_accessor Methode erstellt werden. attr_accessor :name - # Getter/setter methods can also be created individually like this + + # Getter & Setter Methoden können auch einzeln erstellt werden. attr_reader :name attr_writer :name - # A class method uses self to distinguish from instance methods. - # It can only be called on the class, not an instance. + + # Eine Klassenmethode unterscheidet sich durch ein 'self' von einer + # Instanzmethode. + # Sie kann nur auf der Klasse und nicht auf einer Instanz der Klasse + # aufgerufen werden. def self.say(msg) puts msg end + def species @@species end end -``` -## Eine Klasse instanziieren -``` +# Instanziieren einer Klasse jim = Human.new('Jim Halpert') dwight = Human.new('Dwight K. Schrute') -``` -## Methodenaufrufe -``` +# Du kannst die Methoden des erstellten Objekts aufrufen. jim.species #=> "H. sapiens" jim.name #=> "Jim Halpert" jim.name = "Jim Halpert II" #=> "Jim Halpert II" jim.name #=> "Jim Halpert II" dwight.species #=> "H. sapiens" dwight.name #=> "Dwight K. Schrute" -``` -## Eine Klassenmethode aufrufen -``` +# Aufrufen einer Klassenmethode Human.say('Hi') #=> "Hi" -``` -## Variable Gültigkeit -### Variablen die mit "$" starten, gelten global -``` -$var = "I'm a global var" +# Der Gültigkeitsbereich einer Variablen wird durch ihren Namen definiert. +# Variablen, die mit $ beginnen sind global gültig. +$var = "Ich bin eine globale Variable" defined? $var #=> "global-variable" -``` -### Variablen die mit "@" starten, gelten für die Instanz -``` -@var = "I'm an instance var" +# Variablen, die mit @ beginnen, sind innerhalb einer Instanz gültig. +@var = "Ich bin eine Instanzvariable" defined? @var #=> "instance-variable" -``` -### Variablen die mit "@@" starten, gelten für die Klasse -``` -@@var = "I'm a class var" +# Variablen, die mit @@ beginnen, sind für die Klasse gültig. +@@var = "Ich bin eine Klassenvariable" defined? @@var #=> "class variable" -``` -### Variablen die mit einem Großbuchstaben anfangen, sind Konstanten -``` -Var = "I'm a constant" +# Variablen, die mit einem Großbuchstaben beginnen, sind Konstanten +Var = "Ich bin eine Konstante" defined? Var #=> "constant" -``` -## Class ist auch ein Objekt -### Hat also auch Instanzvariablen -### Eine Klassenvariable wird innerhalb der Klasse und Ableitungen geteilt. +# Class ist in Ruby auch ein Objekt. Deshalb kann eine Klasse Instanzvariablen +# haben. Eine Klassenvariable wird zwischen der Klasse und all ihren +# Ableitungen geteilt. -### Basis Klasse -``` +# Basis Klasse class Human @@foo = 0 + def self.foo @@foo end + def self.foo=(value) @@foo = value end end -``` -### Abgeleitete Klasse -``` +# Abgeleitete Klasse class Worker < Human end -Human.foo # 0 -Worker.foo # 0 -Human.foo = 2 # 2 -Worker.foo # 2 -``` -### Eine Klasseninstanzvariable wird nicht geteilt -``` +Human.foo #=> 0 +Worker.foo #=> 0 + +Human.foo = 2 +Worker.foo #=> 2 + +# Ableitungen einer Klasse haben keinen Zugriff auf eine Eine Klassen-Instanzvariable. class Human @bar = 0 + def self.bar @bar end + def self.bar=(value) @bar = value end end -``` -``` + class Doctor < Human end -``` -``` -Human.bar # 0 -Doctor.bar # nil -``` -``` + +Human.bar #=> 0 +Doctor.bar #=> nil + module ModuleExample def foo 'foo' end end -``` -### Module einbinden, heisst ihre Methoden an die Instanzen der Klasse zu binden -### Module erweitern, heisst ihre Mothden an die Klasse selbst zu binden -``` + +# Ein Einbinden (include) eines Moduls bindet seine Methoden an die Instanzen +# der Klasse. +# Ein Erweitern (extend) eines Moduls bindet seine Methoden an die Klasse +# selbst. class Person include ModuleExample end -``` -``` + class Book extend ModuleExample end -``` -``` -Person.foo # => NoMethodError: undefined method `foo' for Person:Class -Person.new.foo # => 'foo' -Book.foo # => 'foo' -Book.new.foo # => NoMethodError: undefined method `foo' -``` -### Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird -``` - module ConcernExample - def self.included(base) - base.extend(ClassMethods) - base.send(:include, InstanceMethods) - end - module ClassMethods - def bar - 'bar' - end - end - module InstanceMethods - def qux - 'qux' - end + +Person.foo #=> NoMethodError: undefined method `foo' for Person:Class +Person.new.foo #=> "foo" +Book.foo #=> "foo" +Book.new.foo #=> NoMethodError: undefined method `foo' + + +# Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird. +module ConcernExample + def self.included(base) + base.extend(ClassMethods) + base.send(:include, InstanceMethods) + end + + module ClassMethods + def bar + 'bar' end end - class Something - include ConcernExample + + module InstanceMethods + def qux + 'qux' + end end -``` -``` -Something.bar # => 'bar' -Something.qux # => NoMethodError: undefined method `qux' -Something.new.bar # => NoMethodError: undefined method `bar' -Something.new.qux # => 'qux' +end + +class Something + include ConcernExample +end + +Something.bar #=> "bar" +Something.qux #=> NoMethodError: undefined method `qux' +Something.new.bar #=> NoMethodError: undefined method `bar' +Something.new.qux #=> "qux" ``` -## Weiterführende Hinweise +## Weitere Links -//EN +_(z.T. auf Englisch)_ -- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges. -- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/) +- [Offizielle Ruby Website](https://www.ruby-lang.org/de/) +- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Eine Variante dieses Dokuments mit in-Browser Challenges. +- [RubyMonk](https://rubymonk.com/) - Lerne Ruby mit einer Reihe interaktiver Tutorials. +- [Offizielle Dokumentation](http://ruby-doc.org/core) - [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/) -- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online. -- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide. +- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Eine ältere [freie Ausgabe](http://ruby-doc.com/docs/ProgrammingRuby/) ist online verfügbar. +- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Ein von der Community erstellter Ruby coding style guide. +- [Try Ruby](http://tryruby.org) - Lerne die Grundlagen der Ruby Programmiersprache, interaktiv im Browser. -- cgit v1.2.3 From 0ecb8264293d852f2ef586279885848b621668d1 Mon Sep 17 00:00:00 2001 From: sumanstats Date: Wed, 10 Jun 2020 16:33:01 +0545 Subject: Perl6 to Raku and many more + As the Perl 6 is renamed to raku, it is good to reflect that https://github.com/Raku/problem-solving/blob/master/solutions/language/Path-to-Raku.md + perl6.org is now raku.org + change references of perl 6 to raku + rename file perl6-pod.html.markdown to raku-pod.html.markdown + Perl refers to Perl 5, there is no ambiguity after rename of Perl6 to Raku, use Perl only to refer to Perl 5 + fix links inside raku.html.markdown --- de-de/perl-de.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'de-de') diff --git a/de-de/perl-de.html.markdown b/de-de/perl-de.html.markdown index fd8fb3c4..13c00b01 100644 --- a/de-de/perl-de.html.markdown +++ b/de-de/perl-de.html.markdown @@ -8,9 +8,9 @@ translators: lang: de-de --- -Perl 5 ist eine sehr mächtige, funktionsreiche Programmiersprache mit über 25 Jahren Entwicklungsgeschichte. +Perl ist eine sehr mächtige, funktionsreiche Programmiersprache mit über 25 Jahren Entwicklungsgeschichte. -Perl 5 läuft auf über 100 Platformen von portablen Geräten bis hin zu Mainframes. Perl 5 ist geeignet für Rapid-Prototyping und auch groß angelegte Entwicklungs-Projekte. +Perl läuft auf über 100 Platformen von portablen Geräten bis hin zu Mainframes. Perl ist geeignet für Rapid-Prototyping und auch groß angelegte Entwicklungs-Projekte. ```perl # Einzeilige Kommentare beginnen mit dem # Symbol. -- cgit v1.2.3 From cd8bb2c776e2e93f67e8be7f8fe16664b441f212 Mon Sep 17 00:00:00 2001 From: kevinnls <57634663+kevinnls@users.noreply.github.com> Date: Thu, 20 Aug 2020 12:53:24 +0530 Subject: fix syntax on yaml frontmatter --- de-de/vim-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown index 2800b949..8abf9a14 100644 --- a/de-de/vim-de.html.markdown +++ b/de-de/vim-de.html.markdown @@ -1,7 +1,7 @@ --- category: tool tool: vim -lang = de-de +lang: de-de contributors: - ["RadhikaG", "https://github.com/RadhikaG"] translators: -- cgit v1.2.3
    Erster Tabellenkopf
    Erster Tabellenkopf Zweiter Tabllenkopf
    Erste Zeile, erste Spalte Erste Zeile, erste Spalte Erste Zeile, zweite Spalte