summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--bash.html.markdown84
-rw-r--r--csharp.html.markdown93
-rw-r--r--de-de/git-de.html.markdown374
-rw-r--r--de-de/python-de.html.markdown27
-rw-r--r--groovy.html.markdown379
-rw-r--r--hu-hu/go.html.markdown305
-rw-r--r--tr-tr/c-tr.html.markdown484
-rw-r--r--whip.html.markdown18
8 files changed, 1730 insertions, 34 deletions
diff --git a/bash.html.markdown b/bash.html.markdown
new file mode 100644
index 00000000..8cf7be18
--- /dev/null
+++ b/bash.html.markdown
@@ -0,0 +1,84 @@
+---
+
+language: bash
+contributors:
+ - ["Max Yankov", "https://github.com/golergka" - "Darren Lin", "https://github.com/CogBear"]
+filename: LearnBash.sh
+
+---
+
+Bash is a name of the unix shell, which was also distributed as the shell for the GNU operating system and as default shell on Linux and Mac OS X.
+Nearly all examples below can be a part of a shell script or executed directly in the shell.
+
+[Read more here.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/sh
+# First line of the script is shebang which tells the system how to execute the script: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# As you already figured, comments start with #. Shebang is also a comment.
+
+# Simple hello world example:
+echo Hello, world!
+
+# Each command starts on a new line, or after semicolon:
+echo 'This is the first line'; echo 'This is the second line'
+
+# Declaring a variable looks like this:
+VARIABLE="Some string"
+
+# But not like this:
+VARIABLE = "Some string" # Bash will decide that VARIABLE is a command he must execute and give an error because it couldn't be found.
+
+# Using the variable:
+echo $VARIABLE
+echo "$VARIABLE"
+# When you use the variable itself — assign it, export it, or else — you write it's name without $. If you want to use variable's value, you should use $.
+
+# Reading a value from input:
+echo "What's your name?"
+read NAME # Note that we didn't need to declare new variable
+echo Hello, $NAME!
+
+# We have the usual if structure:
+if true
+then
+ echo "This is expected"
+else
+ echo "And this is not"
+fi
+
+# Expressions are denoted with the following format:
+echo $(( 10 + 5 ))
+
+# Unlike other programming languages, bash is a shell — so it works in a context of current directory.
+# You can list files and directories in the current directories with ls command:
+ls
+
+# These commands have options that control their execution:
+ls -l # Lists every file and directory on a separate line
+
+# Results of the previous command can be passed to the next command as input.
+# grep command filters the input with provided patterns. That's how we can list txt files in the current directory:
+ls -l | grep "\.txt"
+
+# Commands can be substitued within other commands using $( ):
+# The following command displays the number of files and directories in the current directory.
+echo "There are $(ls | wc -l) items here."
+
+#Bash uses a case statement that works similarily to switch in Java and C++:
+case "$VARIABLE"
+in
+ #List patterns for the conditions you want to meet
+ 0) echo "There is a zero."
+ 1) echo "There is a one."
+ *) echo "It is not null."
+esac
+
+#For loops iterate for as many arguments given:
+#The contents of var $VARIABLE is printed three times.
+for $VARIABLE in x y z
+do
+ echo "$VARIABLE"
+done
+
+```
diff --git a/csharp.html.markdown b/csharp.html.markdown
index 0cef8f05..55de415d 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -3,6 +3,7 @@
language: c#
contributors:
- ["Irfan Charania", "https://github.com/irfancharania"]
+ - ["Max Yankov", "https://github.com/golergka"]
filename: LearnCSharp.cs
---
@@ -402,7 +403,25 @@ namespace Learning
private int _speed; // Private: Only accessible from within the class
protected int gear; // Protected: Accessible from the class and subclasses
internal int wheels; // Internal: Accessible from within the assembly
- string name; // default: Only accessible from within this class
+ string name; // Everything is private by default: Only accessible from within this class
+
+ // Enum is a value type that consists of a set of named constants
+ public enum Brand
+ {
+ AIST,
+ BMC,
+ Electra,
+ Gitane
+ }
+ // We defined this type inside a Bicycle class, so it is a nested type
+ // Code outside of this class should reference this type as Bicycle.Brand
+
+ public Brand brand; // After declaing an enum type, we can declare the field of this type
+
+ // Static members belong to the type itself rather then specific object.
+ static public int bicyclesCreated = 0;
+ // You can access them without a reference to any object:
+ // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
// readonly values are set at run time
// they can only be assigned upon declaration or in a constructor
@@ -410,27 +429,30 @@ namespace Learning
// Constructors are a way of creating classes
// This is a default constructor
- public Bicycle()
+ private Bicycle()
{
gear = 1;
cadence = 50;
_speed = 5;
name = "Bontrager";
+ brand = Brand.AIST;
+ bicyclesCreated++;
}
// This is a specified constructor (it contains arguments)
public Bicycle(int startCadence, int startSpeed, int startGear,
- string name, bool hasCardsInSpokes)
+ string name, bool hasCardsInSpokes, Brand brand)
{
this.gear = startGear; // "this" keyword denotes the current object
this.cadence = startCadence;
this._speed = startSpeed;
this.name = name; // it can be useful when there's a name conflict
this.hasCardsInSpokes = hasCardsInSpokes;
+ this.brand = brand;
}
// Constructors can be chained
- public Bicycle(int startCadence, int startSpeed) :
+ public Bicycle(int startCadence, int startSpeed, Brand brand) :
this(startCadence, startSpeed, 0, "big wheels", true)
{
}
@@ -443,29 +465,30 @@ namespace Learning
// Method declaration syntax:
// <scope> <return type> <method name>(<args>)
- public int getCadence()
+ public int GetCadence()
{
return cadence;
}
// void methods require no return statement
- public void setCadence(int newValue)
+ public void SetCadence(int newValue)
{
cadence = newValue;
}
// virtual keyword indicates this method can be overridden
- public virtual void setGear(int newValue)
+ public virtual void SetGear(int newValue)
{
gear = newValue;
}
- public void speedUp(int increment)
+ // Method parameters can have defaut values. In this case, methods can be called with these parameters omitted
+ public void SpeedUp(int increment = 1)
{
_speed += increment;
}
- public void slowDown(int decrement)
+ public void SlowDown(int decrement = 1)
{
_speed -= decrement;
}
@@ -500,6 +523,14 @@ namespace Learning
"\n------------------------------\n"
;
}
+
+ // Methods can also be static. It can be useful for helper methods
+ public static bool DidWeCreateEnoughBycles()
+ {
+ // Within a static method, we only can reference static class memebers
+ return bicyclesCreated > 9000;
+ } // If your class only needs static members, consider marking the class itself as static.
+
} // end class Bicycle
// PennyFarthing is a subclass of Bicycle
@@ -514,10 +545,47 @@ namespace Learning
{
}
- public override void setGear(int gear)
+ public override void SetGear(int gear)
{
gear = 0;
}
+
+ public override string ToString()
+ {
+ string result = "PennyFarthing bicycle ";
+ result += base.ToString(); // Calling the base version of the method
+ return reuslt;
+ }
+ }
+
+ // Interfaces only contain signatures of the members, without the implementation.
+ interface IJumpable
+ {
+ void Jump(int meters); // all interface members are implicitly public
+ }
+
+ interface IBreakable
+ {
+ bool Broken { get; } // interfaces can contain properties as well as methods, fields & events
+ }
+
+ // Class can inherit only one other class, but can implement any amount of interfaces
+ class MountainBike : Bicycle, IJumpable, IBreakable
+ {
+ int damage = 0;
+
+ public void Jump(int meters)
+ {
+ damage += meters;
+ }
+
+ public void Broken
+ {
+ get
+ {
+ return damage > 100;
+ }
+ }
}
} // End Namespace
@@ -525,10 +593,11 @@ namespace Learning
## Topics Not Covered
- * Enums, Flags
+ * Flags
* Attributes
* Generics (T), Delegates, Func, Actions, lambda expressions
- * Exceptions, Interfaces, Abstraction
+ * Static properties
+ * Exceptions, Abstraction
* LINQ
* ASP.NET (Web Forms/MVC/WebMatrix)
* Winforms
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
new file mode 100644
index 00000000..471c7641
--- /dev/null
+++ b/de-de/git-de.html.markdown
@@ -0,0 +1,374 @@
+---
+category: tool
+tool: git
+contributors:
+ - ["Jake Prather", "http:#github.com/JakeHP"]
+ - ["kultprok", "http://www.kulturproktologie.de"]
+filename: LearnGit.txt
+lang: de-de
+---
+
+Git ist eine verteilte Versions- und Quellcodeverwaltung.
+
+Es nimmt Schnappschüsse der Projekte, um mit diesen Schnappschüssen verschiedene Versionen unterscheiden und den Quellcode verwalten zu können.
+
+Anmerkung des Übersetzers: Einige englische Begriffe wie *Repository*, *Commit* oder *Head* sind idiomatische Bestandteile im Umgang mit Git. Sie wurden nicht übersetzt.
+
+## Konzepte der Versionsverwaltung
+
+### Was ist Versionsverwaltung?
+
+Eine Versionskontrolle erfasst die Änderungen einer Datei oder eines Verzeichnisses im Verlauf der Zeit.
+
+### Zentrale im Vergleich mit verteilter Versionverwaltung
+
+* Zentrale Versionskontrolle konzentriert sich auf das Synchronisieren, Verfolgen und Sichern von Dateien.
+* Verteilte Versionskontrolle konzentriert sich auf das Teilen der Änderungen. Jede Änderung hat eine eindeutige ID.
+* Verteilte Systeme haben keine vorbestimmte Struktur. Ein SVN-ähnliches, zentrales System wäre mit Git ebenso umsetzbar.
+
+[Weiterführende Informationen](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Warum Git?
+
+* Ist offline einsetzbar.
+* Einfache Kollaboration!
+* Branching ist einfach!
+* Merging ist einfach!
+* Git ist schnell.
+* Git ist flexibel.
+
+## Die Architektur von Git
+
+
+### Repository (Repo)
+
+Ein Satz von Dateien, Verzeichnisen, Historieneinträgen, Commits und Heads. Stell es dir wie eine Quellcode-Datenstruktur vor, unter anderem mit der Eigenschaft, dass alle *Elemente* dir Zugriff auf die Revisionshistorie geben.
+
+Ein Repository besteht in Git aus dem .git-Verzeichnis und dem Arbeitsverzeichnis.
+
+### .git-Verzeichnis (Teil des Repositorys)
+
+Das .git-Verzeichnis enth? alle Einstellung, Logs, Branches, den HEAD und mehr.
+[Ausführliche Übersicht](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Arbeitsverzeichnis (Teil des Repositorys)
+
+Dies sind die Verzeichnisse und Dateien in deinem Repository.
+
+### Index (Teil des .git-Verzeichnisses)
+
+Der Index ist die die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
+
+### Commit
+
+Ein Commit ist ein Schnappschuss von Uderungen in deinem Arbeitsverzeichnis. Wenn du zum Beispiel 5 Dateien hinzugefügt und 2 andere entfernt hast, werden diese Änderungen im Commit (Schnappschuss) enthalten sein. Dieser Commit kann dann in andere Repositorys gepusht werden. Oder nicht!
+
+### Branch
+
+Ein Branch, ein Ast oder Zweig, ist im Kern ein Pointer auf den letzten Commit, den du gemacht hast. Während des Commits wird der Pointer automatisch auf Stand gebracht und zeigt dann auf den neuen letzten Commit.
+
+### HEAD und head (Teil des .git-Verzeichnisses)
+
+HEAD ist ein Pointer auf den aktuellen Branch. Ein Repository hat nur einen *aktiven* HEAD. Ein head ist ein Pointer, der auf ein beliebige Zahl von heads zeigt.
+
+### Konzeptionelle Hintergründe
+
+* [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git For Designers](http://hoth.entp.com/output/git_for_designers.html)
+
+
+## Befehle
+
+
+### init
+
+Erstelle ein leeres Git-Repository. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
+
+```bash
+$ git init
+```
+
+### config
+
+Hiermit werden Einstellungen vorgenommen. Dies kann das Repository, das System selbst oder globale Einstellungen betreffen.
+
+```bash
+# Grundlegende Config-Variablen ausgeben und setzen
+$ git config --global user.email
+$ git config --global user.name
+
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[Mehr über git config](http://git-scm.com/docs/git-config)
+
+### help
+
+Schnellzugriff auf extrem detaillierte Anleitungen zu allen Befehlen. Oder als Erinnerung zu semantischen Eigenheiten.
+
+```bash
+# Übersicht gängiger Befehle
+$ git help
+
+# Übersicht aller verfügbaren Befehle
+$ git help -a
+
+# Befehlspezifische Hilfe - Bedienungsanleitung
+# git help <gesuchter_befehl>
+$ git help add
+$ git help commit
+$ git help init
+```
+
+### status
+
+Zeigt die Unterschiede zwischen Index (im Grunde dein Arbeitsverzeichnis/-repository) und dem aktuellen HEAD an.
+
+
+```bash
+# Zeigt den Branch, nicht-verfolgte Dateien, Uderungen und andere Unterschiede an
+$ git status
+
+# Anderes Wissenswertes über git status anzeigen
+$ git help status
+```
+
+### add
+
+Hinzufügen von Dateien zum Arbeitsverzeichnis/-repository. Wenn du neue Dateien nicht mit *git add* zum Arbeitsverzeichnis hinzufügst, werden sie nicht in den Commit aufgenommen!
+
+```bash
+# Fügt eine Datei deinem aktuellen Arbeitsverzeichnis hinzu
+$ git add HelloWorld.java
+
+# Fügt eine Datei aus einem verschachtelten Verzeichnis hinzu
+$ git add /path/to/file/HelloWorld.c
+
+# Reguläre Ausdrücke werden unterstützt!
+$ git add ./*.java
+```
+
+### branch
+
+Verwalte alle Branches. Du kannst sie mit diesem Befehl ansehen, bearbeiten, neue erschaffen oder löschen.
+
+```bash
+# Liste alle bestehenden Branches und Remotes auf
+$ git branch -a
+
+# Erstelle einen neuen Branch
+$ git branch myNewBranch
+
+# Lösche einen Branch
+$ git branch -d myBranch
+
+# Benenne einen Branch um
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# Ändere die Beschreibung eines Branchs
+$ git branch myBranchName --edit-description
+```
+
+### checkout
+
+Bringt alle Dateien im Arbeitsverzeichnis auf den Stand des Index oder des angegebenen Branches.
+
+```bash
+# Ein Repo auschecken - wenn nicht anders angegeben ist das der master
+$ git checkout
+# Einen bestimmten Branch auschecken
+$ git checkout branchName
+# Erstelle einen neuen Branch und wechsle zu ihm. Wie: "git branch <name>; git checkout <name>"
+$ git checkout -b newBranch
+```
+
+### clone
+
+Ein bestehendes Repository in ein neues Verzeichnis klonen oder kopieren. Es fügt außerdem für hedes geklonte Repo remote-tracking Branches hinzu. Du kannst auf diese Remote-Branches pushen.
+
+```bash
+# Klone learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+```
+
+### commit
+
+Speichert die aktuellen Inhalte des Index in einen neuen *Commit*. Dieser Commit enthält alle Änderungen und eine vom Benutzer erstellte Beschreibung der Änderungen.
+
+```bash
+# Commit mit Beschreibung erstellen.
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+```
+
+### diff
+
+Zeigt die Unterschiede zwischen Dateien von Arbeitsverzeichnisse, dem Index und Commits an.
+
+```bash
+# Unterschiede zwischen deinem Arbeitsverzeichnis und dem Index anzeigen
+$ git diff
+
+# Unterschiede zwischen dem Index und dem aktuellsten Commit anzeigen
+$ git diff --cached
+
+# Unterschiede zwischen deinem Arbeitsverzeichnis und dem aktuellsten Commit anzeigen
+$ git diff HEAD
+```
+
+### grep
+
+Schnell ein Repository durchsuchen.
+
+Optionale Einstellungen:
+
+```bash
+# Vielen Dank an Travis Jeffery für die Hinweise.
+# Zeilennummerierung in grep-Suchergebnissen
+$ git config --global grep.lineNumber true
+
+# Suchergebnisse lesbarer gestalten, auch Gruppierungen sind möglich
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Suche nach "variableName" in allen java-Dateien
+$ git grep 'variableName' -- '*.java'
+
+# Suche nach eine Zeile, die "arrayListName" und "add" oder "remove" enthält
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Google ist dein Freund; für mehr Beispiele:
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Zeige Commits für das Repository an.
+
+```bash
+# Zeige alle Commits
+$ git log
+
+# Zeige die Anzahl n an Commits
+$ git log -n 10
+
+# Zeige nur Merges an
+$ git log --merges
+```
+
+### merge
+
+*Merge*, also verschmelze, alle Änderungen von externen Commits in den aktuellen Branch.
+
+```bash
+# Merge den angegebenen Branch in den aktuellen.
+$ git merge branchName
+
+# Erstelle immer einen Merge-Commit.
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Eine Datei umbenennen oder verschieben.
+
+```bash
+# Umbenennen
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Verschieben
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Umbenennung oder Verschieben erzwingen
+# "existingFile" besteht schon im Verzeichnis, wird überschrieben mit "myFile"
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Führe einen Pull, zieht alle Daten, eines Repositorys und f?? einen Merge mit einem anderen Branch durch.
+
+```bash
+# Update deines lokalen Repos, indem ein Merge der neuen Uderungen
+# von den remote-liegenden "origin"- und "master"-Branches durchgef?? wird.
+# git pull <remote> <branch>
+# git pull => impliziter Verweis auf origin und master
+$ git pull origin master
+
+# F?? einen Merge von Uderungen eines remote-Branch und ein Rebase
+# des Branch-Commits im lokalen Repo durch. Wie: pull <remote> <branch>, git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Führe einen Push, ein Hochladen, und einen Merge von Änderungen eines remote-Branch mit einem Branch aus.
+
+```bash
+# Führe Push und Merge von Änderungen des lokalen Repo zu einem
+# remote-Branch namens "origin" und dem "master"-Branch aus.
+# git push <remote> <branch>
+# git push => impliziter Verweis auf => git push origin master
+$ git push origin master
+```
+
+### rebase (mit Vorsicht einsetzen)
+
+Nimm alle Änderungen, die in einem Branch durch Commits vorgenommen wurden, und übertrage sie auf einen anderen Branch. Achtung: Führe keinen Rebase von Commits durch, die auf ein öffentliches Repo gepusht wurden.
+
+```bash
+# Rebase "experimentBranch" in den "master"-Branch
+# git rebase <basisbranch> <themenbranch>
+$ git rebase master experimentBranch
+```
+
+[Weiterführende Informationen](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (mit Vorsicht einsetzen)
+
+Setze den aktuellen HEAD auf den angegebenen Zustand zurück. So können Merges, Pulls, Commits, Hinzufügungen und andere Änderungen rückgängig gemacht werden. Es ist ein hervorragender Befehl, aber auch sehr gefährlich, wenn du nicht weißt, was du tust.
+
+```bash
+# Setze die Staging-Area zurück, um dem letzten Commit zu entsprechen (das Verzeichnis bleibt unberührt)
+$ git reset
+
+# Setze die Staging-Area zurück, um dem letzten Commit zu entsprechen und überschreibe das Arbeitsverzeichnis
+$ git reset --hard
+
+# Bewegt die Spitze des Branches zu dem angegebenen Commit (das Verzeichnis bleibt unber??)
+# Alle Uderungen bleiben im Verzeichnis erhalten
+$ git reset 31f2bb1
+
+# Bewegt die Spitze des Branches zurück zu dem angegebenen Commit
+# und gleicht die Arbeitsverzeichnisse ab (löscht nicht vom Commit erfasste Änderungen und alle Commits,
+# die dem angegebenen Commit folgen).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Das Gegenteil von *git add*. *git rm* löscht Dateien vom Arbeitsverzeichnis.
+
+```bash
+# Entferne HelloWorld.c
+$ git rm HelloWorld.c
+
+# Entferne eine Datei aus einem verschachtelten Verzeichnis
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+## Weiterführende Informationen
+
+* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
+
+* [git-scm - Video Tutorials](http://git-scm.com/videos)
+
+* [git-scm - Documentation](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
+
+* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown
index 6803f98b..7462d5f6 100644
--- a/de-de/python-de.html.markdown
+++ b/de-de/python-de.html.markdown
@@ -28,17 +28,17 @@ Hinweis: Dieser Beitrag bezieht sich besonders auf Python 2.7, er sollte aber au
# Die Zahlen
3 #=> 3
-# Mathematik ist das, was man erwartet
+# Mathematik funktioniert so, wie man das erwartet
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
-# Division ist ein wenig kniffliger. Es ist ganzzahlige Division
-# und rundet automatisch ab.
+# 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 kennenlernen.
+# 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
@@ -57,7 +57,7 @@ not False #=> True
1 == 1 #=> True
2 == 1 #=> False
-# Ungleichheit is !=
+# Ungleichheit ist !=
1 != 1 #=> False
2 != 1 #=> True
@@ -84,7 +84,7 @@ not False #=> True
# Mit % können Strings formatiert werden, etwa so:
"%s können %s werden" % ("Strings", "interpoliert")
-# Ein neuerer Weg, um Strings zu formatieren, ist die format-Methode.
+# 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.
@@ -112,7 +112,7 @@ None is None #=> True
## 2. Variablen und Collections
####################################################
-# Ausgabe ist sehr einfach
+# Textausgabe ist sehr einfach
print "Ich bin Python. Schön, dich kennenzulernen!"
@@ -120,8 +120,9 @@ print "Ich bin Python. Schön, dich kennenzulernen!"
some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm
some_var #=> 5
-# Eine noch nicht deklarierte Variable anzusprechen, löst eine Exception aus.
-# Siehe Kontrollstruktur, um mehr über Ausnahmebehandlung zu lernen.
+# 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
@@ -139,7 +140,7 @@ 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]
-# Fügen wir es wieder hinzu
+# und dann wieder hinzufügen
li.append(3) # li ist jetzt wieder [1, 2, 4, 3].
# Greife auf Listen wie auf Arrays zu
@@ -147,7 +148,7 @@ li[0] #=> 1
# Das letzte Element ansehen
li[-1] #=> 3
-# Außerhalb der Liste ist es ein IndexError
+# Bei Zugriffen außerhal der Liste kommt es jedoch zu einem IndexError
li[4] # Raises an IndexError
# Wir können uns Ranges mit Slice-Syntax ansehen
@@ -249,7 +250,7 @@ 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 mit in prüfen
+# Auf Vorhandensein von Elementen mit in prüfen
2 in filled_set #=> True
10 in filled_set #=> False
@@ -417,7 +418,7 @@ class Human(object):
# Eine Instanz einer Klasse erstellen
i = Human(name="Ian")
-print i.say("hi") # gitbt "Ian: hi" aus
+print i.say("hi") # gibt "Ian: hi" aus
j = Human("Joel")
print j.say("hello") #gibt "Joel: hello" aus
diff --git a/groovy.html.markdown b/groovy.html.markdown
new file mode 100644
index 00000000..e4c2180b
--- /dev/null
+++ b/groovy.html.markdown
@@ -0,0 +1,379 @@
+---
+language: Groovy
+filename: learngroovy.groovy
+contributors:
+ - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
+filename: learngroovy.groovy
+---
+
+Groovy - A dynamic language for the Java platform [Read more here.](http://groovy.codehaus.org)
+
+```cpp
+
+/*
+ Set yourself up:
+
+ 1) Install GVM - http://gvmtool.net/
+ 2) Install Groovy: gvm install groovy
+ 3) Start the groovy console by typing: groovyConsole
+
+*/
+
+// Single line comments start with two forward slashes
+/*
+Multi line comments look like this.
+*/
+
+// Hello World
+println "Hello world!"
+
+/*
+ Variables:
+
+ You can assign values to variables for later use
+*/
+
+def x = 1
+println x
+
+x = new java.util.Date()
+println x
+
+x = -3.1499392
+println x
+
+x = false
+println x
+
+x = "Groovy!"
+println x
+
+/*
+ Collections and maps
+*/
+//Creating an empty list
+def technologies = []
+
+//Add an element to the list
+technologies << "Groovy"
+technologies.add("Grails")
+technologies.addAll(["Gradle","Griffon"])
+
+//Remove an element from the list
+technologies.remove("Griffon")
+
+//Iterate over elements of a list
+technologies.each { println "Technology: $it"}
+technologies.eachWithIndex { it, i -> println "$i: $it"}
+
+//Evaluate if a list contains element(s) (boolean)
+technologies.contains('Groovy')
+technologies.containsAll(['Groovy','Grails'])
+
+//Sort a list
+technologies.sort()
+
+//Replace all elements in the list
+Collections.replaceAll(technologies, 'Gradle', 'gradle')
+
+//Shuffle a list
+Collections.shuffle(technologies, new Random())
+
+//Clear a list
+technologies.clear()
+
+//Creating an empty map
+def devMap = [:]
+
+//Add values
+devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+devMap.put('lastName','Perez')
+
+//Iterate over elements of a map
+devMap.each { println "$it.key: $it.value" }
+devMap.eachWithIndex { it, i -> println "$i: $it"}
+
+//Evaluate if a map contains a key
+assert devMap.containsKey('name')
+
+//Evaluate if a map contains a value
+assert devMap.containsValue('Roberto')
+
+//Get the keys of a map
+println devMap.keySet()
+
+//Get the values of a map
+println devMap.values()
+
+/*
+ Groovy Beans
+
+ GroovyBeans are JavaBeans but using a much simpler syntax
+
+ When Groovy is compiled to bytecode, the following rules are used.
+
+ * If the name is declared with an access modifier (public, private or protected) then a field is generated.
+ * A name declared with no access modifier generates a private field with public getter and setter (i.e. a property).
+ * If a property is declared final the private field is created final and no setter is generated.
+ * You can declare a property and also declare your own getter or setter.
+ * You can declare a property and a field of the same name, the property will use that field then.
+ * If you want a private or protected property you have to provide your own getter and setter which must be declared private or protected.
+ * If you access a property from within the class the property is defined in at compile time with implicit or explicit this (for example this.foo, or simply foo), Groovy will access the field directly instead of going though the getter and setter.
+ * If you access a property that does not exist using the explicit or implicit foo, then Groovy will access the property through the meta class, which may fail at runtime.
+
+*/
+
+class Foo {
+ // read only property
+ final String name = "Roberto"
+
+ // read only property with public getter and protected setter
+ String language
+ protected void setLanguage(String language) { this.language = language }
+
+ // dynamically typed property
+ def lastName
+}
+
+/*
+ Logical Branching and Looping
+*/
+
+//Groovy supports the usual if - else syntax
+def x = 3
+
+if(x==1) {
+ println "One"
+} else if(x==2) {
+ println "Two"
+} else {
+ println "X greater than Two"
+}
+
+//Groovy also supports the ternary operator:
+def y = 10
+def x = (y > 1) ? "worked" : "failed"
+assert x == "worked"
+
+//For loop
+//Iterate over a range
+def x = 0
+for (i in 0 .. 30) {
+ x += i
+}
+
+//Iterate over a list
+x = 0
+for( i in [5,3,2,1] ) {
+ x += i
+}
+
+//Iterate over an array
+array = (0..20).toArray()
+x = 0
+for (i in array) {
+ x += i
+}
+
+//Iterate over a map
+def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+x = 0
+for ( e in map ) {
+ x += e.value
+}
+
+/*
+ Operators
+
+ Operator Overloading for a list of the common operators that Groovy supports: http://groovy.codehaus.org/Operator+Overloading
+
+ Helpful groovy operators
+*/
+//Spread operator: invoke an action on all items of an aggregate object.
+def technologies = ['Groovy','Grails','Gradle']
+technologies*.toUpperCase() //equivalent to: technologies.collect { it?.toUpperCase() }
+
+//Safe navigation operator: used to avoid a NullPointerException.
+def user = User.get(1)
+def username = user?.username
+
+
+/*
+ Closures
+ A Groovy Closure is like a "code block" or a method pointer. It is a piece of code that is defined and then executed at a later point.
+
+ More info at: http://groovy.codehaus.org/Closures+-+Formal+Definition
+*/
+//Example:
+def clos = { println "Hello World!" }
+
+println "Executing the Closure:"
+clos()
+
+//Passing parameters to a closure
+def sum = { a, b -> println a+b }
+sum(2,4)
+
+//Closures may refer to variables not listed in their parameter list.
+def x = 5
+def multiplyBy = { num -> num * x }
+println multiplyBy(10)
+
+//If you have a Closure that takes a single argument, you may omit the parameter definition of the Closure
+def clos = { print it }
+clos( "hi" )
+
+/*
+ Groovy can memorize closure results:
+ More info at:
+ http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
+ http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
+ http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
+*/
+def cl = {a, b ->
+ sleep(3000) // simulate some time consuming processing
+ a + b
+}
+
+mem = cl.memoize()
+
+def callClosure(a, b) {
+ def start = System.currentTimeMillis()
+ mem(a, b)
+ println "Inputs(a = $a, b = $b) - took ${System.currentTimeMillis() - start} msecs."
+}
+
+callClosure(1, 2)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(2, 3)
+callClosure(3, 4)
+callClosure(3, 4)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(3, 4)
+
+/*
+ Expando
+
+ The Expando class is a dynamic bean so we can add properties and we can add closures as methods to an instance of this class
+
+ Reference: http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+*/
+ def user = new Expando(name:"Roberto")
+ assert 'Roberto' == user.name
+
+ user.lastName = 'Pérez'
+ assert 'Pérez' == user.lastName
+
+ user.showInfo = { out ->
+ out << "Name: $name"
+ out << ", Last name: $lastName"
+ }
+
+ def sw = new StringWriter()
+ println user.showInfo(sw)
+
+
+/*
+ Metaprogramming (MOP)
+*/
+
+//Using ExpandoMetaClass to add behaviour
+String.metaClass.testAdd = {
+ println "we added this"
+}
+
+String x = "test"
+x?.testAdd()
+
+//Intercepting method calls
+class Test implements GroovyInterceptable {
+ def sum(Integer x, Integer y) { x + y }
+
+ def invokeMethod(String name, args) {
+ System.out.println "Invoke method $name with args: $args"
+ }
+}
+
+def test = new Test()
+test?.sum(2,3)
+test?.multiply(2,3)
+
+//Groovy supports propertyMissing for dealing with property resolution attempts.
+class Foo {
+ def propertyMissing(String name) { name }
+}
+def f = new Foo()
+
+assertEquals "boo", f.boo
+
+/*
+ TypeChecked and CompileStatic
+ Groovy, by nature, is and will always be a dynamic language but it supports typechecked and compilestatic
+
+ More info: http://www.infoq.com/articles/new-groovy-20
+*/
+//TypeChecked
+import groovy.transform.TypeChecked
+
+void testMethod() {}
+
+@TypeChecked
+void test() {
+ testMeethod()
+
+ def name = "Roberto"
+
+ println naameee
+
+}
+
+//Another example:
+import groovy.transform.TypeChecked
+
+@TypeChecked
+Integer test() {
+ Integer num = "1"
+
+ Integer[] numbers = [1,2,3,4]
+
+ Date date = numbers[1]
+
+ return "Test"
+
+}
+
+//CompileStatic example:
+import groovy.transform.CompileStatic
+
+@CompileStatic
+int sum(int x, int y) {
+ x + y
+}
+
+assert sum(2,5) == 7
+
+
+```
+
+## Further resources
+
+[Groovy documentation](http://groovy.codehaus.org/Documentation)
+
+[Groovy web console](http://groovyconsole.appspot.com/)
+
+Join a [Groovy user group](http://groovy.codehaus.org/User+Groups)
+
+## Books
+
+* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook)
+
+* [Groovy in Action] (http://manning.com/koenig2/)
+
+* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do)
+
+
+
+
+
diff --git a/hu-hu/go.html.markdown b/hu-hu/go.html.markdown
new file mode 100644
index 00000000..b3e8c1ca
--- /dev/null
+++ b/hu-hu/go.html.markdown
@@ -0,0 +1,305 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+ - ["Sonia Keys", "https://github.com/soniakeys"]
+translators:
+ - ["Szabó Krisztián", "https://github.com/thenonameguy/"]
+---
+
+A Go programozási nyelv az életszerű feladatok könnyebb elvégzése miatt született.
+A mai legújabb programozási trendeket elkerülve,
+praktikus megoldást nyújt a valós, üzleti problémákra.
+
+C-szerű szintaktikával és statikus típuskezeléssel rendelkezik.
+A fordító szempillantás alatt végez és egy gyorsan futó,statikus futtatható állományt hoz létre.
+A nyelv könnyen érthető, üzenet-alapú konkurenciát tesz lehetővé, így könnyen ki lehet használni
+a mai számítógépek több magos processzorait, ez nagy rendszerek építéséhez ideális.
+
+A Go alap könyvtára mindenre területre kiterjed, ennek köszönhetően a nyelvnek egyre növekvő tábora van.
+
+```Go
+// Egy soros komment
+/* Több
+ soros komment */
+
+// Minden forrás fájl egy csomag-definícióval kezdődik, ez hasonlít a Python csomagkezelésére
+// A main egy különleges csomagnév, ennek a fordítása futtatható állományt hoz létre egy könyvtár helyett.
+package main
+
+// Az import rész meghatározza melyik csomagokat kívánjuk használni ebben a forrásfájlban
+import (
+ "fmt" // A Go alap könyvtárának része
+ "net/http" // Beépített webszerver!
+ "strconv" // Stringek átalakítására szolgáló csomag
+)
+
+// Funkció deklarás, a main nevű funkció a program kezdőpontja.
+func main() {
+ // Println kiírja a beadott paramétereket a standard kimenetre.
+ // Ha más csomagot funkcióját akarjuk használni, akkor azt jelezni kell a csomag nevével
+ fmt.Println("Hello world!")
+
+ // Meghívunk egy másik funkciót ebből a csomagból
+ beyondHello()
+}
+
+// A függvények paraméterei zárójelek között vannak.
+// Ha nincsenek paraméterek, akkor is kötelező a zárójel-pár.
+func beyondHello() {
+ var x int // Változó deklaráció, használat előtt muszáj ezt megtenni.
+ x = 3 // Változó értékadás
+ // "Rövid" deklaráció is létezik, ez az érték alapján deklarálja, definiálja és értéket is ad a változónak
+ y := 4
+ sum, prod := learnMultiple(x, y) // a függvényeknek több visszatérési értéke is lehet
+ fmt.Println("sum:", sum, "prod:", prod) // egyszerű kiíratás
+ learnTypes()
+}
+
+// A funkcióknak elnevezett visszatérési értékük is lehet
+func learnMultiple(x, y int) (sum, prod int) {
+ return x + y, x * y // visszatérünk két értékkel
+ /*
+ sum = x + y
+ prod = x * y
+ return
+ Ez ugyanezzel az eredménnyel járt volna, mint a fenti sor.
+ Üres return esetén, az elnevezett visszatérési változók
+ aktuális értékeikkel térnek vissza. */
+}
+
+// Beépített típusok
+func learnTypes() {
+ // Rövid deklarás az esetek többségében elég lesz a változókhoz
+ s := "Tanulj Go-t!" // string típus
+
+ s2 := `A "nyers" stringekben lehetnek
+ újsorok is!` // de ettől még ez is ugyanolyan string mint az s, nincs külön típusa
+
+ // nem ASCII karakterek. Minden Go forrás UTF-8 és a stringek is azok.
+ g := 'Σ' // rúna(rune) típus, megegyezik az uint32-vel, egy UTF-8 karaktert tárol
+
+ f := 3.14195 // float64, az IEEE-754 szabványnak megfelelő 64-bites lebegőpontos szám
+ c := 3 + 4i // complex128, belsőleg két float64-el tárolva
+
+ // Var szintaxis változó típus definiálással
+ var u uint = 7 // unsigned, az implementáció dönti el mekkora, akárcsak az int-nél
+ var pi float32 = 22. / 7
+
+ // Rövid deklarásnál átalakítás is lehetséges
+ n := byte('\n') // byte típus, ami megegyezik az uint8-al
+
+ // A tömböknek fordítás-időben fixált méretük van
+ var a4 [4]int // egy tömb 4 int-tel, mind 0-ra inicializálva
+ a3 := [...]int{3, 1, 5} // egy tömb 3 int-tel, láthatóan inicalizálva egyedi értékekre
+
+ // Szeleteknek dinamikus a méretük. A szeleteknek és a tömböknek is meg vannak az előnyeik
+ // de a szeleteket sokkal gyakrabban használjuk.
+ s3 := []int{4, 5, 9} // vesd össze a3-al, nincsenek pontok.
+ s4 := make([]int, 4) // allokál 4 int-et, mind 0-ra inicializálva
+ var d2 [][]float64 // ez csak deklaráció, semmi sincs még allokálva
+ bs := []byte("a slice") // típus konverzió szintaxisa
+
+ p, q := learnMemory() // deklarál két mutatót (p,q), két int-re
+ fmt.Println(*p, *q) // * követi a mutatót. Ez a sor kiírja a két int értékét.
+
+ // A map a dinamikusan növelhető asszociatív tömb része a nyelvnek, hasonlít
+ // a hash és dictionary típusokra más nyelvekben.
+ m := map[string]int{"three": 3, "four": 4}
+ m["one"] = 1
+
+ // A felhasználatlan változók fordítás-idejű hibát okoznak a Go-ban.
+ // Az aláhúzással "használod" a változókat, de eldobod az értéküket.
+ _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
+ // Kiíratás is természetesen használatnak minősül
+ fmt.Println(s, c, a4, s3, d2, m)
+
+ learnFlowControl()
+}
+
+// A Go nyelv teljesen szemétgyűjtött (garbage-collected). Megtalálhatók benne mutatók, de nincs mutató aritmetika.
+// Ez azt jelenti, hogy üres mutatóval még mindig hibázhatsz, de hozzáadni/műveleteket végezni már nem lehet.
+func learnMemory() (p, q *int) {
+ // Elnevezett visszatérési változóknak int-re mutató a típusa
+ p = new(int) // a beépített "new" funkció, egy típusnak elegendő memóriát allokál, és visszaad rá egy mutatót.
+ // Az allokált int nullázva van, p többé nem üres mutató.
+ s := make([]int, 20) // allokáljunk 20 int változót egy memóriaterületen.
+ s[3] = 7 // adjunk értéket az egyiknek
+ r := -2 // hozzánk létre egy lokális változót
+ return &s[3], &r // A & megadja a memóriacímét a változónak
+}
+
+func expensiveComputation() int {
+ return 1e6
+}
+
+func learnFlowControl() {
+ // Az elágazásoknak kötelező a kapcsos zárójel, a zárójel nem szükséges.
+ if true {
+ fmt.Println("megmondtam")
+ }
+ // A kód formátumát a nyelvvel járó "go" parancssori program "go fmt" parancsa szabványosítja
+ if false {
+ // így lehet
+ } else {
+ // if/else-t csinálni
+ }
+ // Használjunk switchet a hosszabb elágazások alkalmazása helyett.
+ x := 1
+ switch x {
+ case 0:
+ case 1:
+ // Az "esetek" nem "esnek át", tehát
+ case 2:
+ // ez nem fog lefutni, nincs szükség break-ekre.
+ }
+ // A for ciklus sem használ zárójeleket
+ for x := 0; x < 3; x++ {
+ fmt.Println("iteráció", x)
+ }
+ // itt az x == 1.
+
+ // A for az egyetlen ciklus fajta a Go-ban, de több formája van.
+ for { // végtelen ciklus
+ break // csak vicceltem
+ continue // soha nem fut le
+ }
+ // Akárcsak a for-nál, az if-ben is lehet rövid deklarással egy lokális változót létrehozni
+ // ami az blokk összes if/else-n keresztül érvényes marad.
+ if y := expensiveComputation(); y > x {
+ x = y
+ }
+ // Függvényeket használhatjuk closure-ként is.
+ xBig := func() bool {
+ return x > 100 // a switch felett deklarált x-et használjuk itt
+ }
+ fmt.Println("xBig:", xBig()) // igaz (utoljára 1e6 lett az értéke az x-nek)
+ x /= 1e5 // így most már x == 10
+ fmt.Println("xBig:", xBig()) // 10 pedig kisebb mint 100, tehát hamis
+
+ // Ha nagyon-nagyon szükséges, akkor használhatjuk a jó öreg goto-t.
+ goto love
+love:
+
+ learnInterfaces() // Itt kezdődnek az érdekes dolgok!
+}
+
+// Definiáljuk a Stringert egy olyan interfésznek, amelynek egy metódusa van, a String, ami visszatér egy stringgel.
+type Stringer interface {
+ String() string
+}
+
+// Definiáljuk a pair-t egy olyan struktúrának amelynek két int változója van, x és y.
+type pair struct {
+ x, y int
+}
+
+// Definiáljunk egy metódust a pair struktúrának, ezzel teljesítve a Stringer interf
+func (p pair) String() string { // p lesz a "vevő"
+ // Sprintf az fmt csomag egy publikus függvénye, műkődése megegyezik a C-s megfelelőjével.
+ // A pontokkal érjük el a mindenkori p struktúra elemeit
+ return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+ // A kapcsos zárójellel jelezzük, hogy egyből inicializálni
+ // szeretnénk a struktúra változóit a sorrendnek megfelelően.
+ p := pair{3, 4}
+ fmt.Println(p.String()) // meghívjuk a p String metódusát.
+ var i Stringer // deklaráljuk i-t Stringer típusú interfésznek
+ i = p // lehetséges, mert a pair struktúra eleget tesz a Stringer interfésznek
+ // Meghívjuk i String metódusát, az eredmény ugyanaz, mint az előbb.
+ fmt.Println(i.String())
+
+ // Az fmt csomag funckciói automatikusan meghívják a String funkciót
+ // hogy megtudják egy objektum szöveges reprezentációját.
+ fmt.Println(p) // ugyan az az eredmény mint az előbb, a Println meghívja a String metódust.
+ fmt.Println(i) // dettó
+
+ learnErrorHandling()
+}
+
+func learnErrorHandling() {
+ // ", ok" szokásos megoldás arra, hogy jól működött-e a függvény.
+ m := map[int]string{3: "three", 4: "four"}
+ if x, ok := m[1]; !ok { // ok hamis lesz, mert az 1 nincs benne a map-ban.
+ fmt.Println("nincs meg")
+ } else {
+ fmt.Print(x) // x lenne az érték, ha benne lenne a map-ban.
+ }
+ // A hiba érték többet is elmond a függvény kimeneteléről, mint hogy minden "ok" volt-e
+ if _, err := strconv.Atoi("non-int"); err != nil { // _ eldobja az értéket, úgy se lesz jó jelen esetben
+ // kiírja, hogy "strconv.ParseInt: parsing "non-int": invalid syntax"
+ fmt.Println(err)
+ }
+ // Az interfészekre még visszatérünk, addig is jöjjön a konkurens programozás!
+ learnConcurrency()
+}
+
+// c egy csatorna, egy konkurens-biztos kommunikációs objektum.
+func inc(i int, c chan int) {
+ c <- i + 1 // <- a "küldés" operátor, ha a bal oldalán csatorna van, így i+1-et küld be a csatornába
+}
+
+// Az inc-et fogjuk arra használni, hogy konkurensen megnöveljünk számokat
+func learnConcurrency() {
+ // Ugyan az a make funkció amivel korábban szeleteket hoztunk létre.
+ // Make allokál mapokat, szeleteket és csatornákat.
+ c := make(chan int)
+ // Indítsunk három konkurens goroutine-t. A számok konkurensen lesznek
+ // megnövelve, ha a számítógép képes rá és jól be van állítva, akkor pedig paralellizálva/egymás mellett.
+ // Mind a 3 ugyanabba a csatornába küldi az eredményeket.
+ go inc(0, c) // A go utasítás indít el goroutine-okat.
+ go inc(10, c)
+ go inc(-805, c)
+ // Beolvassuk 3x a csatornából az eredményeket és kiírjuk őket a kimenetre.
+ // Nem lehet tudni milyen sorrendben fognak érkezni az eredmények!
+ fmt.Println(<-c, <-c, <-c) // hogyha a jobb oldalon csatorna van, akkor a "<-" a beolvasó/kapó operátor
+
+ cs := make(chan string) // még egy csatorna, ez stringekkel kommunikál
+ cc := make(chan chan string) // egy csatorna csatornával
+ go func() { c <- 84 }() // indítsunk egy új goroutine-t, csak azért hogy küldjünk egy számot
+ go func() { cs <- "wordy" }() // ugyanez, csak a cs csatornába stringet küldünk
+ // A select olyan mint a switch, csak feltételek helyett csatorna műveletek vannak.
+ // Véletlenszerűen kiválasztja az első olyan esetet, ahol létrejöhet kommunikáció.
+ select {
+ case i := <-c: // a megkapott értéket el lehet tárolni egy változóban
+ fmt.Println("ez egy", i)
+ case <-cs: // vagy el lehet dobni az értékét
+ fmt.Println("ez egy string volt")
+ case <-cc: // üres csatorna, soha nem fog rajta semmi se érkezni
+ fmt.Println("sose futok le :'( ")
+ }
+ // Ezen a ponton vagy c vagy a cs goroutineja lefutott.
+ // Amelyik hamarabb végzett, annak a megfelelő case-e lefutott, a másik blokkolva vár.
+
+ learnWebProgramming() // Go képes rá. Te is képes akarsz rá lenni.
+}
+
+// Egy funkció a http csomagból elindít egy webszervert.
+func learnWebProgramming() {
+ // A ListenAndServe első paramétre egy TCP port, amin kiszolgálunk majd.
+ // Második paramétere egy interfész, pontosabban a http.Handler interfész.
+ err := http.ListenAndServe(":8080", pair{})
+ fmt.Println(err) // nem felejtük el kiírni az esetleges hibákat!
+}
+
+// Csináljunk a pair-ból egy http.Handler-t úgy, hogy implementáljuk az egyetlen metódusát a ServeHTTP-t.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ // Minden kapcsolatra elküldjük ezt a http.ResponseWriter-el
+ w.Write([]byte("Megtanultad a Go-t Y perc alatt!"))
+}
+```
+
+## További olvasmányok
+
+Minden Go-val kapcsolatos megtaláható a [hivatalos Go weboldalon](http://golang.org/).
+Ott követhetsz egy tutorialt, játszhatsz a nyelvvel az interneten és sok érdekességet olvashatsz.
+
+A nyelv specifikációját kifejezetten érdemes olvasni, viszonylag rövid és sokat tanul belőle az ember.
+
+Ha pedig jobban bele akarod vetni magad a Go-ba, akkor a standard könyvtárban a legjobb praktikákat kilesheted.
+TIPP: a dokumentációban kattints egy funkció nevére és rögtön megmutatja a hozzá tartozó kódot!
+
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
new file mode 100644
index 00000000..50bca246
--- /dev/null
+++ b/tr-tr/c-tr.html.markdown
@@ -0,0 +1,484 @@
+---
+name: c
+category: language
+language: c
+filename: learnc-tr.c
+contributors:
+ - ["Adam Bard", "http://adambard.com/"]
+translators:
+ - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+
+---
+/*
+C halen modern yüksek performans bilgisayarların dili.
+
+C bir çok programcının kullandığı en düşük seviye dillerdendir, ama
+salt hız ile daha fazlasını karşılar. C'nin bellek yönetiminden iyi
+anlarsanız sizi isteğiniz yere götürecektir.
+
+```c
+// Tek satır yorum // karakterleri ile başlar
+
+/*
+Çoklu satırlı yorumlar bu şekilde görünür.
+*/
+
+// C Standart kütüphanelerini uygulamanıza #include<ornek.h> ile
+// dahil edebilirsiniz.
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// Kendi başlık(header) dosyalarınız dahil etmek için "çift tırnak"
+// kullanmalısınız.
+#include "my_header.h"
+
+// Fonksiyonlarınızı bir .h dosyasında ya da c dosyanızın üst tarafta
+// tanımlayın.
+
+void function_1();
+void function_2();
+
+// Programınızın giriş noktası main isimli bir fonksiyondur ve
+// integer değer döner
+int main() {
+
+ // çıktıları yazdırmak için printf kullanılır, "print formatted"
+ // %d bir sayı tipidir, \n yeni satır karakteridir
+ printf("%d\n", 0); // => 0 karakteri yazdırılır.
+ // Tüm ifadeler noktalı virgül ile bitmelidir.
+
+ ///////////////////////////////////////
+ // Tipler
+ ///////////////////////////////////////
+
+ // Değişkenleri kullanmadan önce tanımlamalısınız. Bir değişken tanımlarken
+ // tipini belirtmelisiniz; bu tip onun byte olarak boyutunu belirler.
+
+ // int değişken tipi 4 byte boyutundadır.
+ int x_int = 0;
+
+ // short değişken tipi genellikle 2 byte boyutundadır.
+ short x_short = 0;
+
+ // char tipi 1 byte boyutunu garanti eder.
+ char x_char = 0;
+ char y_char = 'y'; // Karakterler '' işaretleri arasına yazılır.
+
+ // long tipi 4-8 byte olur; long long tipi en azından 64 bit garantiler.
+ long x_long = 0;
+ long long x_long_long = 0;
+
+ // float tipi 32-bit kayan noktalı sayı boyutundadır.
+ float x_float = 0.0;
+
+ // double değişken tipi 64-bit kayan noktalı yazı tipindedir.
+ double x_double = 0.0;
+
+ // Integral türleri işaretsiz olabilir. Bunun anlamı, onlar eksi değer
+ // olamaz demektir, ama aynı boyuttaki işaretsiz bir sayının maksimum
+ // değeri işaretli bir sayının maksimum değeriden büyük olur.
+ unsigned char ux_char;
+ unsigned short ux_short;
+ unsigned int ux_int;
+ unsigned long long ux_long_long;
+
+ // Diğer taraftan char, ki her zaman bir byte boyutundadır, bu tipler
+ // makinenize göre boyut değiştirir. sizeof(T) size bir değişkenin byte
+ // cinsinden boyutunu verir öyle ki bu tipin boyutunu taşınabilir bir
+ // şekilde ifade edilebilir
+ // Örneğin,
+ printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words)
+
+ // If the argument of the `sizeof` operator an expression, then its argument
+ // is not evaluated (except VLAs (see below)).
+ // The value it yields in this case is a compile-time constant.
+ int a = 1;
+ size_t size = sizeof(a++); // a++ is not evaluated
+ printf("sizeof(a++) = %zu where a = %d\n", size, a);
+ // prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture)
+
+ // Diziler somut bir boyut ile oluşturulmalıdır.
+ char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
+ int my_int_array[20]; // Bu dizi 4 * 20 = 80 byte alan kaplar
+ // (4-byte bir word varsayılır)
+
+ // Şu şekilde bir diziyi 0 ile oluşturabilirsiniz:
+ char my_array[20] = {0};
+
+ // Dizinin elemanlarını indexlemek diğer diller gibidir, veya
+ // diğer diller C gibi.
+ my_array[0]; // => 0
+
+ // Diziler değişebilirdir (mutable); O sadece memory!
+ my_array[1] = 2;
+ printf("%d\n", my_array[1]); // => 2
+
+ // In C99 (and as an optional feature in C11), variable-length arrays (VLAs)
+ // can be declared as well. The size of such an array need not be a compile
+ // time constant:
+ printf("Enter the array size: "); // ask the user for an array size
+ char buf[0x100];
+ fgets(buf, sizeof buf, stdin);
+
+ // strtoul parses a string to an unsigned integer
+ size_t size = strtoul(buf, NULL, 10);
+ int var_length_array[size]; // declare the VLA
+ printf("sizeof array = %zu\n", sizeof var_length_array);
+
+ // A possible outcome of this program may be:
+ // > Enter the array size: 10
+ // > sizeof array = 40
+
+ // String'ler bir NUL (0x00) byte ile sonlandırılmış karakter dizileridir,
+ // bu string içerisinde özel bir karakter olan '\0' ile gösterilir.
+ // (Biz Nul byte'i string karakterleri arasında bulundurmamıza gerek
+ // yoktur; derleyici onu bizim için dizinin sonuna ekler.)
+ char a_string[20] = "This is a string";
+ printf("%s\n", a_string); // %s bir string formatıdır.
+
+ /*
+ a_string 16 karakter uzunluğundadır.
+ 17. karakter NUL karakteridir.
+ 18., 19. ve 20. karakterler tanımsızdır.(undefined)
+ */
+
+ printf("%d\n", a_string[16]); // => 0
+ // i.e., byte #17 is 0 (as are 18, 19, and 20)
+
+ // If we have characters between single quotes, that's a character literal.
+ // It's of type `int`, and *not* `char` (for historical reasons).
+ int cha = 'a'; // fine
+ char chb = 'a'; // fine too (implicit conversion from int to char)
+
+ ///////////////////////////////////////
+ // Operatörler
+ ///////////////////////////////////////
+
+ int i1 = 1, i2 = 2; // Çoklu tanımlama için kısayol.
+ float f1 = 1.0, f2 = 2.0;
+
+ // Aritmatik basittir.
+ i1 + i2; // => 3
+ i2 - i1; // => 1
+ i2 * i1; // => 2
+ i1 / i2; // => 0 (0.5'dir ama 0 a yuvarlanmıştır.)
+
+ f1 / f2; // => 0.5, artı veya eksi epsilon
+
+ // Modüler aritmetikte vardır.
+ 11 % 3; // => 2
+
+ // Karşılaştırma operatörleri muhtemelen tanıdıktır, ama
+ // C'de boolean tipi yoktur. Bunun yerine sayı(int) kullanırız.
+ // 0 false yerine ve diğer herşey true yerine geçmektedir.
+ // (Karşılaştırma operatörleri her zaman 0 veya 1 dönmektedir.)
+ 3 == 2; // => 0 (false)
+ 3 != 2; // => 1 (true)
+ 3 > 2; // => 1
+ 3 < 2; // => 0
+ 2 <= 2; // => 1
+ 2 >= 2; // => 1
+
+ // Sayılar üzerinde mantık işlemleri
+ !3; // => 0 (Logical not)
+ !0; // => 1
+ 1 && 1; // => 1 (Logical and)
+ 0 && 1; // => 0
+ 0 || 1; // => 1 (Logical or)
+ 0 || 0; // => 0
+
+ // Bit boyutunda işlem yapmak için operatörler
+ ~0x0F; // => 0xF0 (bitwise negation)
+ 0x0F & 0xF0; // => 0x00 (bitwise AND)
+ 0x0F | 0xF0; // => 0xFF (bitwise OR)
+ 0x04 ^ 0x0F; // => 0x0B (bitwise XOR)
+ 0x01 << 1; // => 0x02 (bitwise left shift (by 1))
+ 0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
+
+ // Be careful when shifting signed integers - the following are undefined:
+ // - shifting into the sign bit of a signed integer (int a = 1 << 32)
+ // - left-shifting a negative number (int a = -1 << 2)
+ // - shifting by an offset which is >= the width of the type of the LHS:
+ // int a = 1 << 32; // UB if int is 32 bits wide
+
+ ///////////////////////////////////////
+ // Kontrol Yapıları
+ ///////////////////////////////////////
+
+ if (0) {
+ printf("I am never run\n");
+ } else if (0) {
+ printf("I am also never run\n");
+ } else {
+ printf("I print\n");
+ }
+
+ // While Döngüsü
+ int ii = 0;
+ while (ii < 10) {
+ printf("%d, ", ii++); // ii++, ii değişkenini değerini kullandıktan sonra artırır.
+ } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+ printf("\n");
+
+ int kk = 0;
+ do {
+ printf("%d, ", kk);
+ } while (++kk < 10); // ++kk, kk değişkeninin değerini kullanmadan önce artırır.
+ // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+ printf("\n");
+
+ // For Döngüsü
+ int jj;
+ for (jj=0; jj < 10; jj++) {
+ printf("%d, ", jj);
+ } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+ printf("\n");
+
+ ///////////////////////////////////////
+ // Tip Dönüşümleri
+ ///////////////////////////////////////
+
+ // C'de her değer bir tipe sahiptir, ama siz bir değeri bir başka tipe
+ // dönüştürebilirsiniz.
+
+ int x_hex = 0x01; // Hex literatüründe değer atayabilirsiniz.
+
+ // Türler arasındaki dönüşümde kendi değerini korumak için çalışacaktır.
+ printf("%d\n", x_hex); // => Prints 1
+ printf("%d\n", (short) x_hex); // => Prints 1
+ printf("%d\n", (char) x_hex); // => Prints 1
+
+ // Tip hiçbir hata vermeden taşacaktır(overflow).
+ printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 eğer karakter 8 bit uzunluğunda ise)
+
+ // `char`, `signed char` ve `unsigned char` karakter tiplerinin maksimum uzunluğunu
+ // belirlemek için <limits.h> kütüphanesindeki CHAR_MAX, SCHAR_MAX ve UCHAR_MAX
+ // macrolarını kullanınız.
+
+ // Integral tipi kayan noktalı yazı tipine dönüştürülecektir ve tam tersi.
+ printf("%f\n", (float)100); // %f formats a float
+ printf("%lf\n", (double)100); // %lf formats a double
+ printf("%d\n", (char)100.0);
+
+ ///////////////////////////////////////
+ // İşaretçiler (Pointers)
+ ///////////////////////////////////////
+
+ // Bir işaretci bellek adresini barındıran bir değişkendir. Tanımlaması ile işaret
+ // edeceği verinin tipi de belirtilecektir. Değişkenlerininzi bellek adreslerini
+ // getirerek bellek ile ilgili karışıklığı ortadan kaldırabilirsiniz.
+
+ int x = 0;
+ printf("%p\n", &x); // & işareti bir değişkenin bellek adresini getirmek için kullanılır.
+ // (%p işaretçilerin formatıdır)
+ // => Bazı bellek adresleri yazdırılacaktır.
+
+
+ // İşaretçiler tanımlanırken * ile başlar
+ int *px, not_a_pointer; // px sayı tipinde bir işaretçidir.
+ px = &x; // X değişkeninin bellek adresi px değişkeninde tutulmaktadır.
+ printf("%p\n", px); // => x değişkeninin bellek adresi yazdırılacaktır.
+ printf("%d, %d\n", (int)sizeof(px), (int)sizeof(not_a_pointer));
+ // => 64-bit sistemde "8, 4" yazdırılacaktır.
+
+ // İşaretçinin adres olarak gösterdiği yerdeki değeri almak için
+ // değişkenin önüne * işareti ekleyiniz.
+ printf("%d\n", *px); // => 0 bastıracaktır, x in değeridir,
+ // çünkü px değişkeni x in adresini göstermektedir.
+
+ // Ayrıca siz işaretçinin gösterdiği yerin değerini
+ // değiştirebilirsiniz. Burada referansı parantez içerisinde göstereceğiz
+ // çünkü ++ işleminin önceliği * işleminden yüksektir.
+ (*px)++; // px'in işaret ettiği değeri 1 artır.
+ printf("%d\n", *px); // => 1 yazdırılır.
+ printf("%d\n", x); // => 1 yazdırılır.
+
+ int x_array[20]; // Diziler(arrays) bellekten yan yana bellek bloklarını
+ // tahsis etmek için iyi bir yöntemdir.
+ int xx;
+ for (xx=0; xx<20; xx++) {
+ x_array[xx] = 20 - xx;
+ } // x_array dizisi 20, 19, 18,... 2, 1 değerleri ile oluşturuluyor.
+
+ // Bir sayı tipinde işaretçi tanımlanıyor ve x_array'i işaret ediyor.
+ int* x_ptr = x_array;
+ // x_ptr artık dizinin ilk elemanını işaret etmektedir (the integer 20).
+ // Bu çalışacaktır çünkü diziler(arrays) aslında sadece onların ilk
+ // elemanlarını gösteren birer işaretçidir.
+ // For example, when an array is passed to a function or is assigned to a pointer,
+ // it decays into (implicitly converted to) a pointer.
+ // Exceptions: when the array is the argument of the `&` (address-od) operator:
+ int arr[10];
+ int (*ptr_to_arr)[10] = &arr; // &arr is NOT of type `int *`!
+ // It's of type "pointer to array" (of ten `int`s).
+ // or when the array is a string literal used for initializing a char array:
+ char arr[] = "foobarbazquirk";
+ // or when it's the argument of the `sizeof` or `alignof` operator:
+ int arr[10];
+ int *ptr = arr; // equivalent with int *ptr = &arr[0];
+ printf("%zu %zu\n", sizeof arr, sizeof ptr); // probably prints "40, 4" or "40, 8"
+
+ // Diziler ilk elemanlarını gösteren birer işaretçidirler.
+ printf("%d\n", *(x_ptr)); // => 20 yazılacaktır.
+ printf("%d\n", x_array[0]); // => 20 yazılacaktır.
+
+ // İşaretçiler kendi tiplerinde artırılır ve azaltılır.
+ printf("%d\n", *(x_ptr + 1)); // => 19 yazılacaktır.
+ printf("%d\n", x_array[1]); // => 19 yazılacaktır.
+
+ // Ayrıca dinamik olarak bir bellek bloğunu standart kütüphanede bulunan
+ // malloc fonksiyonu ile uygulamanız için ayırabilirsiniz. Bu fonksiyon
+ // byte türünden ayırmak istediğiniz bloğun boyutunu parametre olarak alır.
+ int* my_ptr = (int*) malloc(sizeof(int) * 20);
+ for (xx=0; xx<20; xx++) {
+ *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 'de aynı zamanda çalışabilir
+ } // Bellekte 20, 19, 18, 17... 2, 1 (as ints) şeklinde oluşturulmuş olacaktır.
+
+ // Eğer ayrımadığınız bir bellek adresini çağırırsanız
+ // öngörülmeyen bir değer dönecektir.
+ printf("%d\n", *(my_ptr + 21)); // => kim-bilir-ne-yazacak?
+
+ // Malloc fonksiyonu ile ayrıdığınız bellek kısmı ile işiniz bittiğinde
+ // onu free fonksiyonu ile boşaltmalısınız, aksi durumda uygulamanız
+ // kapatılana kadar belleğin o kısmını kimse kullanamaz.
+ free(my_ptr);
+
+ // Metin Dizileri(String) birer karakter dizisidir(char array), ama
+ // genelde karakter işaretçisi olarak kullanılır.
+ char* my_str = "This is my very own string";
+
+ printf("%c\n", *my_str); // => 'T'
+
+ function_1();
+} // main fonksiyon sonu
+
+///////////////////////////////////////
+// Fonksiyonlar
+///////////////////////////////////////
+
+// Fonksiyon tanımlama sözdizimi:
+// <return type> <fonksiyon adi>(<args>)
+
+int add_two_ints(int x1, int x2){
+ return x1 + x2; // bir değer geri döndürmek için return kullanılır.
+}
+
+/*
+Fonksiyonlar pass-by-value'dür, ama isterseniz işaretçi referanslarını
+kullanarak fonksiyona gönderilen parametrenin değerini değiştirebilirsiniz.
+
+Example: Bir metni tersine çevirme
+*/
+
+// Bir void konksiyonu hiç bir değer dönmez
+void str_reverse(char* str_in){
+ char tmp;
+ int ii=0, len = strlen(str_in); // Strlen C'nin standart kütüphanesinin bir fonksiyonu
+ for(ii=0; ii<len/2; ii++){
+ tmp = str_in[ii];
+ str_in[ii] = str_in[len - ii - 1]; // sondan ii'inci elemanı
+ str_in[len - ii - 1] = tmp;
+ }
+}
+
+/*
+char c[] = "This is a test.";
+str_reverse(c);
+printf("%s\n", c); // => ".tset a si sihT"
+*/
+
+///////////////////////////////////////
+// Kullanıcı Tanımlı Tipler ve Yapılar
+///////////////////////////////////////
+
+// Typedef'ler bir tip takma adı oluşturur.
+typedef int my_type;
+my_type my_type_var = 0;
+
+// Struct'lar bir veri koleksiyonudur.
+struct rectangle {
+ int width;
+ int height;
+};
+
+// It's not generally true that
+// sizeof(struct rectangle) == sizeof(int) + sizeof(int)
+// due to potential padding between the structure members (this is for alignment
+// reasons). [1]
+
+void function_1(){
+
+ struct rectangle my_rec;
+
+ // "." ile yapı üyelerine ulaşılabilir.
+ my_rec.width = 10;
+ my_rec.height = 20;
+
+ // Bir yapının adresini işaretçiye atayabilirsiniz.
+ struct rectangle* my_rec_ptr = &my_rec;
+
+ // İşaretçi üzerinden bir yapıya ulaşabilirsiniz.
+ (*my_rec_ptr).width = 30;
+
+ // ya da -> işareti ile yapının elemanlarına ulaşabilirsiniz.
+ my_rec_ptr->height = 10; // (*my_rec_ptr).height = 10; ile aynıdır.
+}
+
+// Kolaylık sağlamak için bir yapıya typedef tanımlayabilirsiniz.
+typedef struct rectangle rect;
+
+int area(rect r){
+ return r.width * r.height;
+}
+
+///////////////////////////////////////
+// Fonksiyon İşaretçiler
+///////////////////////////////////////
+
+/*
+Çalışma zamanında, fonksiyonların bilinen bir bellek adresleri vardır. Fonksiyon
+işaretçileri fonksiyonları direk olarak çağırmayı sağlayan veya geri bildirim(callback)
+için parametre gönderirken kullanılan başka birer işaretçidirler. Ama, syntax tanımı
+başlangıçta biraz karışık gelebilir.
+
+Örnek: bir işaretçiden str_reverse kullanımı
+*/
+void str_reverse_through_pointer(char * str_in) {
+ // f adında bir fonksiyon işaretçisi tanımlanır.
+ void (*f)(char *); // Signature should exactly match the target function.
+ f = &str_reverse; // Assign the address for the actual function (determined at runtime)
+ (*f)(str_in); // Just calling the function through the pointer
+ // f(str_in); // That's an alternative but equally valid syntax for calling it.
+}
+
+/*
+As long as function signatures match, you can assign any function to the same pointer.
+Function pointers are usually typedef'd for simplicity and readability, as follows:
+*/
+
+typedef void (*my_fnp_type)(char *);
+
+// Gerçek bir işaretçi tanımlandığı zaman ki kullanımı:
+// ...
+// my_fnp_type f;
+
+```
+
+## Daha Fazla Okuma Listesi
+
+[K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)'in bir kopyasını bulundurmak mükemmel olabilir
+
+Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/)
+
+It's very important to use proper spacing, indentation and to be consistent with your coding style in general.
+Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the
+[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+
+Diğer taraftan google sizin için bir arkadaş olabilir.
+
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member \ No newline at end of file
diff --git a/whip.html.markdown b/whip.html.markdown
index b8852ecb..3429ec24 100644
--- a/whip.html.markdown
+++ b/whip.html.markdown
@@ -109,18 +109,18 @@ undefined ; user to indicate a value that hasn't been set
; Dictionaries are Whip's equivalent to JavaScript 'objects' or Python 'dicts'
; or Ruby 'hashes': an unordered collection of key-value pairs.
-{"key1":"value1" "key2":2 3:3}
+{"key1" "value1" "key2" 2 3 3}
; Keys are just values, either identifier, number, or string.
-(def my_dict {my_key:"my_value" "my other key":4})
-; But in Whip, dictionaries get parsed like: value, colon, value;
-; with whitespace between each. So that means
-{"key": "value"
+(def my_dict {my_key "my_value" "my other key" 4})
+; But in Whip, dictionaries get parsed like: value, whitespace, value;
+; with more whitespace between each. So that means
+{"key" "value"
"another key"
-: 1234
+1234
}
; is evaluated to the same as
-{"key":"value" "another key":1234}
+{"key" "value" "another key" 1234}
; Dictionary definitions can be accessed used the `at` function
; (like strings and lists.)
@@ -220,8 +220,8 @@ undefined ; user to indicate a value that hasn't been set
(max (1 2 3 4)) ; 4
; If value is in list or object
(elem 1 (1 2 3)) ; true
-(elem "foo" {"foo":"bar"}) ; true
-(elem "bar" {"foo":"bar"}) ; false
+(elem "foo" {"foo" "bar"}) ; true
+(elem "bar" {"foo" "bar"}) ; false
; Reverse list order
(reverse (1 2 3 4)) ; => (4 3 2 1)
; If value is even or odd