adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-10-05 09:08:02 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #1 from adambard/master

Browse Source 
Fetch updates from upstream
This commit is contained in:
Arnie97 2015-04-11 13:09:50 +08:00
commit c7f085ee34
21 changed files with 1761 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
brainfuck.html.markdown
View File

@ -8,6 +8,8 @@ contributors:
Brainfuck (not capitalized except at the start of a sentence) is an extremely
minimal Turing-complete programming language with just 8 commands.
You can try brainfuck on your browser with [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
```
Any character not "><+-.,[]" (excluding quotation marks) is ignored.

4
c.html.markdown
View File

@ -234,7 +234,7 @@ int main() {
// same with j-- and --j
// Bitwise operators!
~0x0F; // => 0xF0 (bitwise negation, "1's complement")
~0x0F; // => 0xFFFFFFF0 (bitwise negation, "1's complement", example result for 32-bit int)
0x0F & 0xF0; // => 0x00 (bitwise AND)
0x0F | 0xF0; // => 0xFF (bitwise OR)
0x04 ^ 0x0F; // => 0x0B (bitwise XOR)
@ -242,7 +242,7 @@ int main() {
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)
// - shifting into the sign bit of a signed integer (int a = 1 << 31)
// - 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

62
de-de/go-de.html.markdown
View File

@ -5,34 +5,34 @@ contributors:
- ["Joseph Adams", "https://github.com/jcla1"]
lang: de-de
---
Go wurde entwickelt um probleme zu lösen. Sie ist zwar nicht der neuste Trend in
der Informatik, aber sie ist eine der neusten und schnellsten Wege um Aufgabe in
Go wurde entwickelt, um Probleme zu lösen. Sie ist zwar nicht der neueste Trend in
der Informatik, aber sie ist einer der neuesten und schnellsten Wege, um Aufgabe in
der realen Welt zu lösen.
Sie hat vertraute Elemente von imperativen Sprachen mit statisher Typisierung
Sie hat vertraute Elemente von imperativen Sprachen mit statischer Typisierung
und kann schnell kompiliert und ausgeführt werden. Verbunden mit leicht zu
verstehenden Parallelitäts-Konstrukten, um die heute üblichen mehrkern
Prozessoren optimal nutzen zu können, eignet sich Go äußerst gut für große
Programmierprojekte.
Außerdem beinhaltet Go eine gut ausgestattete standard bibliothek und hat eine
aktive community.
Außerdem beinhaltet Go eine gut ausgestattete Standardbibliothek und hat eine
aktive Community.
```go
// Einzeiliger Kommentar
/* Mehr-
zeiliger Kommentar */
// Eine jede Quelldatei beginnt mit einer Packet-Klausel.
// "main" ist ein besonderer Packetname, da er ein ausführbares Programm
// Eine jede Quelldatei beginnt mit einer Paket-Klausel.
// "main" ist ein besonderer Pkaetname, da er ein ausführbares Programm
// einleitet, im Gegensatz zu jedem anderen Namen, der eine Bibliothek
// deklariert.
package main
// Ein "import" wird verwendet um Packte zu deklarieren, die in dieser
// Ein "import" wird verwendet, um Pakete zu deklarieren, die in dieser
// Quelldatei Anwendung finden.
import (
"fmt" // Ein Packet in der Go standard Bibliothek
"fmt" // Ein Paket in der Go Standardbibliothek
"net/http" // Ja, ein Webserver.
"strconv" // Zeichenkettenmanipulation
)
@ -42,10 +42,10 @@ import (
// Programms. Vergessen Sie nicht die geschweiften Klammern!
func main() {
// Println gibt eine Zeile zu stdout aus.
// Der Prefix "fmt" bestimmt das Packet aus welchem die Funktion stammt.
// Der Prefix "fmt" bestimmt das Paket aus welchem die Funktion stammt.
fmt.Println("Hello world!")
// Aufruf einer weiteren Funktion definiert innerhalb dieses Packets.
// Aufruf einer weiteren Funktion definiert innerhalb dieses Pakets.
beyondHello()
}
@ -54,7 +54,7 @@ func main() {
func beyondHello() {
var x int // Deklaration einer Variable, muss vor Gebrauch geschehen.
x = 3 // Zuweisung eines Werts.
// Kurze Deklaration: Benutzen Sie ":=" um die Typisierung automatisch zu
// Kurze Deklaration: Benutzen Sie ":=", um die Typisierung automatisch zu
// folgern, die Variable zu deklarieren und ihr einen Wert zu zuweisen.
y := 4
@ -70,7 +70,7 @@ func learnMultiple(x, y int) (sum, prod int) {
return x + y, x * y // Wiedergabe zweier Werte
}
// Überblick ueber einige eingebaute Typen und Literale.
// Überblick über einige eingebaute Typen und Literale.
func learnTypes() {
// Kurze Deklarationen sind die Norm.
s := "Lernen Sie Go!" // Zeichenketten-Typ
@ -111,7 +111,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
m["eins"] = 1
// Ungebrauchte Variablen sind Fehler in Go
// Der Unterstrich wird verwendet um einen Wert zu verwerfen.
// Der Unterstrich wird verwendet, um einen Wert zu verwerfen.
_, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
// Die Ausgabe zählt natürlich auch als Gebrauch
fmt.Println(s, c, a4, s3, d2, m)
@ -142,7 +142,7 @@ func learnFlowControl() {
if true {
fmt.Println("hab's dir ja gesagt!")
}
// Die Formattierung ist durch den Befehl "go fmt" standardisiert
// Die Formatierung ist durch den Befehl "go fmt" standardisiert
if false {
// nicht hier
} else {
@ -170,7 +170,7 @@ func learnFlowControl() {
continue // wird nie ausgeführt
}
// Wie bei for, bedeutet := in einer Bedingten Anweisung zunächst die
// Wie bei for, bedeutet := in einer bedingten Anweisung zunächst die
// Zuweisung und erst dann die Überprüfung der Bedingung.
if y := expensiveComputation(); y > x {
x = y
@ -217,8 +217,8 @@ func learnInterfaces() {
// Aufruf der String Methode von i, gleiche Ausgabe wie zuvor.
fmt.Println(i.String())
// Funktionen des fmt-Packets rufen die String() Methode auf um eine
// druckbare variante des Empfängers zu erhalten.
// Funktionen des fmt-Pakets rufen die String() Methode auf um eine
// druckbare Variante des Empfängers zu erhalten.
fmt.Println(p) // gleiche Ausgabe wie zuvor
fmt.Println(i) // und wieder die gleiche Ausgabe wie zuvor
@ -244,18 +244,18 @@ func learnErrorHandling() {
learnConcurrency()
}
// c ist ein Kannal, ein sicheres Kommunikationsmedium.
// c ist ein Kanal, ein sicheres Kommunikationsmedium.
func inc(i int, c chan int) {
c <- i + 1 // <- ist der "send" Operator, wenn ein Kannal auf der Linken ist
c <- i + 1 // <- ist der "send" Operator, wenn ein Kanal auf der Linken ist
}
// Wir verwenden "inc" um Zahlen parallel zu erhöhen.
func learnConcurrency() {
// Die selbe "make"-Funktion wie vorhin. Sie initialisiert Speicher für
// maps, slices und Kannäle.
// maps, slices und Kanäle.
c := make(chan int)
// Starte drei parallele "Goroutines". Die Zahlen werden parallel (concurrently)
// erhöht. Alle drei senden ihr Ergebnis in den gleichen Kannal.
// erhöht. Alle drei senden ihr Ergebnis in den gleichen Kanal.
go inc(0, c) // "go" ist das Statement zum Start einer neuen Goroutine
go inc(10, c)
go inc(-805, c)
@ -269,16 +269,16 @@ func learnConcurrency() {
// Start einer neuen Goroutine, nur um einen Wert zu senden
go func() { c <- 84 }()
go func() { cs <- "wortreich" }() // schon wider, diesmal für
go func() { cs <- "wortreich" }() // schon wieder, diesmal für
// "select" hat eine Syntax wie ein switch Statement, aber jeder Fall ist
// eine Kannaloperation. Es wählt eine Fall zufällig aus allen die
// kommunikationsbereit sind aus.
// eine Kanaloperation. Es wählt einen Fall zufällig aus allen, die
// kommunikationsbereit sind, aus.
select {
case i := <-c: // der empfangene Wert kann einer Variable zugewiesen werden
fmt.Printf("es ist ein: %T", i)
case <-cs: // oder der Wert kann verworfen werden
fmt.Println("es ist eine Zeichenkette!")
case <-cc: // leerer Kannal, nicht bereit für den Empfang
case <-cc: // leerer Kanal, nicht bereit für den Empfang
fmt.Println("wird nicht passieren.")
}
// Hier wird eine der beiden Goroutines fertig sein, die andere nicht.
@ -287,16 +287,16 @@ func learnConcurrency() {
learnWebProgramming() // Go kann es und Sie hoffentlich auch bald.
}
// Eine einzige Funktion aus dem http-Packet kann einen Webserver starten.
// Eine einzige Funktion aus dem http-Paket kann einen Webserver starten.
func learnWebProgramming() {
// Der erste Parameter von "ListenAndServe" ist eine TCP Addresse an die
// Der erste Parameter von "ListenAndServe" ist eine TCP Addresse, an die
// sich angeschlossen werden soll.
// Der zweite Parameter ist ein Interface, speziell: ein http.Handler
err := http.ListenAndServe(":8080", pair{})
fmt.Println(err) // Fehler sollte man nicht ignorieren!
}
// Wir lassen "pair" das http.Handler Interface erfüllen indem wir seine einzige
// Wir lassen "pair" das http.Handler Interface erfüllen, indem wir seine einzige
// Methode implementieren: ServeHTTP
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Senden von Daten mit einer Methode des http.ResponseWriter
@ -313,6 +313,6 @@ Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
kurz und auch gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/).
Gut documentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktions-
Namen in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).

4
de-de/python-de.html.markdown
View File

@ -149,7 +149,7 @@ li[0] #=> 1
# Das letzte Element ansehen
li[-1] #=> 3
# Bei Zugriffen außerhal der Liste kommt es jedoch zu einem IndexError
# 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
@ -188,7 +188,7 @@ tup[:2] #=> (1, 2)
# 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
# Tuple werden standardmäßig erstellt, wenn wir uns die Klammern sparen
# 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

2
erlang.html.markdown
View File

@ -206,7 +206,7 @@ max(X, Y) ->
if
X > Y -> X;
X < Y -> Y;
true -> nil;
true -> nil
end.
% Warning: at least one of the guards in the `if` expression must evaluate to true;

439
fr-fr/go-fr.html.markdown Normal file
View File

@ -0,0 +1,439 @@
---
name: Go
category: language
language: Go
lang: fr-fr
filename: learngo.go
contributors:
- ["Sonia Keys", "https://github.com/soniakeys"]
- ["Christopher Bess", "https://github.com/cbess"]
- ["Jesse Johnson", "https://github.com/holocronweaver"]
- ["Quint Guvernator", "https://github.com/qguv"]
- ["Jose Donizetti", "https://github.com/josedonizetti"]
- ["Alexej Friesen", "https://github.com/heyalexej"]
- ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"]
---
Go a été créé dans l'optique de développer de façon efficace. Ce n'est pas la
dernière tendance en ce qui est au développement, mais c'est la nouvelle façon
de régler des défis réels de façon rapide.
Le langage possède des concepts familiers à la programmation impérative avec
typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à
comprendre, pour les processeurs multi coeurs d'aujourd'hui et apporte des
fonctionnalités facilitant le développement à grande échelle.
Développer avec Go, c'est bénéficier d'une riche bibliothèque standard et d'une
communauté active.
```go
// Commentaire ligne simple
/* Commentaire
multiligne */
// Un paquet débute avec une clause "package"
// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt
// qu'une bibliothèque
package main
// "Import" déclare les paquets référencés dans ce fichier.
import (
"fmt" // Un paquet dans la bibliothèque standard.
"io/ioutil" // Implémente des fonctions utilitaires I/O.
m "math" // Bibliothèque mathématique utilisant un alias local "m".
"net/http" // Un serveur Web!
"strconv" // Bibliothèque pour convertir les chaînes de caractères.
)
// Une définition de fonction. La fonction "main" est spéciale - c'est le point
// d'entrée du binaire.
func main() {
// Println retournera la valeur à la console.
// Associez la fonction avec son paquet respectif, fmt.
fmt.Println("Hello world!")
// Appelez une fonction différente à partir de ce paquet.
beyondHello()
}
// Les fonctions ont des paramètres entre parenthèses.
// Les parenthèses sont nécessaires avec ou sans paramètre.
func beyondHello() {
var x int // Déclaration de variable. Les variables doivent être déclarées
// avant leur utilisation.
x = 3 // Assignation de valeur.
// Les déclarations courtes utilisent := pour inférer le type, déclarer et
// assigner.
y := 4
sum, prod := learnMultiple(x, y) // La fonction retourne deux valeurs.
fmt.Println("sum:", sum, "prod:", prod) // Affichage simple.
learnTypes() // < y minutes, en savoir plus!
}
// Les fonctions peuvent avoir des paramètres et plusieurs valeurs retournées.
func learnMultiple(x, y int) (sum, prod int) {
return x + y, x * y // Deux valeurs retournées.
}
// Quelques types inclus et littéraux.
func learnTypes() {
// Une déclaration courte infère généralement le type désiré.
str := "Learn Go!" // Type string.
s2 := `Une chaîne de caractères peut contenir des
sauts de ligne.` // Chaîne de caractère.
// Littéral non-ASCII. Les sources Go utilisent le charset UTF-8.
g := 'Σ' // type rune, un alias pour le type int32, contenant un caractère
// unicode.
f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit.
c := 3 + 4i // complex128, considéré comme deux float64 par le compilateur.
// Syntaxe "var" avec une valeur d'initialisation.
var u uint = 7 // Non signé, mais la taille dépend selon l'entier.
var pi float32 = 22. / 7
// Conversion avec syntaxe courte.
n := byte('\n') // byte est un alias du type uint8.
// Les tableaux ont une taille fixe déclarée à la compilation.
var a4 [4]int // Un tableau de 4 ints, tous initialisés à 0.
a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3
// éléments, contenant les valeurs 3, 1 et 5.
// Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun
// des avantages, mais les cas d'utilisation des slices sont plus fréquents.
s3 := []int{4, 5, 9} // Comparable à a3.
s4 := make([]int, 4) // Alloue un slice de 4 ints, initialisés à 0.
var d2 [][]float64 // Déclaration seulement, sans allocation de mémoire.
bs := []byte("a slice") // Conversion d'une chaîne en slice de bytes.
// Parce qu'elles sont dynamiques, les slices peuvent être jointes sur
// demande. Pour joindre un élément à une slice, la fonction standard append()
// est utilisée. Le premier argument est la slice à utiliser. Habituellement,
// la variable tableau est mise à jour sur place, voir ci-bas.
s := []int{1, 2, 3} // Le résultat est une slice de taille 3.
s = append(s, 4, 5, 6) // Ajout de 3 valeurs. La taille est de 6.
fmt.Println(s) // La valeur est de [1 2 3 4 5 6]
// Pour ajouter une slice à une autre, au lieu d'utiliser une liste de valeurs
// atomiques, il est possible de mettre en argument une référence de
// slice littérale grâce aux points de suspension.
s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice
// littérale.
fmt.Println(s) // La slice contient [1 2 3 4 5 6 7 8 9]
p, q := learnMemory() // Déclare p, q comme étant des pointeurs de type int.
fmt.Println(*p, *q) // * suit un pointeur. Ceci retourne deux ints.
// Les maps sont des tableaux associatifs de taille dynamique, comme les
// hash ou les types dictionnaires de certains langages.
m := map[string]int{"trois": 3, "quatre": 4}
m["un"] = 1
// Les valeurs inutilisées sont considérées comme des erreurs en Go.
// Un tiret bas permet d'ignorer une valeur inutilisée, évitant une erreur.
_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
// Cependant, son affichage en console est considéré comme une utilisation,
// ce qui ne sera pas considéré comme une erreur à la compilation.
fmt.Println(s, c, a4, s3, d2, m)
learnFlowControl() // De retour dans le flux.
}
// Il est possible, à l'opposé de plusieurs autres langages, de retourner des
// variables par leur nom à partir de fonctions.
// Assigner un nom à un type retourné par une fonction permet de retrouver sa
// valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus.
func learnNamedReturns(x, y int) (z int) {
z = x * y
return // z est implicite, car la variable a été définie précédemment.
}
// La récupération de la mémoire est automatique en Go. Le langage possède des
// pointeurs, mais aucune arithmétique des pointeurs (*(a + b) en C). Vous
// pouvez produire une erreur avec un pointeur nil, mais pas en incrémentant un
// pointeur.
func learnMemory() (p, q *int) {
// Les valeurs retournées p et q auront le type pointeur int.
p = new(int) // Fonction standard "new" alloue la mémoire.
// Le int alloué est initialisé à 0, p n'est plus nil.
s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire.
s[3] = 7 // Assigne l'un des entiers.
r := -2 // Déclare une autre variable locale.
return &s[3], &r // & retourne l'adresse d'un objet.
}
func expensiveComputation() float64 {
return m.Exp(10)
}
func learnFlowControl() {
// Bien que les "if" requièrent des accolades, les parenthèses ne sont pas
// nécessaires pour contenir le test booléen.
if true {
fmt.Println("voilà!")
}
// Le formatage du code est standardisé par la commande shell "go fmt."
if false {
// bing.
} else {
// bang.
}
// Utilisez "switch" au lieu des "if" en chaîne
x := 42.0
switch x {
case 0:
case 1:
case 42:
// Les "case" n'ont pas besoin de "break;".
case 43:
// Non-exécuté.
}
// Comme les "if", les "for" n'utilisent pas de parenthèses.
// Les variables déclarées dans les "for" et les "if" sont locales à leur
// portée.
for x := 0; x < 3; x++ { // ++ est une incrémentation.
fmt.Println("itération ", x)
}
// x == 42 ici.
// "For" est le seul type de boucle en Go, mais possède différentes formes.
for { // Boucle infinie
break // C'est une farce
continue // Non atteint.
}
// Vous pouvez utiliser une "range" pour itérer dans un tableau, une slice, une
// chaîne, une map ou un canal. Les "range" retournent un canal ou deux
// valeurs (tableau, slice, chaîne et map).
for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} {
// pour chaque pair dans une map, affichage de la valeur et clé
fmt.Printf("clé=%s, valeur=%d\n", key, value)
}
// À l'opposé du "for", := dans un "if" signifie la déclaration et
// l'assignation y en premier, et ensuite y > x
if y := expensiveComputation(); y > x {
x = y
}
// Les fonctions littérales sont des fermetures.
xBig := func() bool {
return x > 10000
}
fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x).
x = 1.3e3 // Ceci fait x == 1300
fmt.Println("xBig:", xBig()) // Maintenant false.
// De plus, les fonctions littérales peuvent être définies et appelées
// sur la même ligne, agissant comme argument à cette fonction, tant que:
// a) la fonction littérale est appelée suite à (),
// b) le résultat correspond au type de l'argument.
fmt.Println("Ajoute + multiplie deux nombres : ",
func(a, b int) int {
return (a + b) * 2
}(10, 2)) // Appelle la fonction avec les arguments 10 et 2
// => Ajoute + double deux nombres : 24
// Quand vous en aurez besoin, vous allez l'adorer.
goto love
love:
learnFunctionFactory() // func retournant func correspondant à fun(3)(3).
learnDefer() // Un survol de cette instruction importante.
learnInterfaces() // Incontournable !
}
func learnFunctionFactory() {
// Les deux syntaxes sont identiques, bien que la seconde soit plus pratique.
fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!"))
d := sentenceFactory("été")
fmt.Println(d("Une matinée d'", "agréable!"))
fmt.Println(d("Une soirée d'", "relaxante!"))
}
// Le décorateur est un patron de conception commun dans d'autres langages.
// Il est possible de faire de même en Go avec des fonctions littérales
// acceptant des arguments.
func sentenceFactory(mystring string) func(before, after string) string {
return func(before, after string) string {
return fmt.Sprintf("%s %s %s", before, mystring, after) // nouvelle chaîne
}
}
func learnDefer() (ok bool) {
// Les déclarations différées sont exécutées avant la sortie d'une fonction.
defer fmt.Println("les déclarations différées s'exécutent en ordre LIFO.")
defer fmt.Println("\nCette ligne est affichée en premier parce que")
// Les déclarations différées sont utilisées fréquemment pour fermer un
// fichier, afin que la fonction ferme le fichier en fin d'exécution.
return true
}
// Défini Stringer comme étant une interface avec une méthode, String.
type Stringer interface {
String() string
}
// Défini pair comme étant une structure contenant deux entiers, x et y.
type pair struct {
x, y int
}
// Défini une méthode associée au type pair. Pair implémente maintenant Stringer
func (p pair) String() string { // p s'appelle le "destinataire"
// Sprintf est une autre fonction publique dans le paquet fmt.
// La syntaxe avec point permet de faire référence aux valeurs de p.
return fmt.Sprintf("(%d, %d)", p.x, p.y)
}
func learnInterfaces() {
// La syntaxe avec accolade défini une "structure littérale". Celle-ci
// s'évalue comme étant une structure. La syntaxe := déclare et initialise p
// comme étant une instance.
p := pair{3, 4}
fmt.Println(p.String()) // Appelle la méthode String de p, de type pair.
var i Stringer // Déclare i instance de l'interface Stringer.
i = p // Valide, car pair implémente Stringer.
// Appelle la méthode String de i, de type Stringer. Retourne la même valeur
// que ci-haut.
fmt.Println(i.String())
// Les fonctions dans le paquet fmt appellent la méthode String, demandant
// aux objets d'afficher une représentation de leur structure.
fmt.Println(p) // Affiche la même chose que ci-haut. Println appelle la
// méthode String.
fmt.Println(i) // Affiche la même chose que ci-haut.
learnVariadicParams("apprentissage", "génial", "ici!")
}
// Les fonctions peuvent être définie de façon à accepter un ou plusieurs
// paramètres grâce aux points de suspension, offrant une flexibilité lors de
// son appel.
func learnVariadicParams(myStrings ...interface{}) {
// Itère chaque paramètre dans la range.
// Le tiret bas sert à ignorer l'index retourné du tableau.
for _, param := range myStrings {
fmt.Println("paramètre:", param)
}
// Passe une valeur variadique comme paramètre variadique.
fmt.Println("paramètres:", fmt.Sprintln(myStrings...))
learnErrorHandling()
}
func learnErrorHandling() {
// ", ok" idiome utilisée pour définir si l'opération s'est déroulée avec
// succès ou non
m := map[int]string{3: "trois", 4: "quatre"}
if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map.
fmt.Println("inexistant")
} else {
fmt.Print(x) // x serait la valeur, si elle se trouvait dans la map.
}
// Une erreur ne retourne qu'un "ok", mais également plus d'information
// par rapport à un problème survenu.
if _, err := strconv.Atoi("non-int"); err != nil { // _ discarte la valeur
// retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax'
fmt.Println(err)
}
// Nous réviserons les interfaces un peu plus tard. Pour l'instant,
learnConcurrency()
}
// c est un canal, un objet permettant de communiquer en simultané de façon
// sécurisée.
func inc(i int, c chan int) {
c <- i + 1 // <- est l'opérateur "envoi" quand un canal apparaît à
// gauche.
}
// Nous utiliserons inc pour incrémenter des nombres en même temps.
func learnConcurrency() {
// La fonction "make" utilisée précédemment pour générer un slice. Elle
// alloue et initialise les slices, maps et les canaux.
c := make(chan int)
// Démarrage de trois goroutines simultanées. Les nombres seront incrémentés
// simultanément, peut-être en paralèle si la machine le permet et configurée
// correctement. Les trois utilisent le même canal.
go inc(0, c) // go est une instruction démarrant une nouvelle goroutine.
go inc(10, c)
go inc(-805, c)
// Lis et affiche trois résultats du canal - impossible de savoir dans quel
// ordre !
fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de
// "réception".
cs := make(chan string) // Un autre canal, celui-ci gère des chaînes.
ccs := make(chan chan string) // Un canal de canaux de chaînes.
go func() { c <- 84 }() // Démarre une nouvelle goroutine, pour
// envoyer une valeur.
go func() { cs <- "wordy" }() // De nouveau, pour cs cette fois-ci.
// Select possède une syntaxe similaire au switch, mais chaque cas requiert
// une opération impliquant un canal. Il sélectionne un cas aléatoirement
// prêt à communiquer.
select {
case i := <-c: // La valeur reçue peut être assignée à une variable,
fmt.Printf("c'est un %T", i)
case <-cs: // ou la valeur reçue peut être ignorée.
fmt.Println("c'est une chaîne")
case <-ccs: // Un canal vide, indisponible à la communication.
fmt.Println("ne surviendra pas.")
}
// À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines
// démarrée plus haut a complétée, la seconde restera bloquée.
learnWebProgramming() // Go permet la programmation Web.
}
// Une seule fonction du paquet http démarre un serveur Web.
func learnWebProgramming() {
// Le premier paramètre de ListenAndServe est une adresse TCP à écouter.
// Le second est une interface, de type http.Handler.
go func() {
err := http.ListenAndServe(":8080", pair{})
fmt.Println(err) // n'ignorez pas les erreurs !
}()
requestServer()
}
// Implémente la méthode ServeHTTP de http.Handler à pair, la rendant compatible
// avec les opérations utilisant l'interface http.Handler.
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Répondez à une requête à l'aide de la méthode http.ResponseWriter.
w.Write([]byte("Vous avez appris Go en Y minutes!"))
}
func requestServer() {
resp, err := http.Get("http://localhost:8080")
fmt.Println(err)
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
fmt.Printf("\nLe serveur Web a dit: `%s`", string(body))
}
```
## En savoir plus
La référence Go se trouve sur [le site officiel de Go](http://golang.org/).
Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus.
Une lecture de la documentation du langage est grandement conseillée. C'est
facile à lire et très court (comparé aux autres langages).
Vous pouvez exécuter et modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go.
Sur la liste de lecteur des étudiants de Go se trouve le [code source de la
librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre
le meilleur de la clarté de Go, le style ainsi que ses expressions. Sinon, vous
pouvez cliquer sur le nom d'une fonction dans [la
documentation](http://golang.org/pkg/) et le code source apparaît!
Une autre excellente ressource pour apprendre est [Go par l'exemple](https://gobyexample.com/).

51
haskell.html.markdown
View File

@ -148,12 +148,12 @@ add 1 2 -- 3
-- Guards: an easy way to do branching in functions
fib x
| x < 2 = x
| x < 2 = 1
| otherwise = fib (x - 1) + fib (x - 2)
-- Pattern matching is similar. Here we have given three different
-- definitions for fib. Haskell will automatically call the first
-- function that matches the pattern of the value.
-- function that matches the pattern of the value.
fib 1 = 1
fib 2 = 2
fib x = fib (x - 1) + fib (x - 2)
@ -181,7 +181,7 @@ foldl1 (\acc x -> acc + x) [1..5] -- 15
----------------------------------------------------
-- partial application: if you don't pass in all the arguments to a function,
-- it gets "partially applied". That means it returns a function that takes the
-- it gets "partially applied". That means it returns a function that takes the
-- rest of the arguments.
add a b = a + b
@ -202,19 +202,20 @@ foo = (*5) . (+10)
foo 5 -- 75
-- fixing precedence
-- Haskell has another function called `$`. This changes the precedence
-- so that everything to the left of it gets computed first and then applied
-- to everything on the right. You can use `$` (often in combination with `.`)
-- to get rid of a lot of parentheses:
-- Haskell has another operator called `$`. This operator applies a function
-- to a given parameter. In contrast to standard function application, which
-- has highest possible priority of 10 and is left-associative, the `$` operator
-- has priority of 0 and is right-associative. Such a low priority means that
-- the expression on its right is applied as the parameter to the function on its left.
-- before
(even (fib 7)) -- true
(even (fib 7)) -- false
-- after
even . fib $ 7 -- true
even . fib $ 7 -- false
-- equivalently
even $ fib 7 -- true
even $ fib 7 -- false
----------------------------------------------------
-- 5. Type signatures
@ -319,13 +320,13 @@ Nothing -- of type `Maybe a` for any `a`
-- called. It must return a value of type `IO ()`. For example:
main :: IO ()
main = putStrLn $ "Hello, sky! " ++ (say Blue)
main = putStrLn $ "Hello, sky! " ++ (say Blue)
-- putStrLn has type String -> IO ()
-- It is easiest to do IO if you can implement your program as
-- a function from String to String. The function
-- It is easiest to do IO if you can implement your program as
-- a function from String to String. The function
-- interact :: (String -> String) -> IO ()
-- inputs some text, runs a function on it, and prints out the
-- inputs some text, runs a function on it, and prints out the
-- output.
countLines :: String -> String
@ -339,43 +340,43 @@ main' = interact countLines
-- the `do` notation to chain actions together. For example:
sayHello :: IO ()
sayHello = do
sayHello = do
putStrLn "What is your name?"
name <- getLine -- this gets a line and gives it the name "name"
putStrLn $ "Hello, " ++ name
-- Exercise: write your own version of `interact` that only reads
-- one line of input.
-- The code in `sayHello` will never be executed, however. The only
-- action that ever gets executed is the value of `main`.
-- To run `sayHello` comment out the above definition of `main`
-- action that ever gets executed is the value of `main`.
-- To run `sayHello` comment out the above definition of `main`
-- and replace it with:
-- main = sayHello
-- Let's understand better how the function `getLine` we just
-- Let's understand better how the function `getLine` we just
-- used works. Its type is:
-- getLine :: IO String
-- You can think of a value of type `IO a` as representing a
-- computer program that will generate a value of type `a`
-- computer program that will generate a value of type `a`
-- when executed (in addition to anything else it does). We can
-- store and reuse this value using `<-`. We can also
-- store and reuse this value using `<-`. We can also
-- make our own action of type `IO String`:
action :: IO String
action = do
putStrLn "This is a line. Duh"
input1 <- getLine
input1 <- getLine
input2 <- getLine
-- The type of the `do` statement is that of its last line.
-- `return` is not a keyword, but merely a function
-- `return` is not a keyword, but merely a function
return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
-- We can use this just like we used `getLine`:
main'' = do
putStrLn "I will echo two lines!"
result <- action
result <- action
putStrLn result
putStrLn "This was all, folks!"

33
haxe.html.markdown
View File

@ -3,6 +3,7 @@ language: haxe
filename: LearnHaxe3.hx
contributors:
- ["Justin Donaldson", "https://github.com/jdonaldson/"]
- ["Dan Korostelev", "https://github.com/nadako/"]
---
Haxe is a web-oriented language that provides platform support for C++, C#,
@ -34,16 +35,20 @@ references.
/*
This is your first actual haxe code coming up, it's declaring an empty
package. A package isn't necessary, but it's useful if you want to create a
namespace for your code (e.g. org.module.ClassName).
namespace for your code (e.g. org.yourapp.ClassName).
Omitting package declaration is the same as declaring an empty package.
*/
package; // empty package, no namespace.
/*
Packages define modules for your code. Each module (e.g. org.module) must
be lower case, and should exist as a folder structure containing the class.
Class (and type) names must be capitalized. E.g, the class "org.module.Foo"
should have the folder structure org/module/Foo.hx, as accessible from the
compiler's working directory or class path.
Packages are directories that contain modules. Each module is a .hx file
that contains types defined in a package. Package names (e.g. org.yourapp)
must be lower case while module names are capitalized. A module contain one
or more types whose names are also capitalized.
E.g, the class "org.yourapp.Foo" should have the folder structure org/module/Foo.hx,
as accessible from the compiler's working directory or class path.
If you import code from other files, it must be declared before the rest of
the code. Haxe provides a lot of common default classes to get you started:
@ -53,6 +58,12 @@ import haxe.ds.ArraySort;
// you can import many classes/modules at once with "*"
import haxe.ds.*;
// you can import static fields
import Lambda.array;
// you can also use "*" to import all static fields
import Math.*;
/*
You can also import classes in a special way, enabling them to extend the
functionality of other classes like a "mixin". More on 'using' later.
@ -172,7 +183,8 @@ class LearnHaxe3{
Regexes are also supported, but there's not enough space to go into
much detail.
*/
trace((~/foobar/.match('foo')) + " is the value for (~/foobar/.match('foo')))");
var re = ~/foobar/;
trace(re.match('foo') + " is the value for (~/foobar/.match('foo')))");
/*
Arrays are zero-indexed, dynamic, and mutable. Missing values are
@ -383,11 +395,7 @@ class LearnHaxe3{
*/
// if statements
var k = if (true){
10;
} else {
20;
}
var k = if (true) 10 else 20;
trace("K equals ", k); // outputs 10
@ -628,6 +636,7 @@ enum ComplexEnum{
ComplexEnumEnum(c:ComplexEnum);
}
// Note: The enum above can include *other* enums as well, including itself!
// Note: This is what's called *Algebraic data type* in some other languages.
class ComplexEnumTest{
public static function example(){

12
java.html.markdown
View File

@ -103,15 +103,15 @@ public class LearnJava {
// Arrays
//The array size must be decided upon instantiation
//The following formats work for declaring an array
//<datatype> [] <var name> = new <datatype>[<array size>];
//<datatype>[] <var name> = new <datatype>[<array size>];
//<datatype> <var name>[] = new <datatype>[<array size>];
int [] intArray = new int[10];
String [] stringArray = new String[1];
boolean boolArray [] = new boolean[100];
int[] intArray = new int[10];
String[] stringArray = new String[1];
boolean boolArray[] = new boolean[100];
// Another way to declare & initialize an array
int [] y = {9000, 1000, 1337};
String names [] = {"Bob", "John", "Fred", "Juan Pedro"};
int[] y = {9000, 1000, 1337};
String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
boolean bools[] = new boolean[] {true, false, false};
// Indexing an array - Accessing an element

8
perl6.html.markdown
View File

@ -253,7 +253,9 @@ given "foo bar" {
when $_.chars > 50 { # smart matching anything with True (`$a ~~ True`) is True,
# so you can also put "normal" conditionals.
# This when is equivalent to this `if`:
# if ($_.chars > 50) ~~ True {...}
# if $_ ~~ ($_.chars > 50) {...}
# Which means:
# if $_.chars > 50 {...}
say "Quite a long string !";
}
default { # same as `when *` (using the Whatever Star)
@ -560,7 +562,7 @@ subset VeryBigInteger of Int where * > 500;
multi sub sayit(Int $n) { # note the `multi` keyword here
say "Number: $n";
}
multi sayit(Str $s) } # a multi is a `sub` by default
multi sayit(Str $s) { # a multi is a `sub` by default
say "String: $s";
}
sayit("foo"); # prints "String: foo"
@ -963,7 +965,7 @@ say join ',', gather if False {
# But consider:
constant thrice = gather for ^3 { say take $_ }; # Doesn't print anything
# versus:
constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2 3 4
constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2
# - `lazy` - Defer actual evaluation until value is fetched (forces lazy context)
# Not yet implemented !!

84
pt-br/brainfuck-pt.html.markdown Normal file
View File

@ -0,0 +1,84 @@
---
language: brainfuck
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]
translators:
- ["Suzane Sant Ana", "http://github.com/suuuzi"]
lang: pt-br
---
Brainfuck (em letras minúsculas, eceto no início de frases) é uma linguagem de
programação Turing-completa extremamente simples com apenas 8 comandos.
```
Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
e um ponteiro de dados que aponta para a célula atual.
Existem 8 comandos:
+ : Incrementa o vaor da célula atual em 1.
- : Decrementa o valor da célula atual em 1.
> : Move o ponteiro de dados para a célula seguinte (célula à direita).
< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
, : Lê um único caractere para a célula atual.
[ : Se o valor da célula atual for zero, salta para o ] correspondente.
Caso contrário, passa para a instrução seguinte.
] : Se o valor da célula atual for zero, passa para a instrução seguinte.
Caso contrário, volta para a instrução relativa ao [ correspondente.
[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
Vamos ver alguns exemplos básicos em brainfuck:
++++++ [ > ++++++++++ < - ] > +++++ .
Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
continuando com a instrução seguinte).
Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
, [ > + < - ] > .
Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
célula #2 e imprimimos o valor em ASCII.
Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
o mesmo programa da seguinte maneira:
,[>+<-]>.
Tente descobrir o que este programa faz:
,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
Este programa lê dois números e os multiplica.
Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
#2, incrementando o valor da célula #3. Porém existe um problema, no final do
ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
célula #4 é também incrementado e copiado para a célula #2.
```
E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
seus próprios programas em brainfuck, ou então escrever um interpretador de
brainfuck em outra linguagem. O interpretador é relativamente fácil de se
implementar, mas caso você seja masoquista, tente escrever um interpretador de
brainfuck… em brainfuck.

312
pt-br/git-pt.html.markdown
View File

@ -1,110 +1,119 @@
---
category: tool
tool: git
lang: pt-br
filename: LearnGit.txt
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
translators:
- ["Miguel Araújo", "https://github.com/miguelarauj1o"]
lang: pt-br
filename: learngit-pt.txt
- ["Suzane Sant Ana", "http://github.com/suuuzi"]
---
Git é um sistema de controle de versão distribuído e de gerenciamento de código-fonte.
Git é um sistema distribuido de gestão para código fonte e controle de versões.
Ele faz isso através de uma série de momentos instantâneos de seu projeto, e ele funciona
com esses momentos para lhe fornecer a funcionalidade para a versão e
gerenciar o seu código-fonte.
Funciona através de uma série de registos de estado do projeto e usa esse
registo para permitir funcionalidades de versionamento e gestão de código
fonte.
## Versionando Conceitos
## Conceitos de versionamento
### O que é controle de versão?
### O que é controle de versão
O controle de versão é um sistema que registra alterações em um arquivo ou conjunto
de arquivos, ao longo do tempo.
Controle de versão (*source control*) é um processo de registo de alterações
a um arquivo ou conjunto de arquivos ao longo do tempo.
### Versionamento Centralizado VS Versionamento Distribuído
### Controle de versão: Centralizado VS Distribuído
* Controle de versão centralizado concentra-se na sincronização, controle e backup de arquivos.
* Controle de versão distribuído concentra-se na partilha de mudanças. Toda mudança tem um ID único.
* Sistemas Distribuídos não têm estrutura definida. Você poderia facilmente ter um estilo SVN,
sistema centralizado, com git.
* Controle de versão centralizado foca na sincronização, registo e *backup*
de arquivos.
* Controle de versão distribuído foca em compartilhar alterações. Cada
alteração é associada a um *id* único.
* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema
centralizado ao estilo SVN usando git.
[Informação Adicional](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
### Porque usar o Git?
### Por que usar git?
* Possibilidade de trabalhar offline
* Colaborar com os outros é fácil!
* Ramificação é fácil
* Mesclagem é fácil
* Git é rápido
* Git é flexível.
* Permite trabalhar offline.
* Colaborar com outros é fácil!
* Criar *branches* é fácil!
* Fazer *merge* é fácil!
* Git é rápido.
* Git é flexivel.
## Git - Arquitetura
## Arquitetura Git
### Repositório
Um conjunto de arquivos, diretórios, registros históricos, cometes, e cabeças. Imagine-o
como uma estrutura de dados de código-fonte, com o atributo que cada "elemento" do
código-fonte dá-lhe acesso ao seu histórico de revisão, entre outras coisas.
Um conjunto de arquivos, diretórios, registos históricos, *commits* e
referências. Pode ser descrito como uma estrutura de dados de código fonte
com a particularidade de cada elemento do código fonte permitir acesso ao
histórico das suas alterações, entre outras coisas.
Um repositório git é composto do diretório git. e árvore de trabalho.
Um repositório git é constituido pelo diretório .git e a *working tree*
### Diretório .git (componente do repositório)
O diretório git. contém todas as configurações, registros, galhos, cabeça(HEAD) e muito mais.
[Lista Detalhada](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
O repositório .git contém todas as configurações, *logs*, *branches*,
referências e outros.
### Árvore de trabalho (componente do repositório)
[Lista detalhada (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
Esta é, basicamente, os diretórios e arquivos no seu repositório. Ele é muitas vezes referida
como seu diretório de trabalho.
### *Working Tree* (componente do repositório)
### Índice (componente do diretório .git)
A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto.
O Índice é a área de teste no git. É basicamente uma camada que separa a sua árvore de trabalho
a partir do repositório Git. Isso dá aos desenvolvedores mais poder sobre o que é enviado para o
repositório Git.
### *Index* (componente do diretório .git)
### Comete (commit)
O *Index* é a camada da interface no git. É o elemento que separa
o diretório do projeto do repositório git. Isto permite aos programadores um
maior controle sobre o que é registado no repositório git.
A commit git é um instantâneo de um conjunto de alterações ou manipulações a sua árvore de trabalho.
Por exemplo, se você adicionou 5 imagens, e removeu outros dois, estas mudanças serão contidas
em um commit (ou instantâneo). Esta confirmação pode ser empurrado para outros repositórios, ou não!
### *Commit*
### Ramo (branch)
Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto.
Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações
serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
para outros repositórios ou não!
Um ramo é, essencialmente, um ponteiro que aponta para o último commit que você fez. Como
você se comprometer, este ponteiro irá atualizar automaticamente e apontar para o último commit.
### *Branch*
### Cabeça (HEAD) e cabeça (head) (componente do diretório .git)
Um *branch* é essencialmente uma referência que aponta para o último *commit*
efetuado. Na medida que são feitos novos commits, esta referência é atualizada
automaticamente e passa a apontar para o commit mais recente.
HEAD é um ponteiro que aponta para o ramo atual. Um repositório tem apenas 1 * ativo * HEAD.
head é um ponteiro que aponta para qualquer commit. Um repositório pode ter qualquer número de commits.
### *HEAD* e *head* (componentes do diretório .git)
### Recursos Conceituais
*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem
uma *HEAD* activa.
*head* é uma referência que aponta para qualquer *commit*. Um repositório pode
ter um número indefinido de *heads*
* [Git para Cientistas da Computação](http://eagain.net/articles/git-for-computer-scientists/)
### Recursos conceituais (EN)
* [Git para Cientistas de Computação](http://eagain.net/articles/git-for-computer-scientists/)
* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html)
## Comandos
### init
### *init*
Criar um repositório Git vazio. As configurações do repositório Git, informações armazenadas,
e mais são armazenados em um diretório (pasta) com o nome ". git".
Cria um repositório Git vazio. As definições, informação guardada e outros do
repositório git são guardados em uma pasta chamada ".git".
```bash
$ git init
```
### config
### *config*
Para configurar as definições. Quer seja para o repositório, o próprio sistema, ou
configurações globais.
Permite configurar as definições, sejam as definições do repositório, sistema
ou configurações globais.
```bash
# Impressão e definir algumas variáveis ​​de configuração básica (global)
# Imprime e define algumas variáveis de configuração básicas (global)
$ git config --global user.email
$ git config --global user.name
@ -112,22 +121,21 @@ $ git config --global user.email "MyEmail@Zoho.com"
$ git config --global user.name "My Name"
```
[Saiba mais sobre o git config.](http://git-scm.com/docs/git-config)
[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
### help
Para lhe dar um acesso rápido a um guia extremamente detalhada de cada comando. ou
apenas dar-lhe um rápido lembrete de algumas semânticas.
Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica.
```bash
# Rapidamente verificar os comandos disponíveis
# Ver rapidamente os comandos disponiveis
$ git help
# Confira todos os comandos disponíveis
# Ver todos os comandos disponiveis
$ git help -a
# Ajuda específica de comando - manual do usuário
# git help <command_here>
# Usar o *help* para um comando especifico
# git help <comando_aqui>
$ git help add
$ git help commit
$ git help init
@ -135,85 +143,89 @@ $ git help init
### status
Para mostrar as diferenças entre o arquivo de índice (basicamente o trabalho de
copiar/repo) e a HEAD commit corrente.
Apresenta as diferenças entre o arquivo *index* (a versão corrente
do repositório) e o *commit* da *HEAD* atual.
```bash
# Irá exibir o ramo, os arquivos não monitorados, as alterações e outras diferenças
# Apresenta o *branch*, arquivos não monitorados, alterações e outras
# difereças
$ git status
# Para saber outras "tid bits" sobre git status
# Para aprender mais detalhes sobre git *status*
$ git help status
```
### add
Para adicionar arquivos para a atual árvore/directory/repo trabalho. Se você não
der `git add` nos novos arquivos para o trabalhando árvore/diretório, eles não serão
incluídos em commits!
Adiciona arquivos ao repositório corrente. Se os arquivos novos não forem
adicionados através de `git add` ao repositório, então eles não serão
incluidos nos commits!
```bash
# Adicionar um arquivo no seu diretório de trabalho atual
# adiciona um arquivo no diretório do projeto atual
$ git add HelloWorld.java
# Adicionar um arquivo em um diretório aninhado
# adiciona um arquivo num sub-diretório
$ git add /path/to/file/HelloWorld.c
# Suporte a expressões regulares!
# permite usar expressões regulares!
$ git add ./*.java
```
### branch
Gerenciar seus ramos. Você pode visualizar, editar, criar, apagar ramos usando este comando.
Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este
comando.
```bash
# Lista ramos e controles remotos existentes
# listar *branches* existentes e remotos
$ git branch -a
# Criar um novo ramo
# criar um novo *branch*
$ git branch myNewBranch
# Apagar um ramo
# apagar um *branch*
$ git branch -d myBranch
# Renomear um ramo
# alterar o nome de um *branch*
# git branch -m <oldname> <newname>
$ git branch -m myBranchName myNewBranchName
# Editar a descrição de um ramo
# editar a descrição de um *branch*
$ git branch myBranchName --edit-description
```
### checkout
Atualiza todos os arquivos na árvore de trabalho para corresponder à versão no
índice, ou árvore especificada.
Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
à versão do index ou do *branch* especificado.
```bash
# Finalizar um repo - padrão de ramo mestre
# Checkout de um repositório - por padrão para o branch master
$ git checkout
# Checa um ramo especificado
# Checkout de um branch especifico
$ git checkout branchName
# Criar um novo ramo e mudar para ela, como: "<nome> git branch; git checkout <nome>"
# Cria um novo branch e faz checkout para ele.
# Equivalente a: "git branch <name>; git checkout <name>"
$ git checkout -b newBranch
```
### clone
Clones, ou cópias, de um repositório existente para um novo diretório. Ele também adiciona
filiais remotas de rastreamento para cada ramo no repo clonado, que permite que você empurre
a um ramo remoto.
Clona ou copia um repositório existente para um novo diretório. Também
adiciona *branches* de monitoramento remoto para cada *branch* no repositório
clonado o que permite enviar alterações para um *branch* remoto.
```bash
# Clone learnxinyminutes-docs
# Clona learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
```
### commit
Armazena o conteúdo atual do índice em um novo "commit". Este commit contém
as alterações feitas e uma mensagem criada pelo utilizador.
Guarda o conteudo atual do index num novo *commit*. Este *commit* contém
as alterações feitas e a mensagem criada pelo usuário.
```bash
# commit com uma mensagem
@ -222,170 +234,170 @@ $ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
### diff
Mostra as diferenças entre um arquivo no diretório, o índice de trabalho e commits.
Apresenta as diferenças entre um arquivo no repositório do projeto, *index*
e *commits*
```bash
# Mostrar diferença entre o seu diretório de trabalho e o índice.
# Apresenta a diferença entre o diretório atual e o index
$ git diff
# Mostrar diferenças entre o índice e o commit mais recente.
# Apresenta a diferença entre o index e os commits mais recentes
$ git diff --cached
# Mostrar diferenças entre o seu diretório de trabalho e o commit mais recente.
# Apresenta a diferença entre o diretório atual e o commit mais recente
$ git diff HEAD
```
### grep
Permite procurar rapidamente um repositório.
Permite procurar facilmente num repositório
Configurações opcionais:
```bash
# Obrigado ao Travis Jeffery por isto
# Configure os números de linha a serem mostrados nos resultados de busca grep
# Define a apresentação de números de linha nos resultados do grep
$ git config --global grep.lineNumber true
# Fazer resultados de pesquisa mais legível, incluindo agrupamento
# Agrupa os resultados da pesquisa para facilitar a leitura
$ git config --global alias.g "grep --break --heading --line-number"
```
```bash
# Procure por "variableName" em todos os arquivos java
# Pesquisa por "variableName" em todos os arquivos java
$ git grep 'variableName' -- '*.java'
# Procure por uma linha que contém "arrayListName" e "adicionar" ou "remover"
$ git grep -e 'arrayListName' --and \( -e add -e remove \)
# Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove"
$ git grep -e 'arrayListName' --and \( -e add -e remove \)
```
Google é seu amigo; para mais exemplos
[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
O Google é seu amigo; para mais exemplos:
[Git Grep Ninja (EN)](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
### log
Mostrar commits para o repositório.
Apresenta commits do repositório.
```bash
# Mostrar todos os commits
# Apresenta todos os commits
$ git log
# Mostrar um número X de commits
# Apresenta X commits
$ git log -n 10
# Mostrar somente commits mesclados
# Apresenta apenas commits de merge
$ git log --merges
```
### merge
"Merge" em mudanças de commits externos no branch atual.
"Merge" junta as alterações de commits externos com o *branch* atual.
```bash
# Mesclar o ramo especificado para o atual.
# Junta o branch especificado com o atual
$ git merge branchName
# Gera sempre uma mesclagem commit ao mesclar
# Para gerar sempre um commit ao juntar os branches
$ git merge --no-ff branchName
```
### mv
Renomear ou mover um arquivo
Alterar o nome ou mover um arquivo.
```bash
# Renomear um arquivo
# Alterar o nome de um arquivo
$ git mv HelloWorld.c HelloNewWorld.c
# Mover um arquivo
$ git mv HelloWorld.c ./new/path/HelloWorld.c
# Força renomear ou mover
# "ExistingFile" já existe no diretório, será substituído
# Forçar a alteração de nome ou mudança local
# "existingFile" já existe no directório, será sobrescrito.
$ git mv -f myFile existingFile
```
### pull
Puxa de um repositório e se funde com outro ramo.
Puxa alterações de um repositório e as junta com outro branch
```bash
# Atualize seu repo local, através da fusão de novas mudanças
# A partir da "origem" remoto e ramo "master (mestre)".
# Atualiza o repositório local, juntando as novas alterações
# do repositório remoto 'origin' e branch 'master'
# git pull <remote> <branch>
# git pull => implícito por padrão => git pull origin master
# git pull => aplica a predefinição => git pull origin master
$ git pull origin master
# Mesclar em mudanças de ramo remoto e rebase
# Ramo commita em seu repo local, como: "git pull <remote> <branch>, git rebase <branch>"
# Juntar alterações do branch remote e fazer rebase commits do branch
# no repositório local, como: "git pull <remote> <branch>, git rebase <branch>"
$ git pull origin master --rebase
```
### push
Empurre e mesclar as alterações de uma ramificação para uma remota e ramo.
Enviar e juntar alterações de um branch para o seu branch correspondente
num repositório remoto.
```bash
# Pressione e mesclar as alterações de um repo local para um
# Chamado remoto "origem" e ramo de "mestre".
# Envia e junta as alterações de um repositório local
# para um remoto denominado "origin" no branch "master".
# git push <remote> <branch>
# git push => implícito por padrão => git push origin master
# git push => aplica a predefinição => git push origin master
$ git push origin master
# Para ligar atual filial local com uma filial remota, bandeira add-u:
$ git push -u origin master
# Agora, a qualquer hora que você quer empurrar a partir desse mesmo ramo local, uso de atalho:
$ git push
```
### rebase (CAUTELA)
### rebase (cautela!)
Tire todas as alterações que foram commitadas em um ramo, e reproduzi-las em outro ramo.
* Não rebase commits que você tenha empurrado a um repo público *.
Pega em todas as alterações que foram registadas num branch e volta a
aplicá-las em outro branch.
*Não deve ser feito rebase de commits que foram enviados para um repositório
público*
```bash
# Rebase experimentBranch para mestre
# Faz Rebase de experimentBranch para master
# git rebase <basebranch> <topicbranch>
$ git rebase master experimentBranch
```
[Leitura Adicional.](http://git-scm.com/book/en/Git-Branching-Rebasing)
[Leitura adicional (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing)
### reset (CAUTELA)
### reset (cuidado!)
Repor o atual HEAD de estado especificado. Isto permite-lhe desfazer fusões (merge),
puxa (push), commits, acrescenta (add), e muito mais. É um grande comando, mas também
perigoso se não saber o que se está fazendo.
Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*,
*pulls*, *commits*, *adds* e outros. É um comando muito poderoso mas também
perigoso quando não há certeza do que se está fazendo.
```bash
# Repor a área de teste, para coincidir com o último commit (deixa diretório inalterado)
# Restabelece a camada intermediária de registo para o último
# commit (o directório fica sem alterações)
$ git reset
# Repor a área de teste, para coincidir com o último commit, e substituir diretório trabalhado
# Restabelece a camada intermediária de registo para o último commit, e
# sobrescreve o projeto atual
$ git reset --hard
# Move a ponta ramo atual para o especificado commit (deixa diretório inalterado)
# Todas as alterações ainda existem no diretório.
# Move a head do branch atual para o commit especificado, sem alterar o projeto.
# todas as alterações ainda existem no projeto
$ git reset 31f2bb1
# Move a ponta ramo atual para trás, para o commit especificado
# E faz o jogo dir trabalho (exclui mudanças não commitadas e todos os commits
# Após o commit especificado).
# Inverte a head do branch atual para o commit especificado
# fazendo com que este esteja em sintonia com o diretório do projeto
# Remove alterações não registadas e todos os commits após o commit especificado
$ git reset --hard 31f2bb1
```
### rm
O oposto do git add, git rm remove arquivos da atual árvore de trabalho.
O oposto de git add, git rm remove arquivos do branch atual.
```bash
# remove HelloWorld.c
$ git rm HelloWorld.c
# Remove um arquivo de um diretório aninhado
# Remove um arquivo de um sub-directório
$ git rm /pather/to/the/file/HelloWorld.c
```
# # Mais informações
## Informação complementar (EN)
* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
@ -398,5 +410,3 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/)
* [Git - guia prático](http://rogerdudler.github.io/git-guide/index.pt_BR.html)

13
pt-pt/git-pt.html.markdown
View File

@ -74,8 +74,7 @@ maior controlo sobre o que é registado no repositório git.
### *Commit*
Um *commit** de git é um registo de um cojunto de alterações ou manipulações
no nos ficheiros do projecto.
Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos ficheiros do projecto.
Por exemplo, ao adicionar cinco ficheiros e remover outros 2, estas alterações
serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
para outros repositórios ou não!
@ -83,7 +82,7 @@ para outros repositórios ou não!
### *Branch*
Um *branch* é essencialmente uma referência que aponta para o último *commit*
efetuado. à medida que são feitos novos commits, esta referência é atualizada
efetuado. À medida que são feitos novos commits, esta referência é atualizada
automaticamente e passa a apontar para o commit mais recente.
### *HEAD* e *head* (componentes do directório .git)
@ -115,7 +114,7 @@ Permite configurar as definições, sejam as definições do repositório, siste
ou configurações globais.
```bash
# Imprime & Define Algumas Variáveis de Configuração Básicas (Global)
# Imprime e define algumas variáveis de configuração básicas (global)
$ git config --global user.email
$ git config --global user.name
@ -123,7 +122,7 @@ $ git config --global user.email "MyEmail@Zoho.com"
$ git config --global user.name "My Name"
```
[Aprenda Mais Sobre git config. (EN)](http://git-scm.com/docs/git-config)
[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
### help
@ -166,7 +165,7 @@ adicionados através de `git add` ao repositório, então eles não serão
incluidos nos commits!
```bash
# adiciona um ficheiro no directório do project atual
# adiciona um ficheiro no directório do projecto atual
$ git add HelloWorld.java
# adiciona um ficheiro num sub-directório
@ -371,7 +370,7 @@ Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*,
perigoso se não há certeza quanto ao que se está a fazer.
```bash
# Restabelece a camada intermediária dr registo para o último
# Restabelece a camada intermediária de registo para o último
# commit (o directório fica sem alterações)
$ git reset

2
python.html.markdown
View File

@ -14,7 +14,7 @@ executable pseudocode.
Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
Note: This article applies to Python 2.7 specifically, but should be applicable
to Python 2.x. For Python 3.x, take a look at the Python 3 tutorial.
to Python 2.x. For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
```python

12
python3.html.markdown
View File

@ -13,7 +13,7 @@ executable pseudocode.
Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
Note: This article applies to Python 3 specifically. Check out the other tutorial if you want to learn the old Python 2.7
Note: This article applies to Python 3 specifically. Check out [here](http://learnxinyminutes.com/docs/python/) if you want to learn the old Python 2.7
```python
@ -276,7 +276,7 @@ empty_set = set()
# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
some_set = {1, 1, 2, 2, 3, 4} # some_set is now {1, 2, 3, 4}
#Can set new variables to a set
# Can set new variables to a set
filled_set = some_set
# Add one more item to the set
@ -394,7 +394,6 @@ our_iterator.__next__() # Raises StopIteration
list(filled_dict.keys()) #=> Returns ["one", "two", "three"]
####################################################
## 4. Functions
####################################################
@ -410,7 +409,6 @@ add(5, 6) # => prints out "x is 5 and y is 6" and returns 11
# Another way to call functions is with keyword arguments
add(y=6, x=5) # Keyword arguments can arrive in any order.
# You can define functions that take a variable number of
# positional arguments
def varargs(*args):
@ -418,7 +416,6 @@ def varargs(*args):
varargs(1, 2, 3) # => (1, 2, 3)
# You can define functions that take a variable number of
# keyword arguments, as well
def keyword_args(**kwargs):
@ -501,7 +498,9 @@ class Human(object):
# Basic initializer, this is called when this class is instantiated.
# Note that the double leading and trailing underscores denote objects
# or attributes that are used by python but that live in user-controlled
# namespaces. You should not invent such names on your own.
# namespaces. Methods(or objects or attributes) like: __init__, __str__,
# __repr__ etc. are called magic methods (or sometimes called dunder methods)
# You should not invent such names on your own.
def __init__(self, name):
# Assign the argument to the instance's name attribute
self.name = name
@ -636,6 +635,7 @@ print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :(
* [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)
### Dead Tree

4
ru-ru/javascript-ru.html.markdown
View File

@ -22,8 +22,8 @@ Google Chrome, становится все более популярной.
```js
// Си-подобные комментарии. Однострочные комментарии начинаются с двух символов слэш,
/* а многострочные комментарии начинаются с звёздочка-слэш
и заканчиваются символами слэш-звёздочка */
/* а многострочные комментарии начинаются с последовательности слэш-звёздочка
и заканчиваются символами звёздочка-слэш */
// Инструкции могут заканчиваться точкой с запятой ;
doStuff();

2
ru-ru/python3-ru.html.markdown
View File

@ -593,7 +593,7 @@ def double_numbers(iterable):
range_ = range(1, 900000000)
# Будет удваивать все числа, пока результат не превысит 30
for i in double_numbers(xrange_):
for i in double_numbers(range_):
print(i)
if i >= 30:
break

8
ruby.html.markdown
View File

@ -11,6 +11,7 @@ contributors:
- ["Ariel Krakowski", "http://www.learneroo.com"]
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
- ["Levi Bostian", "https://github.com/levibostian"]
- ["Rahil Momin", "https://github.com/iamrahil"]
---
@ -169,6 +170,9 @@ array[1..3] #=> [2, 3, 4]
# Add to an array like this
array << 6 #=> [1, 2, 3, 4, 5, 6]
# Check if an item exists in an array
array.include?(1) #=> true
# Hashes are Ruby's primary dictionary with keys/value pairs.
# Hashes are denoted with curly braces:
hash = { 'color' => 'green', 'number' => 5 }
@ -188,6 +192,10 @@ new_hash = { defcon: 3, action: true }
new_hash.keys #=> [:defcon, :action]
# Check existence of keys and values in hash
new_hash.has_key?(:defcon) #=> true
new_hash.has_value?(3) #=> true
# Tip: Both Arrays and Hashes are Enumerable
# They share a lot of useful methods such as each, map, count, and more

251
tr-tr/markdown-tr.html.markdown Normal file
View File

@ -0,0 +1,251 @@
---
language: markdown
contributors:
- ["Dan Turkel", "http://danturkel.com/"]
translators:
- ["Eray AYDIN", "http://erayaydin.me/"]
lang: tr-tr
filename: markdown-tr.md
---
Markdown, 2004 yılında John Gruber tarafından oluşturuldu. Asıl amacı kolay okuma ve yazmayı sağlamakla beraber kolayca HTML (artık bir çok diğer formatlara) dönüşüm sağlamaktır.
```markdown
<!-- Markdown, HTML'i kapsar, yani her HTML dosyası geçerli bir Markdown dosyasıdır, bu demektir
ki Markdown içerisinde HTML etiketleri kullanabiliriz, örneğin bu yorum elementi, ve
markdown işleyicisinde etki etmezler. Fakat, markdown dosyası içerisinde HTML elementi oluşturursanız,
bu elementin içeriğinde markdown söz dizimlerini kullanamazsınız. -->
<!-- Markdown ayrıca işleyiciden işleyiciye farklılık gösterebilir. Bu rehberde
evrensel özelliklere uygun anlatımlar olacaktır. Bir çok işleyici bu rehberdeki
anlatımları destekler -->
<!-- Başlıklar -->
<!-- Kolayca <h1>'den <h6>'ya HTML etiketleri oluşturabilirsiniz.
Kare (#) sayısı bu elementin numarasını belirleyecek ve devamında getirdiğiniz
yazı bu elementin içeriği olacaktır
-->
# Bu bir <h1>
## Bu bir <h2>
### Bu bir <h3>
#### Bu bir <h4>
##### Bu bir <h5>
###### Bu bir <h6>
<!-- Markdown ayrıca h1 ve h2 için 2 alternatif yol daha taşır -->
Bu bir h1
=========
Bu bir h2
---------
<!-- Basit yazı stilleri -->
<!-- Markdown ile yazılar kolayca italik ve kalın belirtilebilir -->
*Bu yazı italik.*
_Bu yazı da italik._
**Bu yazı kalın.**
__Bu yazı da kalın.__
***Bu yazı hem kalın hem italik.***
**_Bu da öyle!_**
*__Hatta bu bile!__*
<!-- Github Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
~~Bu yazı üstü çizili olarak gözükecek.~~
<!-- Paragraflar bir veya daha fazla boş satırla ayrılır. -->
Bu bir paragraf. Paragrafın içeriğine devam ediyorum, eğlenceli değil mi?
Şimdi 2. paragrafıma geçtim.
Hala 2. paragraftayım, çünkü boş bir satır bırakmadım.
Bu da 3. paragrafım!
<!-- HTML'de her satır için <br /> etiketi kullanmak ister misiniz, Bir
paragrafı bitirdikten sonra 2 veya daha fazla boşluk bırakın ve yeni paragrafa
başlayın, bu bir <br /> etiketi sayılacaktır -->
Bu yazının sonunda 2 boşluk var (bu satırı seçerek kontrol edebilirsiniz).
Bir üst satırda <br /> etiketi var!
<!-- Blok yazılarının yapımı oldukça kolay, (>) karakteri ile yapabilirsiniz -->
> Bu bir blok etiketi. Satırlara ayırmak için
> her satırın başında `>` karakter yerleştirmeli veya tek satırda bütün içeriği yazabilirsiniz.
> Satır `>` karakteri ile başladığı sürece sorun yok.
> Ayrıca alt alta da blok elementi açabilirsiniz
>> iç içe yani
> düzgün değil mi ?
<!-- Listeler -->
<!-- Numarasız listeler için yıldız, artı, veya tire kullanabilirsiniz -->
* Nesne
* Nesne
* Bir başka nesne
veya
+ Nesne
+ Nesne
+ Bir başka nesne
veya
- Nesne
- Nesne
- Son bir nesne
<!-- Numaralı liste için başına sıralı bir şekilde sayı eklemeniz yeterli -->
1. İlk nesne
2. İkinci nesne
3. Üçüncü nesne
<!-- İsterseniz sıralı bir şekilde yazmak zorunda değilsiniz, markdown
biçimlendirirken sizin için sıralayacaktır, fakat bunu önermiyorum. Markdown dosyasının
düzgün gözükmesi için önerilen metodu uygulamanızı tavsiye ederim -->
1. İlk nesne
1. İkinci nesne
1. Üçüncü nesne
<!-- (Bunun çıktısı ile, sıralı olarak yazdığımız örneğin çıktısı aynı olacaktır) -->
<!-- Ayrıca alt alta liste oluşturabilirsiniz -->
1. İlk nesne
2. İkinci nesne
3. Üçüncü nesne
* Alt nesne
* Alt nesne
4. Dördüncü nesne
<!-- Ayrıca görev listeleri de bulunmakta. HTML seçim kutusu(checkbox) oluşturacaktır. -->
Kutunun içerisinde `x` yoksa eğer seçim kutusu boş olacaktır.
- [ ] Yapılacak ilk görev.
- [ ] Yapılması gereken bir başka görev
Aşağıdaki seçim kutusu ise içi dolu olacaktır.
- [x] Bu görev başarıyla yapıldı
<!-- Kod blokları -->
<!-- Kod bloklarını(<code> elementi) belirtmek için 4 adet boşluk veya bir
tab karakterini kullanabilirsiniz -->
Bu bir kod
öyle mi?
<!-- Ayrıca kod içerisinde girinti kullanmak istiyorsanız tekrar `tab` veya `4 boşluk`
kullanabilirsiniz -->
my_array.each do |item|
puts item
end
<!-- Yazı içerisinde kod belirtmek için sorgu tırnağı (`) kullanabilirsiniz -->
Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor!
<!-- Github Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
\`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! -->
def foobar
puts "Hello world!"
end
\`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` -->
<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, Github da
``` işaretinden sonra belirttiğiniz yazılım diline göre gerekli
syntax aydınlatmaları uygulanacaktır -->
<!-- Düz çizgi (<hr />) -->
<!-- Düz çizgiler 3 veya daha fazla yıldız/çizgi ile yapılabilir. Boşluklar önemsiz. -->
***
---
- - -
****************
<!-- Linkler -->
<!-- Markdown'daki en güzel şeylerden biri kolayca link oluşturmaktır.
Linkte göstermek istediğiniz yazıyı [] içerisine yerleştirin ve sonuna parantezler içerisinde ()
gideceği adresi belirtin -->
[Bana tıkla!](http://test.com)
<!-- Ayrıca linke `title` özelliği eklemek için tırnakları kullanabilirsiniz -->
[Bana tıkla!](http://test.com "Test.com'a gider")
<!-- Bağıl yollar da çalışıyor. -->
[Müzik dinle](/muzik/).
<!-- Markdown ayrıca referans linklerini de destekler -->
[Bu linke tıklayarak][link1] daha detaylı bilgi alabilirsiniz!
[Ayrıca bu linki de inceleyin][foobar] tabi istiyorsanız.
[link1]: http://test.com/ "harika!"
[foobar]: http://foobar.biz/ "okey!"
<!--Başlık ayrıca tek tırnak veya parantez içinde olabilir, veya direk yazılabilir.
Referans döküman içerisindeki herhangi bir yer olabilir ve referans IDsi
benzersiz olduğu sürece sorunsuz çalışacaktır. -->
<!-- Ayrıca "dolaylı adlandırma" bulunmaktadır, "dolaylı adlandırma", linkin yazısının
aynı zamanda onun idsi olmasıdır -->
[Bu][] bir link.
[bu]: http://bubirlink.com
<!-- Fakat bu çok tercih edilen bir yöntem değil. -->
<!-- Resimler -->
<!-- Resimler aslında linklere çok benziyor fakat başında ünlem bulunuyor! -->
![Bu alt etiketine gelecek içerik](http://imgur.com/resmim.jpg "Bu da isteğe bağlı olan bir başlık")
<!-- Referanslar resimler için de geçerli -->
![Bu alt etiketi.][resmim]
[resmim]: bagil/linkler/de/calisiyor.jpg "Başlık isterseniz buraya girebilirsiniz"
<!-- Çeşitli -->
<!-- Oto-linkler -->
<http://testwebsite.com/> ile
[http://testwebsite.com/](http://testwebsite.com) aynı şeyler
<!-- Oto-linkler epostaları da destekler -->
<foo@bar.com>
<!-- Kaçış karakterleri -->
Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmamasını istiyorum,
bunun için, şu şekilde: \*bu yazı italik değil, yıldızlar arasında\*.
<!-- Tablolar -->
<!-- Tablolar sadece Github Flavored Markdown'da destekleniyor ve açıkçası
performansı çok yoruyorlar, fakat illa ki kullanmak isterseniz: -->
| Sütun1 | Sütun 2 | Sütün 3 |
| :----------- | :------: | ------------: |
| Sola dayalı | Ortalı | Sağa dayalı |
| test | test | test |
<!-- ayrıca, bunun aynısı -->
Sütun 1 | Sütun 2 | Sütun 3
:-- | :-: | --:
Çok çirkin göözüküyor | değil | mi?
<!-- Bitiş! -->
```
Daha detaylı bilgi için, John Gruber'in resmi söz dizimi yazısını [buradan](http://daringfireball.net/projects/markdown/syntax) veya Adam Pritchard'ın mükemmel hatırlatma kağıdını [buradan](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) inceleyebilirsiniz.

635
tr-tr/python3-tr.html.markdown Normal file
View File

@ -0,0 +1,635 @@
---
language: python3
contributors:
- ["Louie Dinh", "http://pythonpracticeprojects.com"]
- ["Steven Basart", "http://github.com/xksteven"]
- ["Andre Polykanine", "https://github.com/Oire"]
- ["Andre Polykanine", "https://github.com/Oire"]
translators:
- ["Eray AYDIN", "http://erayaydin.me/"]
lang: tr-tr
filename: learnpython3-tr.py
---
Python,90ların başlarında Guido Van Rossum tarafından oluşturulmuştur. En popüler olan dillerden biridir. Beni Python'a aşık eden sebep onun syntax beraklığı. Çok basit bir çalıştırılabilir söz koddur.
Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [burayı](http://learnxinyminutes.com/docs/python/) kontrol edebilirsiniz.
```python
# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır.
""" Çok satırlı olmasını istediğiniz yorumlar
üç adet tırnak(") işareti ile
yapılmaktadır
"""
####################################################
## 1. Temel Veri Türleri ve Operatörler
####################################################
# Sayılar
3 # => 3
# Tahmin edebileceğiniz gibi matematik
1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
# Bölme işlemi varsayılan olarak onluk döndürür
35 / 5 # => 7.0
# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar
5 // 3 # => 1
5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0
# Onluk kullanırsanız, sonuç da onluk olur
3 * 2.0 # => 6.0
# Kalan operatörü
7 % 3 # => 1
# Üs (2 üzeri 4)
2**4 # => 16
# Parantez ile önceliği değiştirebilirsiniz
(1 + 3) * 2 # => 8
# Boolean(Doğru-Yanlış) değerleri standart
True
False
# 'değil' ile terse çevirme
not True # => False
not False # => True
# Boolean Operatörleri
# "and" ve "or" büyük küçük harf duyarlıdır
True and False #=> False
False or True #=> True
# Bool operatörleri ile sayı kullanımı
0 and 2 #=> 0
-5 or 0 #=> -5
0 == False #=> True
2 == True #=> False
1 == True #=> True
# Eşitlik kontrolü ==
1 == 1 # => True
2 == 1 # => False
# Eşitsizlik Kontrolü !=
1 != 1 # => False
2 != 1 # => True
# Diğer karşılaştırmalar
1 < 10 # => True
1 > 10 # => False
2 <= 2 # => True
2 >= 2 # => True
# Zincirleme şeklinde karşılaştırma da yapabilirsiniz!
1 < 2 < 3 # => True
2 < 3 < 2 # => False
# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir
"Bu bir yazı."
'Bu da bir yazı.'
# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem.
"Merhaba " + "dünya!" # => "Merhaba dünya!"
# Bir yazı(string) karakter listesi gibi işlenebilir
"Bu bir yazı"[0] # => 'B'
# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde:
"{} da ayrıca {}".format("yazılar", "işlenebilir")
# Biçimlendirme işleminde aynı argümanı da birden fazla kullanabilirsiniz.
"{0} çeviktir, {0} hızlıdır, {0} , {1} üzerinden atlayabilir".format("Ahmet", "şeker çubuğu")
#=> "Ahmet çeviktir, Ahmet hızlıdır, Ahmet , şeker çubuğu üzerinden atlayabilir"
# Argümanın sırasını saymak istemiyorsanız, anahtar kelime kullanabilirsiniz.
"{isim} yemek olarak {yemek} istiyor".format(isim="Ahmet", yemek="patates") #=> "Ahmet yemek olarak patates istiyor"
# Eğer Python 3 kodunuz ayrıca Python 2.5 ve üstünde çalışmasını istiyorsanız,
# eski stil formatlamayı kullanabilirsiniz:
"%s bu %s yolla da %s" % ("yazılar", "eski", "biçimlendirilebilir")
# Hiçbir şey(none) da bir objedir
None # => None
# Bir değerin none ile eşitlik kontrolü için "==" sembolünü kullanmayın
# Bunun yerine "is" kullanın. Obje türünün eşitliğini kontrol edecektir.
"vb" is None # => False
None is None # => True
# None, 0, ve boş yazılar/listeler/sözlükler hepsi False değeri döndürü.
# Diğer veriler ise True değeri döndürür
bool(0) # => False
bool("") # => False
bool([]) #=> False
bool({}) #=> False
####################################################
## 2. Değişkenler ve Koleksiyonlar
####################################################
# Python bir yazdırma fonksiyonuna sahip
print("Ben Python. Tanıştığıma memnun oldum!")
# Değişkenlere veri atamak için önce değişkeni oluşturmanıza gerek yok.
# Düzenli bir değişken için hepsi_kucuk_ve_alt_cizgi_ile_ayirin
bir_degisken = 5
bir_degisken # => 5
# Önceden tanımlanmamış değişkene erişmek hata oluşturacaktır.
# Kontrol akışları başlığından hata kontrolünü öğrenebilirsiniz.
bir_bilinmeyen_degisken # NameError hatası oluşturur
# Listeler ile sıralamaları tutabilirsiniz
li = []
# Önceden doldurulmuş listeler ile başlayabilirsiniz
diger_li = [4, 5, 6]
# 'append' ile listenin sonuna ekleme yapabilirsiniz
li.append(1) # li artık [1] oldu
li.append(2) # li artık [1, 2] oldu
li.append(4) # li artık [1, 2, 4] oldu
li.append(3) # li artık [1, 2, 4, 3] oldu
# 'pop' ile listenin son elementini kaldırabilirsiniz
li.pop() # => 3 ve li artık [1, 2, 4]
# Çıkarttığımız tekrardan ekleyelim
li.append(3) # li yeniden [1, 2, 4, 3] oldu.
# Dizi gibi listeye erişim sağlayın
li[0] # => 1
# Son elemente bakın
li[-1] # => 3
# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur
li[4] # IndexError hatası oluşturur
# Bir kısmını almak isterseniz.
li[1:3] # => [2, 4]
# Başlangıç belirtmezseniz
li[2:] # => [4, 3]
# Sonu belirtmesseniz
li[:3] # => [1, 2, 4]
# Her ikişer objeyi seçme
li[::2] # =>[1, 4]
# Listeyi tersten almak
li[::-1] # => [3, 4, 2, 1]
# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz
# li[baslangic:son:adim]
# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz
del li[2] # li artık [1, 2, 3] oldu
# Listelerde de ekleme yapabilirsiniz
# Not: değerler üzerinde değişiklik yapılmaz.
li + diger_li # => [1, 2, 3, 4, 5, 6]
# Listeleri birbirine bağlamak için "extend()" kullanılabilir
li.extend(diger_li) # li artık [1, 2, 3, 4, 5, 6] oldu
# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir
1 in li # => True
# Uzunluğu öğrenmek için "len()" kullanılabilir
len(li) # => 6
# Tüpler listeler gibidir fakat değiştirilemez.
tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # TypeError hatası oluşturur
# Diğer liste işlemlerini tüplerde de uygulayabilirsiniz
len(tup) # => 3
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
tup[:2] # => (1, 2)
2 in tup # => True
# Tüpleri(veya listeleri) değişkenlere açabilirsiniz
a, b, c = (1, 2, 3) # 'a' artık 1, 'b' artık 2 ve 'c' artık 3
# Eğer parantez kullanmazsanız varsayılan oalrak tüpler oluşturulur
d, e, f = 4, 5, 6
# 2 değeri birbirine değiştirmek bu kadar kolay
e, d = d, e # 'd' artık 5 ve 'e' artık 4
# Sözlükler anahtar kodlarla verileri tutar
bos_sozl = {}
# Önceden doldurulmuş sözlük oluşturma
dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
# Değere bakmak için [] kullanalım
dolu_sozl["bir"] # => 1
# Bütün anahtarları almak için "keys()" kullanılabilir.
# Listelemek için list() kullanacağınız çünkü dönen değerin işlenmesi gerekiyor. Bu konuya daha sonra değineceğiz.
# Not - Sözlük anahtarlarının sıralaması kesin değildir.
# Beklediğiniz çıktı sizinkiyle tam uyuşmuyor olabilir.
list(dolu_sozl.keys()) # => ["uc", "iki", "bir"]
# Tüm değerleri almak için "values()" kullanacağız. Dönen değeri biçimlendirmek için de list() kullanmamız gerekiyor
# Not - Sıralama değişebilir.
list(dolu_sozl.values()) # => [3, 2, 1]
# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz
"bir" in dolu_sozl # => True
1 in dolu_sozl # => False
# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır.
dolu_sozl["dort"] # KeyError hatası oluşturur
# "get()" metodu ile değeri almaya çalışırsanız KeyError sorunundan kurtulursunuz
dolu_sozl.get("bir") # => 1
dolu_sozl.get("dort") # => None
# "get" metoduna parametre belirterek değerin olmaması durumunda varsayılan bir değer döndürebilirsiniz.
dolu_sozl.get("bir", 4) # => 1
dolu_sozl.get("dort", 4) # => 4
# "setdefault()" metodu sözlükte, belirttiğiniz anahtarın [olmaması] durumunda varsayılan bir değer atayacaktır
dolu_sozl.setdefault("bes", 5) # dolu_sozl["bes"] artık 5 değerine sahip
dolu_sozl.setdefault("bes", 6) # dolu_sozl["bes"] değişmedi, hala 5 değerine sahip
# Sözlüğe ekleme
dolu_sozl.update({"dort":4}) #=> {"bir": 1, "iki": 2, "uc": 3, "dort": 4}
#dolu_sozl["dort"] = 4 #sözlüğe eklemenin bir diğer yolu
# Sözlükten anahtar silmek için 'del' kullanılabilir
del dolu_sozl["bir"] # "bir" anahtarını dolu sözlükten silecektir
# Setler ... set işte :D
bos_set = set()
# Seti bir veri listesi ile de oluşturabilirsiniz. Evet, biraz sözlük gibi duruyor. Üzgünüm.
bir_set = {1, 1, 2, 2, 3, 4} # bir_set artık {1, 2, 3, 4}
# Sete yeni setler ekleyebilirsiniz
dolu_set = bir_set
# Sete bir diğer öğe ekleme
dolu_set.add(5) # dolu_set artık {1, 2, 3, 4, 5} oldu
# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz
diger_set = {3, 4, 5, 6}
dolu_set & diger_set # => {3, 4, 5}
# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz
dolu_set | diger_set # => {1, 2, 3, 4, 5, 6}
# Farklılıkları almak için "-" kullanabilirsiniz
{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir
2 in dolu_set # => True
10 in dolu_set # => False
####################################################
## 3. Kontrol Akışları ve Temel Soyutlandırma
####################################################
# Bir değişken oluşturalım
bir_degisken = 5
# Burada bir "if" ifadesi var. Girinti(boşluk,tab) python için önemlidir!
# çıktı olarak "bir_degisken 10 dan küçük" yazar
if bir_degisken > 10:
print("bir_degisken 10 dan büyük")
elif bir_degisken < 10: # Bu 'elif' ifadesi zorunlu değildir.
print("bir_degisken 10 dan küçük")
else: # Bu ifade de zorunlu değil.
print("bir_degisken değeri 10")
"""
Döngülerle lsiteleri döngüye alabilirsiniz
çıktı:
köpek bir memeli hayvandır
kedi bir memeli hayvandır
fare bir memeli hayvandır
"""
for hayvan in ["köpek", "kedi, "fare"]:
# format ile kolayca yazıyı biçimlendirelim
print("{} bir memeli hayvandır".format(hayvan))
"""
"range(sayi)" bir sayı listesi döndür
0'dan belirttiğiniz sayıyıa kadar
çıktı:
0
1
2
3
"""
for i in range(4):
print(i)
"""
'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir.
çıktı:
0
1
2
3
"""
x = 0
while x < 4:
print(x)
x += 1 # Uzun hali x = x + 1
# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz
try:
# Bir hata oluşturmak için "raise" kullanabilirsiniz
raise IndexError("Bu bir index hatası")
except IndexError as e:
pass # Önemsiz, devam et.
except (TypeError, NameError):
pass # Çoklu bir şekilde hataları kontrol edebilirsiniz, tabi gerekirse.
else: # İsteğe bağlı bir kısım. Eğer hiçbir hata kontrol mekanizması desteklemiyorsa bu blok çalışacaktır
print("Her şey iyi!") # IndexError, TypeError ve NameError harici bir hatada bu blok çalıştı
# Temel Soyutlandırma, bir objenin işlenmiş halidir.
# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi.
dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
temel_soyut = dolu_sozl.keys()
print(temel_soyut) #=> range(1,10). Bu obje temel soyutlandırma arayüzü ile oluşturuldu
# Temel Soyutlandırılmış objeyi döngüye sokabiliriz.
for i in temel_soyut:
print(i) # Çıktısı: bir, iki, uc
# Fakat, elementin anahtarına değerine.
temel_soyut[1] # TypeError hatası!
# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır.
iterator = iter(temel_soyut)
# 'iterator' o obje üzerinde yaptığımız değişiklikleri hatırlayacaktır
# Bir sonraki objeyi almak için __next__ fonksiyonunu kullanabilirsiniz.
iterator.__next__() #=> "bir"
# Bir önceki __next__ fonksiyonumuzu hatırlayıp bir sonraki kullanımda bu sefer ondan bir sonraki objeyi döndürecektir
iterator.__next__() #=> "iki"
iterator.__next__() #=> "uc"
# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır.
iterator.__next__() # StopIteration hatası
# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz.
list(dolu_sozl.keys()) #=> Returns ["bir", "iki", "uc"]
####################################################
## 4. Fonksiyonlar
####################################################
# "def" ile yeni fonksiyonlar oluşturabilirsiniz
def topla(x, y):
print("x = {} ve y = {}".format(x, y))
return x + y # Değer döndürmek için 'return' kullanmalısınız
# Fonksiyonu parametleri ile çağırıyoruz
topla(5, 6) # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür
# Bir diğer fonksiyon çağırma yöntemi de anahtar değerleri ile belirtmek
topla(y=6, x=5) # Anahtar değeri belirttiğiniz için parametre sıralaması önemsiz.
# Sınırsız sayıda argüman da alabilirsiniz
def argumanlar(*argumanlar):
return argumanlar
argumanlar(1, 2, 3) # => (1, 2, 3)
# Parametrelerin anahtar değerlerini almak isterseniz
def anahtar_par(**anahtarlar):
return anahtar
# Çalıştırdığımızda
anahtar_par(anah1="deg1", anah2="deg2") # => {"anah1": "deg1", "anah2": "deg2"}
# İsterseniz, bu ikisini birden kullanabilirsiniz
def tum_argumanlar(*argumanlar, **anahtarla):
print(argumanlar)
print(anahtarla)
"""
tum_argumanlar(1, 2, a=3, b=4) çıktı:
(1, 2)
{"a": 3, "b": 4}
"""
# Fonksiyonu çağırırken de aynısını kullanabilirsiniz
argumanlar = (1, 2, 3, 4)
anahtarla = {"a": 3, "b": 4}
tum_argumanlar(*argumanlar) # = foo(1, 2, 3, 4)
tum_argumanlar(**anahtarla) # = foo(a=3, b=4)
tum_argumanlar(*argumanlar, **anahtarla) # = foo(1, 2, 3, 4, a=3, b=4)
# Fonksiyonlarda kullanacağımız bir değişken oluşturalım
x = 5
def belirleX(sayi):
# Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil
x = sayi # => 43
print (x) # => 43
def globalBelirleX(sayi):
global x
print (x) # => 5
x = sayi # global olan x değişkeni artık 6
print (x) # => 6
belirleX(43)
globalBelirleX(6)
# Sınıf fonksiyonları oluşturma
def toplama_olustur(x):
def topla(y):
return x + y
return topla
ekle_10 = toplama_olustur(10)
ekle_10(3) # => 13
# Bilinmeyen fonksiyon
(lambda x: x > 2)(3) # => True
# TODO - Fix for iterables
# Belirli sayıdan yükseğini alma fonksiyonu
map(ekle_10, [1, 2, 3]) # => [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
# Filtreleme işlemi için liste comprehensions da kullanabiliriz
[ekle_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. Sınıflar
####################################################
# Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
class Insan(obje):
# Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
tur = "H. sapiens"
# Basit başlatıcı, Sınıf çağrıldığında tetiklenecektir.
# Dikkat edin, iki adet alt çizgi(_) bulunmakta. Bunlar
# python tarafından tanımlanan isimlerdir.
# Kendinize ait bir fonksiyon oluştururken __fonksiyon__ kullanmayınız!
def __init__(self, isim):
# Parametreyi sınıfın değerine atayalım
self.isim = isim
# Bir metot. Bütün metotlar ilk parametre olarak "self "alır.
def soyle(self, mesaj):
return "{isim}: {mesaj}".format(isim=self.name, mesaj=mesaj)
# Bir sınıf metotu bütün nesnelere paylaştırılır
# İlk parametre olarak sınıf alırlar
@classmethod
def getir_tur(snf):
return snf.tur
# Bir statik metot, sınıf ve nesnesiz çağrılır
@staticmethod
def grunt():
return "*grunt*"
# Sınıfı çağıralım
i = Insan(isim="Ahmet")
print(i.soyle("merhaba")) # çıktı "Ahmet: merhaba"
j = Insan("Ali")
print(j.soyle("selam")) # çıktı "Ali: selam"
# Sınıf metodumuzu çağıraim
i.getir_tur() # => "H. sapiens"
# Paylaşılan değeri değiştirelim
Insan.tur = "H. neanderthalensis"
i.getir_tur() # => "H. neanderthalensis"
j.getir_tur() # => "H. neanderthalensis"
# Statik metodumuzu çağıralım
Insan.grunt() # => "*grunt*"
####################################################
## 6. Moduller
####################################################
# Modülleri içe aktarabilirsiniz
import math
print(math.sqrt(16)) # => 4
# Modülden belirli bir fonksiyonları alabilirsiniz
from math import ceil, floor
print(ceil(3.7)) # => 4.0
print(floor(3.7)) # => 3.0
# Modüldeki tüm fonksiyonları içe aktarabilirsiniz
# Dikkat: bunu yapmanızı önermem.
from math import *
# Modül isimlerini değiştirebilirsiniz.
# Not: Modül ismini kısaltmanız çok daha iyi olacaktır
import math as m
math.sqrt(16) == m.sqrt(16) # => True
# Python modulleri aslında birer python dosyalarıdır.
# İsterseniz siz de yazabilir ve içe aktarabilirsiniz Modulün
# ismi ile dosyanın ismi aynı olacaktır.
# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz.
import math
dir(math)
####################################################
## 7. Gelişmiş
####################################################
# Oluşturucular uzun uzun kod yazmamanızı sağlayacak ve yardımcı olacaktır
def kare_sayilar(nesne):
for i in nesne:
yield i + i
# Bir oluşturucu(generator) değerleri anında oluşturur.
# Bir seferde tüm değerleri oluşturup göndermek yerine teker teker her oluşumdan
# sonra geri döndürür. Bu demektir ki, kare_sayilar fonksiyonumuzda 15'ten büyük
# değerler işlenmeyecektir.
# Not: range() da bir oluşturucu(generator)dur. 1-900000000 arası bir liste yapmaya çalıştığınızda
# çok fazla vakit alacaktır.
# Python tarafından belirlenen anahtar kelimelerden kaçınmak için basitçe alt çizgi(_) kullanılabilir.
range_ = range(1, 900000000)
# kare_sayilar'dan dönen değer 30'a ulaştığında durduralım
for i in kare_sayilar(range_):
print(i)
if i >= 30:
break
# Dekoratörler
# Bu örnekte,
# Eğer lutfen_soyle True ise dönen değer değişecektir.
from functools import wraps
def yalvar(hedef_fonksiyon):
@wraps(hedef_fonksiyon)
def metot(*args, **kwargs):
msj, lutfen_soyle = hedef_fonksiyon(*args, **kwargs)
if lutfen_soyle:
return "{} {}".format(msj, "Lütfen! Artık dayanamıyorum :(")
return msj
return metot
@yalvar
def soyle(lutfen_soyle=False):
msj = "Bana soda alır mısın?"
return msj, lutfen_soyle
print(soyle()) # Bana soda alır mısın?
print(soyle(lutfen_soyle=True)) # Ban soda alır mısın? Lutfen! Artık dayanamıyorum :(
```
## Daha Fazlasına Hazır Mısınız?
### Ücretsiz Online
* [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)
### Kitaplar
* [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)

131
typescript.html.markdown
View File

@ -14,100 +14,111 @@ This article will focus only on TypeScript extra syntax, as oposed to [JavaScrip
To test TypeScript's compiler, head to the [Playground] (http://www.typescriptlang.org/Playground) where you will be able to type code, have auto completion and directly see the emitted JavaScript.
```js
//There are 3 basic types in TypeScript
// There are 3 basic types in TypeScript
var isDone: boolean = false;
var lines: number = 42;
var name: string = "Anders";
//..When it's impossible to know, there is the "Any" type
// When it's impossible to know, there is the "Any" type
var notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean
//For collections, there are typed arrays and generic arrays
// For collections, there are typed arrays and generic arrays
var list: number[] = [1, 2, 3];
//Alternatively, using the generic array type
// Alternatively, using the generic array type
var list: Array<number> = [1, 2, 3];
//For enumerations:
// For enumerations:
enum Color {Red, Green, Blue};
var c: Color = Color.Green;
//Lastly, "void" is used in the special case of a function not returning anything
// Lastly, "void" is used in the special case of a function returning nothing
function bigHorribleAlert(): void {
alert("I'm a little annoying box!");
}
//Functions are first class citizens, support the lambda "fat arrow" syntax and use type inference
//All examples are equivalent, the same signature will be infered by the compiler, and same JavaScript will be emitted
var f1 = function(i: number) : number { return i * i; }
var f2 = function(i: number) { return i * i; } //Return type infered
var f3 = (i : number) : number => { return i * i; }
var f4 = (i: number) => { return i * i; } //Return type infered
var f5 = (i: number) => i * i; //Return type infered, one-liner means no return keyword needed
// Functions are first class citizens, support the lambda "fat arrow" syntax and
// use type inference
//Interfaces are structural, anything that has the properties is compliant with the interface
// The following are equivalent, the same signature will be infered by the
// compiler, and same JavaScript will be emitted
var f1 = function(i: number): number { return i * i; }
// Return type inferred
var f2 = function(i: number) { return i * i; }
var f3 = (i: number): number => { return i * i; }
// Return type inferred
var f4 = (i: number) => { return i * i; }
// Return type inferred, one-liner means no return keyword needed
var f5 = (i: number) => i * i;
// Interfaces are structural, anything that has the properties is compliant with
// the interface
interface Person {
name: string;
//Optional properties, marked with a "?"
// Optional properties, marked with a "?"
age?: number;
//And of course functions
// And of course functions
move(): void;
}
//..Object that implements the "Person" interface
var p : Person = { name: "Bobby", move : () => {} }; //Can be treated as a Person since it has the name and age properties
//..Objects that have the optional property:
var validPerson : Person = { name: "Bobby", age: 42, move: () => {} };
var invalidPerson : Person = { name: "Bobby", age: true }; //Is not a person because age is not a number
// Object that implements the "Person" interface
// Can be treated as a Person since it has the name and move properties
var p: Person = { name: "Bobby", move: () => {} };
// Objects that have the optional property:
var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
// Is not a person because age is not a number
var invalidPerson: Person = { name: "Bobby", age: true };
//..Interfaces can also describe a function type
// Interfaces can also describe a function type
interface SearchFunc {
(source: string, subString: string): boolean;
}
//..Only the parameters' types are important, names are not important.
// Only the parameters' types are important, names are not important.
var mySearch: SearchFunc;
mySearch = function(src: string, sub: string) {
return src.search(sub) != -1;
}
//Classes - members are public by default
// Classes - members are public by default
class Point {
//Properties
x: number;
//Constructor - the public/private keywords in this context will generate the boiler plate code
// for the property and the initialization in the constructor.
// In this example, "y" will be defined just like "x" is, but with less code
//Default values are also supported
constructor(x: number, public y: number = 0) {
this.x = x;
}
//Functions
dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
//Static members
static origin = new Point(0, 0);
// Properties
x: number;
// Constructor - the public/private keywords in this context will generate
// the boiler plate code for the property and the initialization in the
// constructor.
// In this example, "y" will be defined just like "x" is, but with less code
// Default values are also supported
constructor(x: number, public y: number = 0) {
this.x = x;
}
// Functions
dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
// Static members
static origin = new Point(0, 0);
}
var p1 = new Point(10 ,20);
var p2 = new Point(25); //y will be 0
//Inheritance
// Inheritance
class Point3D extends Point {
constructor(x: number, y: number, public z: number = 0) {
super(x, y); //Explicit call to the super class constructor is mandatory
}
//Overwrite
dist() {
var d = super.dist();
return Math.sqrt(d * d + this.z * this.z);
}
constructor(x: number, y: number, public z: number = 0) {
super(x, y); // Explicit call to the super class constructor is mandatory
}
// Overwrite
dist() {
var d = super.dist();
return Math.sqrt(d * d + this.z * this.z);
}
}
//Modules, "." can be used as separator for sub modules
// Modules, "." can be used as separator for sub modules
module Geometry {
export class Square {
constructor(public sideLength: number = 0) {
@ -120,32 +131,32 @@ module Geometry {
var s1 = new Geometry.Square(5);
//..Local alias for referencing a module
// Local alias for referencing a module
import G = Geometry;
var s2 = new G.Square(10);
//Generics
//..Classes
// Generics
// Classes
class Tuple<T1, T2> {
constructor(public item1: T1, public item2: T2) {
}
}
//..Interfaces
// Interfaces
interface Pair<T> {
item1: T;
item2: T;
item1: T;
item2: T;
}
//..And functions
// And functions
var pairToTuple = function<T>(p: Pair<T>) {
return new Tuple(p.item1, p.item2);
return new Tuple(p.item1, p.item2);
};
var tuple = pairToTuple({ item1:"hello", item2:"world"});
//Including references to a definition file:
// Including references to a definition file:
/// <reference path="jquery.d.ts" />
```