summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ca-es/groovy-ca.html.markdown4
-rw-r--r--chapel.html.markdown16
-rw-r--r--de-de/swift-de.html.markdown32
-rw-r--r--es-es/groovy-es.html.markdown4
-rw-r--r--es-es/swift-es.html.markdown30
-rw-r--r--fr-fr/java-fr.html.markdown939
-rw-r--r--groovy.html.markdown4
-rw-r--r--it-it/markdown.html.markdown194
-rw-r--r--pt-br/groovy-pt.html.markdown4
-rw-r--r--pt-br/qt-pt.html.markdown174
-rw-r--r--pt-br/rust-pt.html.markdown (renamed from rust-pt.html.markdown)0
-rw-r--r--pt-br/swift-pt.html.markdown10
-rw-r--r--pt-pt/swift-pt.html.markdown32
-rw-r--r--ru-ru/swift-ru.html.markdown38
-rw-r--r--swift.html.markdown38
-rw-r--r--tr-tr/swift-tr.html.markdown32
-rw-r--r--zh-cn/groovy-cn.html.markdown4
-rw-r--r--zh-cn/swift-cn.html.markdown30
18 files changed, 1387 insertions, 198 deletions
diff --git a/ca-es/groovy-ca.html.markdown b/ca-es/groovy-ca.html.markdown
index 57674970..f0a9adbe 100644
--- a/ca-es/groovy-ca.html.markdown
+++ b/ca-es/groovy-ca.html.markdown
@@ -233,10 +233,12 @@ for (i in array) {
//Itera per un mapa
def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
-x = 0
+x = ""
for ( e in map ) {
x += e.value
+ x += " "
}
+assert x.equals("Roberto Grails Groovy ")
/*
Operadors
diff --git a/chapel.html.markdown b/chapel.html.markdown
index 96ddc69d..e9c4019a 100644
--- a/chapel.html.markdown
+++ b/chapel.html.markdown
@@ -188,7 +188,7 @@ if 10 < 100 then
if -1 < 1 then
writeln("Continuing to believe reality");
else
- writeln("Send mathematician, something's wrong");
+ writeln("Send mathematician, something is wrong");
// You can use parentheses if you prefer.
if (10 > 100) {
@@ -213,7 +213,7 @@ if a % 3 == 0 {
var maximum = if thisInt < thatInt then thatInt else thisInt;
// select statements are much like switch statements in other languages.
-// However, select statements don't cascade like in C or Java.
+// However, select statements do not cascade like in C or Java.
var inputOption = "anOption";
select inputOption {
when "anOption" do writeln("Chose 'anOption'");
@@ -223,7 +223,7 @@ select inputOption {
}
otherwise {
writeln("Any other Input");
- writeln("the otherwise case doesn't need a do if the body is one line");
+ writeln("the otherwise case does not need a do if the body is one line");
}
}
@@ -282,7 +282,7 @@ var range2to10by2: range(stridable=true) = 2..10 by 2; // 2, 4, 6, 8, 10
var reverse2to10by2 = 2..10 by -2; // 10, 8, 6, 4, 2
var trapRange = 10..1 by -1; // Do not be fooled, this is still an empty range
-writeln("Size of range '", trapRange, "' = ", trapRange.length);
+writeln("Size of range ", trapRange, " = ", trapRange.length);
// Note: range(boundedType= ...) and range(stridable= ...) are only
// necessary if we explicitly type the variable.
@@ -425,7 +425,7 @@ var thisPlusThat = thisArray + thatArray;
writeln(thisPlusThat);
// Moving on, arrays and loops can also be expressions, where the loop
-// body's expression is the result of each iteration.
+// body expression is the result of each iteration.
var arrayFromLoop = for i in 1..10 do i;
writeln(arrayFromLoop);
@@ -1141,7 +1141,7 @@ to see if more topics have been added or more tutorials created.
Your input, questions, and discoveries are important to the developers!
-----------------------------------------------------------------------
-The Chapel language is still in-development (version 1.15.0), so there are
+The Chapel language is still in-development (version 1.16.0), so there are
occasional hiccups with performance and language features. The more information
you give the Chapel development team about issues you encounter or features you
would like to see, the better the language becomes. Feel free to email the team
@@ -1158,8 +1158,8 @@ Chapel can be built and installed on your average 'nix machine (and cygwin).
[Download the latest release version](https://github.com/chapel-lang/chapel/releases/)
and it's as easy as
- 1. `tar -xvf chapel-1.15.0.tar.gz`
- 2. `cd chapel-1.15.0`
+ 1. `tar -xvf chapel-1.16.0.tar.gz`
+ 2. `cd chapel-1.16.0`
3. `source util/setchplenv.bash # or .sh or .csh or .fish`
4. `make`
5. `make check # optional`
diff --git a/de-de/swift-de.html.markdown b/de-de/swift-de.html.markdown
index b58a72d3..08f72a35 100644
--- a/de-de/swift-de.html.markdown
+++ b/de-de/swift-de.html.markdown
@@ -440,13 +440,13 @@ if let circle = myEmptyCircle {
// Wie Klassen auch können sie Methoden haben
enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
@@ -455,35 +455,35 @@ enum Suit {
// Enum-Werte können vereinfacht geschrieben werden, es muss nicht der Enum-Typ
// genannt werden, wenn die Variable explizit deklariert wurde
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
// Nicht-Integer-Enums brauchen direkt zugewiesene "Rohwerte"
enum BookName: String {
- case John = "John"
- case Luke = "Luke"
+ case john = "John"
+ case luke = "Luke"
}
-print("Name: \(BookName.John.rawValue)")
+print("Name: \(BookName.john.rawValue)")
// Enum mit assoziierten Werten
enum Furniture {
// mit Int assoziiert
- case Desk(height: Int)
+ case desk(height: Int)
// mit String und Int assoziiert
- case Chair(String, Int)
-
+ case chair(String, Int)
+
func description() -> String {
switch self {
- case .Desk(let height):
+ case .desk(let height):
return "Desk with \(height) cm"
- case .Chair(let brand, let height):
+ case .chair(let brand, let height):
return "Chair of \(brand) with \(height) cm"
}
}
}
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
print(desk.description()) // "Desk with 80 cm"
-var chair = Furniture.Chair("Foo", 40)
+var chair = Furniture.chair("Foo", 40)
print(chair.description()) // "Chair of Foo with 40 cm"
diff --git a/es-es/groovy-es.html.markdown b/es-es/groovy-es.html.markdown
index 799fc609..262d5e6a 100644
--- a/es-es/groovy-es.html.markdown
+++ b/es-es/groovy-es.html.markdown
@@ -232,10 +232,12 @@ for (i in array) {
// Iterando sobre un mapa
def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
-x = 0
+x = ""
for ( e in map ) {
x += e.value
+ x += " "
}
+assert x.equals("Roberto Grails Groovy ")
/*
Operadores
diff --git a/es-es/swift-es.html.markdown b/es-es/swift-es.html.markdown
index 8f63517a..22e3c532 100644
--- a/es-es/swift-es.html.markdown
+++ b/es-es/swift-es.html.markdown
@@ -446,48 +446,48 @@ if let circle = myEmptyCircle {
// Al igual que las clases, pueden contener métodos
enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
// Los valores de enum permite la sintaxis corta, sin necesidad de poner
// el tipo del enum cuando la variable es declarada de manera explícita
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
// Enums de tipo no-entero requiere asignaciones de valores crudas directas
enum BookName: String {
- case John = "John"
- case Luke = "Luke"
+ case john = "John"
+ case luke = "Luke"
}
-print("Name: \(BookName.John.rawValue)")
+print("Name: \(BookName.john.rawValue)")
// Enum con valores asociados
enum Furniture {
// Asociación con Int
- case Desk(height: Int)
+ case desk(height: Int)
// Asociación con String e Int
- case Chair(String, Int)
+ case chair(String, Int)
func description() -> String {
switch self {
- case .Desk(let height):
+ case .desk(let height):
return "Desk with \(height) cm"
- case .Chair(let brand, let height):
+ case .chair(let brand, let height):
return "Chair of \(brand) with \(height) cm"
}
}
}
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
print(desk.description()) // "Desk with 80 cm"
-var chair = Furniture.Chair("Foo", 40)
+var chair = Furniture.chair("Foo", 40)
print(chair.description()) // "Chair of Foo with 40 cm"
diff --git a/fr-fr/java-fr.html.markdown b/fr-fr/java-fr.html.markdown
new file mode 100644
index 00000000..d0f91611
--- /dev/null
+++ b/fr-fr/java-fr.html.markdown
@@ -0,0 +1,939 @@
+---
+language: java
+contributors:
+ - ["Jake Prather", "https://github.com/JakeHP"]
+ - ["Jakukyo Friel", "https://weakish.github.io"]
+ - ["Madison Dickson", "https://github.com/mix3d"]
+ - ["Simon Morgan", "https://sjm.io/"]
+ - ["Zachary Ferguson", "https://github.com/zfergus2"]
+ - ["Cameron Schermerhorn", "https://github.com/cschermerhorn"]
+ - ["Rachel Stiyer", "https://github.com/rstiyer"]
+ - ["Michael Dähnert", "https://github.com/JaXt0r"]
+ - ["Rob Rose", "https://github.com/RobRoseKnows"]
+ - ["Sean Nam", "https://github.com/seannam"]
+filename: JavaFr.java
+translators:
+ - ['Mathieu Gemard', 'https://github.com/mgemard']
+lang: fr-fr
+---
+Java est un langage orienté objet, concurrent et très facilement portable. Java
+est inspiré du C++ mais ne reprend pas tous les concepts comme par exemple les
+pointeurs et en ajoute de nouveaux comme les interfaces.
+[En savoir plus.](https://fr.wikipedia.org/wiki/Java_(langage))
+
+```java
+// Les commentaires sur une seule ligne commencent par //
+
+/*
+Les commentaires sur plusieurs lignes ressemblent à ceci.
+*/
+
+/**
+ * Les commentaires de la JavaDoc ressemblent à ceci. Ils sont utilisés pour
+ * décrire la classe et ses différents attributs.
+ * Attributs principaux:
+ *
+ * @author Nom (et information de contact comme l'email) de(s) auteur(s).
+ * @version Version actuelle du programme.
+ * @since Date à laquelle cette partie du programme a été ajouté.
+ * @param Décrit les différents paramètres pour d'une méthode.
+ * @return Décrit le retour de la méthode.
+ * @deprecated Indique si le code est déprécié ou ne doit plus être utilisé.
+ * @see Lien vers une autre partie de la documentation.
+*/
+
+// Importe la classe ArrayList qui se trouve dans le package java.util
+import java.util.ArrayList;
+// Importe toutes les classes qui se trouvent dans le package java.security
+import java.security.*;
+
+// Chaque fichier .java doit contenir une classe public portant le même nom que
+le fichier.
+public class JavaFr {
+
+ // Pour exécuter un programme Java, celui-ci doit posséder une méthode main
+ // qui fournir un point d'entrée.
+ public static void main(String[] args) {
+
+ ///////////////////////////////////////
+ // Entrée/Sortie
+ ///////////////////////////////////////
+
+ /*
+ * Sortie
+ */
+
+ // Utilisez System.out.println() pour afficher un texte dans la console.
+ System.out.println("Hello World!");
+ System.out.println(
+ "Integer: " + 10 +
+ " Double: " + 3.14 +
+ " Boolean: " + true);
+
+ // Pour afficher sans retour à la ligne, on utilise System.out.print().
+ System.out.print("Hello ");
+ System.out.print("World");
+
+ // Utilisez System.out.printf() pour formatter les données à afficher.
+ System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+ /*
+ * Entrée
+ */
+
+ // Utilisez Scanner pour lire l'entrée
+ // Nécessite: import java.util.Scanner;
+ Scanner scanner = new Scanner(System.in);
+
+ // Lire une chaîne de caractères
+ String name = scanner.next();
+
+ // Lire un byte
+ byte numByte = scanner.nextByte();
+
+ // Lire un entier
+ int numInt = scanner.nextInt();
+
+ // Lire une entrée de type long
+ float numFloat = scanner.nextFloat();
+
+ // Lire une entrée de type double
+ double numDouble = scanner.nextDouble();
+
+ // Lire une entrée de type boolean
+ boolean bool = scanner.nextBoolean();
+
+ ///////////////////////////////////////
+ // Variables
+ ///////////////////////////////////////
+
+ /*
+ * Déclaration de variable
+ */
+ // Déclarez une variable avec la forme <type> <name>
+ int fooInt;
+ // Declarez plusieurs variables du même type <type> <name1>, <name2>,
+ // <name3>
+ int fooInt1, fooInt2, fooInt3;
+
+ /*
+ * Initialisation de variable
+ */
+
+ // Initialisez une variable sous la forme <type> <name> = <val>
+ int barInt = 1;
+ // Initialisez plusieurs variables du même type et avec la même valeur
+ // sous la forme
+ // <type> <name1>, <name2>, <name3>
+ // <name1> = <name2> = <name3> = <val>
+ int barInt1, barInt2, barInt3;
+ barInt1 = barInt2 = barInt3 = 1;
+
+ /*
+ * Types de variable
+ */
+ // byte - Entier signé utilisant la notation en complément à deux sur
+ // 8 bits
+ // (-128 <= byte <= 127)
+ byte fooByte = 100;
+
+ // Si vous voulez interpréter un byte en entier non-signé, cette simple
+ // opération peut vous aider
+ int unsignedIntLessThan256 = 0xff & fooByte;
+ // cela contraste avec une conversion qui peut être négative.
+ int signedInt = (int) fooByte;
+
+ // short - Entier signé utilisant la notation en complément à deux sur
+ // 16 bits
+ // (-32,768 <= short <= 32,767)
+ short fooShort = 10000;
+
+ // int - Entier signé utilisant la notation en complément à deux sur
+ // 32 bits
+ // (-2,147,483,648 <= int <= 2,147,483,647)
+ int bazInt = 1;
+
+ // long - Entier signé utilisant la notation en complément à deux sur
+ // 64 bits
+ // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ long fooLong = 100000L;
+ // L est utilisé pour indiquer que la variable est de type long;
+ // le nombre serait traité comme un int sans le L
+
+ // Note: byte, short, int et long sont signés. Ils peuvent avoir des
+ // valeurs positives et négatives.
+ // Il n'existe pas de variantes non-signées.
+ // char, toutefois, est non-signé sur 16 bits
+
+ // float - nombre à virgule flottante selon la norme IEEE 754 utilisant
+ // le format simple précision sur 32 bits
+ // 2^-149 <= float <= (2-2^-23) * 2^127
+ float fooFloat = 234.5f;
+ // f ou F sont utilisés pour indiquer que la variable est de type float;
+ // autrement elle serait traitée comme un double.
+
+ // double - nombre à virgule flottante selon la norme IEEE 754 utilisant
+ // le format double précision sur 64 bits
+ // 2^-1074 <= x <= (2-2^-52) * 2^1023
+ double fooDouble = 123.4;
+
+ // boolean - vrai & faux
+ boolean fooBoolean = true;
+ boolean barBoolean = false;
+
+ // char - un caractère Unicode sur 16 bits
+ char fooChar = 'A';
+
+ // les variables final ne peuvent pas être réassignés à un autre objet,
+ final int HOURS_I_WORK_PER_WEEK = 9001;
+ // mais ils peuvent être initialisés plus tard.
+ final double E;
+ E = 2.71828;
+
+ // BigInteger - entier immuable de taille arbitraire
+ //
+ // BigInteger est un type de donné qui autorise les développeurs à
+ // manipuler des entiers au delà de 64 bits. Les entiers sont stockés
+ // dans un tableau de bytes et sont manipulés grâce à des functions
+ // de la classe BigIntger
+ //
+ // BigInteger peut être initialiser en utilisant un tableau de bytes ou
+ // une chaîne de caractère.
+ BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+ // BigDecimal - entier immuable et positif de taille arbitraire
+ //
+ // BigDecimal comprend deux parties: une entier de taille arbitraire
+ // (BigInteger) et un entier de 32 bits représantant la position de la
+ // virgule.
+ //
+ // BigDecimal donne aux développeurs un contrôle total pour l'arrondie
+ // à la décimale. Il est recommandé de l'utiliser pour les valeurs
+ // monétaires et pour les cas où la value exacte de l'arondie à la
+ // décimale est requis.
+ //
+ // BigInteger peut être initialiser en utilisant un int, long, double ou
+ // String.
+ // On peut également utiliser un BigInteger et un int pour la
+ // position de la virgule.
+ BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+ // Sachez que la création d'un BigDecimal avec un float ou
+ // un double prendra en compte l'inexactitude des représention en float
+ // ou double.
+ // Préférez String pour une représention exacte.
+ BigDecimal tenCents = new BigDecimal("0.1");
+
+ // String - Chaîne de caractères
+ String fooString = "My String Is Here!";
+
+ // \n est un caractère d'échappement qui indique une nouvelle ligne
+ String barString = "Printing on a new line?\nNo Problem!";
+ // \t est un caractère d'échappement qui indique une tabulation
+ String bazString = "Do you want to add a tab?\tNo Problem!";
+ System.out.println(fooString);
+ System.out.println(barString);
+ System.out.println(bazString);
+
+ // Construction de chaînes de caractères
+ // #1 - avec l'opérateur +
+ // C'est la manière la plus simple et optimisé par le compilateur
+ String plusConcatenated = "Strings can " + "be concatenated " + "via + operator.";
+ System.out.println(plusConcatenated);
+ // Affiche: Strings can be concatenated via + operator.
+
+ // #2 - avec StringBuilder
+ // Cette méthode ne nécessite pas d'objet String intermédiaire. Elle
+ // stocke juste les différentes chaînes de caractères et les assemble
+ // lorsque la méthode toString() est appelée.
+ // Attention: Cette classe n'est pas thread-safe (l'objet ne peut pas être partagé
+ // entre les threads). Une alternative
+ // (avec un impact sur les performances) thread-safe est d'utiliser la
+ // classe StringBuffer.
+ StringBuilder builderConcatenated = new StringBuilder();
+ builderConcatenated.append("You ");
+ builderConcatenated.append("can use ");
+ builderConcatenated.append("the StringBuilder class.");
+ System.out.println(builderConcatenated.toString()); // only now is the string built
+ // Affiche: You can use the StringBuilder class.
+
+ // StringBuffer est efficace quand la chaîne de caractères n'est pas
+ // utilisée avec la fin de sa construction.
+ StringBuilder stringBuilder = new StringBuilder();
+ String inefficientString = "";
+ for (int i = 0 ; i < 10; i++) {
+ stringBuilder.append(i).append(" ");
+ inefficientString += i + " ";
+ }
+ System.out.println(inefficientString);
+ System.out.println(stringBuilder.toString());
+ // inefficientString est moins performant car une chaîne de caractères
+ // est créée à chaque itération de la boucle.
+ // Les concaténations avec + sont compilés en un StringBuilder et
+ // toString().
+ // Evitez les concaténations de string dans les boucles.
+
+ // #3 - avec la méthode format() de la classe String.
+ // Une autre alternative. Rapide et lisible.
+ String.format("%s may prefer %s.", "Or you", "String.format()");
+ // Affiche: Or you may prefer String.format().
+
+ // Tableau
+ // La taille du tableau doit être précisée à l'instantiation
+ // Les formats suivant sont possibles pour déclarer un tableau
+ // <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];
+
+ // Une autre manière de déclarer et initialiser un tableau
+ int[] y = {9000, 1000, 1337};
+ String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+ boolean bools[] = {true, false, false};
+
+ // Accéder à un élément
+ System.out.println("intArray @ 0: " + intArray[0]);
+
+ // Les tableaus commencent à 0 et sont muables
+ intArray[1] = 1;
+ System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+ // Les autres types de donnés utiles sont
+ // ArrayList - Identique aux tableaux mais avec plus de fonctionnalités
+ // et de taille muable.
+ // LinkedList - Implémentation de listes doublement chaînées. Toutes Les
+ // opérations éffectuées le sont comme attendue pour une
+ // liste doublement chaînée.
+ // Map - Une collection d'objets qui fait correspondre une valeur à une
+ // clé. Map est une interface et ne peut pas être instantiée. Le
+ // type des clés et des valeurs doit être précisés à
+ // l'instantiation. Chaque clé doit correspondre à une seule
+ // valeur et chaque clé doit être unique (pas de clés dupliquées).
+ // HashMap - Cette classe utilise une table de hachage pour implémenter
+ // l'interface Map. Cela garantie que le temps d'exécution des
+ // opérations basiques, comme get (récuper une valeur) et
+ // insert (insérer une valeur), reste constant quelque soit la
+ // la taille.
+ // TreeMap - Cette classe utilise une structure en arbre et est
+ // ordonnée. Elle implémente un arbre bicolore (ou arbre rouge
+ // et noir) et ordonne les éléments en se basant sur la clé ou
+ // en utilisant un comparateur fournit à la création.
+
+ ///////////////////////////////////////
+ // Opérateurs
+ ///////////////////////////////////////
+ System.out.println("\n->Operators");
+
+ int i1 = 1, i2 = 2; // Raccourcis pour des déclarations multiples
+
+ // L'arithmétique
+ System.out.println("1+2 = " + (i1 + i2)); // => 3
+ System.out.println("2-1 = " + (i2 - i1)); // => 1
+ System.out.println("2*1 = " + (i2 * i1)); // => 2
+ System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int)
+ System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+ // Le modulo
+ System.out.println("11%3 = "+(11 % 3)); // => 2
+
+ // Opérateurs de comparaison
+ System.out.println("3 == 2? " + (3 == 2)); // => faux
+ System.out.println("3 != 2? " + (3 != 2)); // => vrai
+ System.out.println("3 > 2? " + (3 > 2)); // => vrai
+ System.out.println("3 < 2? " + (3 < 2)); // => faux
+ System.out.println("2 <= 2? " + (2 <= 2)); // => vrai
+ System.out.println("2 >= 2? " + (2 >= 2)); // => vrai
+
+ // Opérateurs boolean
+ System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+ System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+ System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+ // Opérateurs sur les bits
+ /*
+ ~ Complément à un
+ << Décalage des bits vers la gauche
+ >> Décalage des bits vers la droite, le signe est conservé
+ >>> Décalage des bits vers la droite, zéro est utilisé pour les bits
+ les plus à gauche
+ & Opérateur ET
+ ^ Opérateur OU exlusif
+ | Opérateur OU inclusif
+ */
+
+ // Opérateurs d'incrémentation
+ int i = 0;
+ System.out.println("\n->Inc/Dec-rementation");
+ // Les opérateurs ++ et -- incrémentent et décrémentent respectivement
+ // de 1.
+ // S'ils sont placés avant la variable, ils incrémentent la variable puis
+ // retournent la valeur. Placés après la varible, ils retournent la variable
+ // puis l'incrémentent.
+ System.out.println(i++); // i = 1, affiche 0 (pré-incrément)
+ System.out.println(++i); // i = 2, affiche 2 (post-incrément)
+ System.out.println(i--); // i = 1, affiche 2 (post-incrément)
+ System.out.println(--i); // i = 0, affiche 0 (pré-incrément)
+
+ ///////////////////////////////////////
+ // Structures de contôles
+ ///////////////////////////////////////
+ System.out.println("\n->Control Structures");
+
+ // Les instructions conditionnelle sont identiques aux langage C
+ int j = 10;
+ if (j == 10) {
+ System.out.println("I get printed");
+ } else if (j > 10) {
+ System.out.println("I don't");
+ } else {
+ System.out.println("I also don't");
+ }
+
+ // Bouble while
+ int fooWhile = 0;
+ while(fooWhile < 100) {
+ System.out.println(fooWhile);
+ // Incrémente le compteur
+ // Itéré 100 fois, fooWhile 0,1,2...99
+ fooWhile++;
+ }
+ System.out.println("fooWhile Value: " + fooWhile);
+
+ // Boucle do-while
+ int fooDoWhile = 0;
+ do {
+ System.out.println(fooDoWhile);
+ // Incrémente le compteur
+ // Itéré 99 fois, fooDoWhile 0->99
+ fooDoWhile++;
+ } while(fooDoWhile < 100);
+ System.out.println("fooDoWhile Value: " + fooDoWhile);
+
+ // Boucle for
+ // De la forme for(<start_statement>; <conditional>; <step>)
+ for (int fooFor = 0; fooFor < 10; fooFor++) {
+ System.out.println(fooFor);
+ // Itéré 10 fois, fooFor 0->9
+ }
+ System.out.println("fooFor Value: " + fooFor);
+
+ // Fin d'une boucle for avec un label
+ outer:
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 10; j++) {
+ if (i == 5 && j ==5) {
+ break outer;
+ // termine l'itération de la boucle englobante avec le label outer
+ }
+ }
+ }
+
+ // Boucle for-each
+ // La boucle for est également capable d'itérer aussi bien sur un
+ // tableau que sur des objets qui implémentent l'interface Iterable.
+ int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ // De la forme: for (<object> : <iterable>)
+ // Lu comme: "Pour chaque élément du tableau"
+ // note: le type doit correspondre à celui de l'objet itérable
+ for (int bar : fooList) {
+ System.out.println(bar);
+ //Itère 9 fois et affiche les chiffres de 1 à 9
+ }
+
+ // Le switch-case
+ // Un switch fonctionne avec les données de type byte, short, char et
+ // int.
+ // On peut également utiliser le type Enum, la classe String et les
+ // classes spéciales qui englobent les types primitifs (Character, Byte,
+ // Short et Integer).
+ // Depuis Java 7, on peut utiliser le type String.
+ int month = 3;
+ String monthString;
+ switch (month) {
+ case 1: monthString = "January";
+ break;
+ case 2: monthString = "February";
+ break;
+ case 3: monthString = "March";
+ break;
+ default: monthString = "Some other month";
+ break;
+ }
+ System.out.println("Switch Case Result: " + monthString);
+
+ // try-with-resources (Java 7+)
+ // Le mécanisme de gestion des erreurs try-catch-finally peut être
+ // utilisé mais depuis Java 7 il est également possible d'utiliser
+ // try-with-ressources.
+ // try-with-resources simplifie try-catch-finally en fermant
+ // automatiquement les ressources
+
+ // Pour utiliser un try-with-resources, il suffit d'inclure l'instance
+ // d'une classe qui implémente l'interface java.lang.AutoCloseable
+ try (BufferedReader br = new BufferedReader(new FileReader("foo.txt"))) {
+ // Ici, vous pouvez essayer de faire quelque chose qui lance une
+ // exception.
+ System.out.println(br.readLine());
+ // Avec Java 7, la ressource sera toujours fermé, même si elle lance
+ // une exception.
+ } catch (Exception ex) {
+ // La ressource sera fermé avant que le catch s'exécute.
+ System.out.println("readLine() failed.");
+ }
+ // Il n'y a pas besoin de finally dans ce cas, l'objet BufferedReader
+ // sera déjà fermé. Cela peut être utile dans certains cas spécifiques
+ // où le code contenu dans finally ne serait pas exécuté.
+ // Consulter la documention Oracle pour en savoir plus (en anglais) :
+ // https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
+
+
+ // Expression ternaire
+ // Vous pouvez utiliser l'opérateur ternaire '?' pour faire un
+ // assignement rapide avec une condition logique.
+ // Il faut lire "Si la (condition) est vraie alors utiliser la
+ // <première valeur> sinon utilisez la <deuxième valeur>".
+ int foo = 5;
+ String bar = (foo < 10) ? "A" : "B";
+ System.out.println("bar : " + bar); // Affiche "bar : A", car la condition est vraie
+ // Ou alors plus simplement
+ System.out.println("bar : " + (foo < 10 ? "A" : "B")); // Affiche également "bar : A"
+
+ ////////////////////////////////////////
+ // Conversion de type
+ ////////////////////////////////////////
+
+ // Autoboxing
+
+ // Convertir un objet String en un objet Integer
+ Integer.parseInt("123"); // retourne un le type primitif int de 123
+
+ // Convert Integer To String
+ Integer.toString(123); // retourne un object String correspondant à"123"
+
+ // Pour les autres conversions, référer vous aux classes suivantes:
+ // Double
+ // Long
+ // String
+
+ ///////////////////////////////////////
+ // Classes et fonctions
+ ///////////////////////////////////////
+
+ System.out.println("\n->Classes & Functions");
+
+ // (voir plus loin pour la définition de la classe Bicycle)
+
+ // Utilisez new pour instancier une classe
+ Bicycle trek = new Bicycle();
+
+ // Pour appeler une méthode de l'objet
+ trek.speedUp(3); // !! Il est conseillé de passer par une méthode pour
+ // changer la valeur d'une variable.
+ trek.setCadence(100);
+
+ // toString retourne une représentation de l'objet en chaîne de caractères.
+ System.out.println("trek info: " + trek.toString());
+
+ // Initialisation avec double accolades
+ // Le langage Java ne permet pas de créer des collections statiques d'une
+ // manière simple. Généralement, on utilise la forme suivante:
+ private static final Set<String> COUNTRIES = new HashSet<String>();
+ static {
+ COUNTRIES.add("DENMARK");
+ COUNTRIES.add("SWEDEN");
+ COUNTRIES.add("FINLAND");
+ }
+
+ // Mais on peut le faire d'une manière plus habile, dite initialisation
+ // avec double semi-colonnes
+ private static final Set<String> COUNTRIES = new HashSet<String>() {{
+ add("DENMARK");
+ add("SWEDEN");
+ add("FINLAND");
+ }}
+
+ // La première semi-colonne crée une classe anonyme et la deuxième est
+ // un bloc d'initialisation du bloc. Ce dernier est appelé lorsque Copyright (c)
+ // classe anonyme est crée. Cela ne fonctionne pas uniquement pour les
+ // collections mais également pour toutes les classes n'étant pas
+ // déclarées comme final.
+
+ } // Fin de la méthode main
+} // Fin de la class JavaFr
+
+// Vous pouvez inclure des classes qui ne sont pas publics dans un fichier Java.
+// Cependant, il est préférable de séparer les
+// classes dans des fichiers différents.
+
+// Syntaxe de déclaration des classes:
+// <public/private/protected> class <Nom de la classe> {
+// // Les attributs, les constructeurs et les méthodes de la classe vont ici.
+// // Les functions de classes sont appelées méthode.
+// }
+
+class Bicycle {
+
+ // Attributs et variables de la classe Bicycle
+ public int cadence; // Public: Peut être accesible depuis n'importe où
+ private int speed; // Private: Accisible depuis la classe
+ protected int gear; // Protected: Accisible depuis la classe et ses sous-
+ // classes
+ String name; // default: Uniquement accesible depuis ce package
+ static String className; // Variable de classe static
+
+ // Bloc static
+ // Java n'a pas d'implémentation pour les constructeurs statiques mais
+ // possède le bloc static qui peut être utilisé pour initialiser les
+ // variables de classe.
+ // Ce bloc sera appelé lorsque la classe sera chargée.
+ static {
+ className = "Bicycle";
+ }
+
+ // Les constructeurs sont un moyen de créer les classe
+ // Ceci est le constructeur de la classe Bicycle
+ public Bicycle() {
+ // Vous pouvez aussie appeler un autre constructeur. Par exemple en
+ // appelant le constructeur de la classe mère (voir héritage):
+ // this(1, 50, 5, "Bontrager");
+ gear = 1;
+ cadence = 50;
+ speed = 5;
+ name = "Bontrager";
+ }
+ // Le constructeur peut prendre plusieurs arguments
+ public Bicycle(int startCadence, int startSpeed, int startGear,
+ String name) {
+ this.gear = startGear;
+ this.cadence = startCadence;
+ this.speed = startSpeed;
+ this.name = name;
+ }
+
+ // Syntaxe d'une méthode :
+ // <public/private/protected> <type de retour> <nom de la fonction>(
+ // <arguments>)
+
+ // Les classes Java possèdent souvent des accesseurs (getters) et mutateurs
+ // (setters) pour leurs attributs.
+
+ public int getCadence() {
+ return cadence;
+ }
+
+ // Les méthodes void ne retourne aucune valeur
+ public void setCadence(int newValue) {
+ cadence = newValue;
+ }
+ public void setGear(int newValue) {
+ gear = newValue;
+ }
+ public void speedUp(int increment) {
+ speed += increment;
+ }
+ public void slowDown(int decrement) {
+ speed -= decrement;
+ }
+ public void setName(String newName) {
+ name = newName;
+ }
+ public String getName() {
+ return name;
+ }
+
+ // Méthode pour afficher la valeur des attributs de l'objet. @Override est
+ // une annotation (voir plus loin).
+ @Override //On dit ici qu'on remplace la méthode de la classe Objet.
+ public String toString() {
+ return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+ " name: " + name;
+ }
+} // Fin de la classe Bicycle
+
+// PennyFarthing est une sous-classe de Bicycle
+class PennyFarthing extends Bicycle {
+ // (Les Penny Farthings sont des bicyclette avec une grande roue avant.
+ // Il n'y a pas de roue libre, le cycliste est obligé de pédaler en
+ // permanence.)
+
+ public PennyFarthing(int startCadence, int startSpeed) {
+ // Appelez le constructeur parent avec la méthode super()
+ super(startCadence, startSpeed, 0, "PennyFarthing");
+ }
+
+ // Ici nous modifions la méthode setGear() de la classe mère. Il faut donc
+ // utiliser l'annotation @Overide. Pour en savoir plus sur les annotations,
+ // consulter la documention officiel (en anglais) :
+ // out: http://docs.oracle.com/javase/tutorial/java/annotations/
+ @Override
+ public void setGear(int gear) {
+ this.gear = 0;
+ }
+}
+
+// Polymorphisme (cast d'objets)
+// Comme la classe PennyFarthing héritent de la classe Bicycle, on peut dire
+// qu'un PennyFarthing est un Bicycle (un vélo en anglais) et écrire :
+// Bicycle bicycle = new PennyFarthing();
+// Le polymorphisme est la capacité d'un objet de se faire passer pour un autre.
+// Vous pouvez consulter la documentation Oracle pour plus de détails et
+// concepts (en anglais) :
+// https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+// Interfaces
+// Déclaration d'une interface
+// <niveau d'accès> interface <nom de l'interface> extends <nom de l'interface
+// mère> {
+// // Constantes
+// // Délaration des méthodes
+// }
+
+// Exemple - Toute nourriture peut être mangée et digégée différemment
+// L'interface Edible (traduction : comestible) décrit l'action de manger
+public interface Edible {
+ public void eat(); // Toute classe qui implémente cette interface doit
+ // implémenter cette méthode
+}
+
+// L'interface Digestible décrit l'action de digérer
+public interface Digestible {
+ public void digest();
+ // Depuis Java 8, les interfaces peuvent avoir des méthodes par défaut.
+ public void defaultMethod() {
+ System.out.println("Hi from default method ...");
+ }
+}
+
+// On peut maintenant créer une classe qui implémente chacune de ces interfaces.
+public class Fruit implements Edible, Digestible {
+ @Override
+ public void eat() {
+ // ...
+ }
+
+ @Override
+ public void digest() {
+ // ...
+ }
+}
+
+// En Java, on peut hériter uniquement d'une classe mais on peut implémenter
+// plusieurs interfaces:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+ InterfaceTwo {
+ @Override
+ public void InterfaceOneMethod() {
+ }
+
+ @Override
+ public void InterfaceTwoMethod() {
+ }
+
+}
+
+// Classes abstraites
+
+// Syntaxe de déclaration:
+// <niveau d'accès> abstract class <nom de la classe abstraite> extends <nom de la
+// classe mère abstraite> {
+// // Constantes et variables
+// // Méthodes
+// }
+
+// Une classe abstraite contient au moins une méthode abstraite qui doit être
+// définee dans la classe fille. Comme les interfaces, les classes abstraites ne
+// peuvent pas être instanciées mais doivent être étendues avec les méthodes
+// abstraites implémentées. À la différence des interfaces, une classe abstraite
+// peut contenir des méthodes abstraites ou non-abstraites. Les méthodes dans une
+// interfaces ne peuvent pas être implémentées à l'exception des méthodes static.
+// Les variables d'une classe abstraite sont déclarées comme final par défaut à
+// l'opposé des interfaces. Finalement les classes abstraites peuvent avoir une
+// méthode main.
+public abstract class Animal
+{
+ public abstract void makeSound();
+
+ // Les méthodes peuvent avoir une implémentation dans une classe abstraite.
+ public void eat()
+ {
+ System.out.println("I am an animal and I am Eating.");
+ // Note: On peut accéder à une variable privée ici.
+ age = 30;
+ }
+
+ // On n'a pas besoin d'initialiser les variables dans les classe abstraites.
+ // Cependant, dans une interfaces, les variables sont implicitement
+ // déclarées comme final et doivent donc être initialisées.
+ private int age;
+
+ public void printAge()
+ {
+ System.out.println(age);
+ }
+
+ // Les classes abstraites peuvent avoir une fonction main.
+ public static void main(String[] args)
+ {
+ System.out.println("I am abstract");
+ }
+}
+
+class Dog extends Animal
+{
+ // On doit également utiliser l'annotation @Override lors de la surchage de
+ // la méthode abstraite d'une classe abstraite.
+ @Override
+ public void makeSound()
+ {
+ System.out.println("Bark");
+ // age = 30; ==> ERREUR! age est privé et n'est pas accesible.
+ }
+
+ // NOTE: Vous obtiendrez une erreur si vous utilisé l'annotation @Override
+ // ici car Java n'autorise pas la surcharge de méthodes statiques. Ce qui ce
+ // passe est appelé "method hiding". Si vous voulez en savoir plus,
+ // consultez cette discussion (en anglais) :
+ // http://stackoverflow.com/questions/16313649/
+ public static void main(String[] args)
+ {
+ Dog pluto = new Dog();
+ pluto.makeSound();
+ pluto.eat();
+ pluto.printAge();
+ }
+}
+
+// Classes finales
+
+// Syntaxe de déclaration
+// <niveau d'accès> final <nom de la classe final> {
+// // Constantes et variables
+// // Méthodes déclarations
+// }
+
+// Les classe déclarées comme final ne peuvent pas avoir de classe fille. Elles
+// peuvent être considérées comme l'opposé des classes abstraites.
+public final class SaberToothedCat extends Animal
+{
+ // On doit également utiliser l'annotation @Override lors de la surchage de
+ // la méthode abstraite d'une classe abstraite.
+ @Override
+ public void makeSound()
+ {
+ System.out.println("Roar");
+ }
+}
+
+// Méthodes final
+public abstract class Mammal()
+{
+ // Syntaxe:
+ // <niveau d'accès> final <type de retour> <nom de la fonction>(<arguments>)
+
+ // Les méthodes déclarées comme final ne peuvent pas être surchargées par
+ // une classe fille et en sont donc l'implémentation finale.
+ public final boolean isWarmBlooded()
+ {
+ return true;
+ }
+}
+
+// Enumérations
+//
+// Le type enum est un type de donnée spécial qui permet à une variable de ne
+// prendre que certaines valeurs prédéfinies. La variable doit être égales à une
+// des valeurs pédéfinies pour celle-ci. En Java, les variables constantes sont
+// notées en majuscules.
+// On définie un type enum en utilisant le mot clé enum. Par exemple pour les
+// jours de l'année:
+public enum Day {
+ SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+ THURSDAY, FRIDAY, SATURDAY
+}
+
+// On l'utilise ainsi:
+public class EnumTest {
+ // On utilise notre énumération
+ Day day;
+
+ public EnumTest(Day day) {
+ this.day = day;
+ }
+
+ public void tellItLikeItIs() {
+ switch (day) {
+ case MONDAY:
+ System.out.println("Mondays are bad.");
+ break;
+ case FRIDAY:
+ System.out.println("Fridays are better.");
+ break;
+ case SATURDAY:
+ case SUNDAY:
+ System.out.println("Weekends are best.");
+ break;
+ default:
+ System.out.println("Midweek days are so-so.");
+ break;
+ }
+ }
+
+ public static void main(String[] args) {
+ EnumTest firstDay = new EnumTest(Day.MONDAY);
+ firstDay.tellItLikeItIs(); // => affiche "Mondays are bad"
+ EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
+ thirdDay.tellItLikeItIs(); // => affiche "Midweek days are so-so"
+ }
+}
+
+// Le type enum permet de faire bien plus que ce qui est montré ici. Il ne se
+// limite pas à une liste de constante mais peut inclure des champs et méthodes.
+// Vous pouvez en savoir plus ici (en anglais):
+//https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## Pour aller plus loin (en anglais)
+
+Les liens ci-dessous sont données si vous souhaitez approfondir sur le sujet,
+n'hésitez pas à consulter Google pour trouver des exemples spécifiques.
+
+**Guides officiels d'Oracle**:
+
+* [Java Tutorial Trail from Sun / Oracle](https://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](https://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+ * [Inheritance](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+ * [Polymorphism](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+ * [Abstraction](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](https://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](https://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+* Nouvelles fonctionnalités Java 8:
+ * [Lambda expressions (functional programming)](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
+ * [Date and time API (java.time package)](http://www.oracle.com/technetwork/articles/java/jf14-date-time-2125367.html)
+
+**Pratiquer en ligne et tutoriels**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+**Livres**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](https://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](https://www.amazon.com/gp/product/0071606300)
diff --git a/groovy.html.markdown b/groovy.html.markdown
index a3a45757..efbb2b32 100644
--- a/groovy.html.markdown
+++ b/groovy.html.markdown
@@ -230,10 +230,12 @@ for (i in array) {
//Iterate over a map
def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
-x = 0
+x = ""
for ( e in map ) {
x += e.value
+ x += " "
}
+assert x.equals("Roberto Grails Groovy ")
/*
Operators
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
index b006dbb4..44801747 100644
--- a/it-it/markdown.html.markdown
+++ b/it-it/markdown.html.markdown
@@ -2,41 +2,65 @@
language: markdown
contributors:
- ["Dan Turkel", "http://danturkel.com/"]
+ - ["Jacob Ward", "http://github.com/JacobCWard/"]
translators:
- ["Jacopo Andrea Giola", "http://geekpanda.net"]
+ - ["Ale46", "https://github.com/Ale46"]
filename: markdown-it.md
lang: it-it
---
Markdown è stato creato da John Gruber nel 2004. Il suo scopo è quello di essere una sintassi facile da leggere e scrivere, e che può essere convertita in HTML (ad oggi anche in molti altri formati).
-Mandate tutto il feedback che volete! / Sentitevi liberi di forkare o di mandare pull request!
+Markdown varia nelle sue implementazioni da un parser all'altro. Questa guida cercherà di chiarire quali caratteristiche esistono a livello globale o quando sono disponibili solo per un determinato parser.
+- [Elementi HTML](#elementi-html)
+- [Titoli](#titoli)
+- [Stili di testo semplici](#stili-di-testo-semplici)
+- [Paragrafi](#paragrafi)
+- [Liste](#liste)
+- [Estratti di codice](#estratti-di-codice)
+- [Linea orizzontale](#linea-orizzontale)
+- [Links](#links)
+- [Immagini](#immagini)
+- [Miscellanea](#miscellanea)
+
+## Elementi HTML
+Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido.
```markdown
-<!-- Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido. Questo significa che possiamo usare elementi di HTML in Markdown, come per esempio i commenti, e questi non saranno modificati dal parser di Markdown. State attenti però, se inserite un elemento HTML nel vostro file Markdown, non potrete usare la sua sintassi all'interno del contenuto dell'elemento. -->
+<!-- Questo significa che possiamo usare elementi di HTML in Markdown, come per esempio i commenti,
+e questi non saranno modificati dal parser di Markdown. State attenti però,
+se inserite un elemento HTML nel vostro file Markdown, non potrete usare la sua sintassi
+all'interno del contenuto dell'elemento. -->
+```
+
+## Titoli
-<!-- L'implementazione di Markdown inoltre cambia da parser a parser. In questa guida cercheremo di indicare quando una feature è universale e quando sono specifiche ad un certo parser. -->
+Potete creare gli elementi HTML da `<h1>` a `<h6>` facilmente, basta che inseriate un egual numero di caratteri cancelletto (#) prima del testo che volete all'interno dell'elemento
-<!-- Titoli -->
-<!-- Potete creare gli elementi HTML da <h1> ad <h6> facilmente, basta che inseriate un egual numero di caratteri cancelletto (#) prima del testo che volete all'interno dell'elemento -->
+```markdown
# Questo è un <h1>
## Questo è un <h2>
### Questo è un <h3>
#### Questo è un <h4>
##### Questo è un <h5>
###### Questo è un <h6>
+```
+Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2
-<!-- Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2 -->
+```markdown
Questo è un h1
==============
Questo è un h2
--------------
+```
-<!-- Stili di testo semplici -->
-<!-- Il testo può essere stilizzato in corsivo o grassetto usando markdown -->
+## Stili di testo semplici
+Il testo può essere stilizzato in corsivo o grassetto usando markdown
+```markdown
*Questo testo è in corsivo.*
_Come pure questo._
@@ -46,30 +70,38 @@ __Come pure questo.__
***Questo testo è stilizzato in entrabmi i modi.***
**_Come questo!_**
*__E questo!__*
+```
-<!-- In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su
-Github, è presente anche lo stile barrato -->
+In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su Github, è presente anche lo stile barrato:
+```markdown
~~Questo testo è barrato.~~
+```
+## Paragrafi
-<!-- I paragrafi sono uno o più linee di testo addiacenti separate da una o più righe vuote. -->
+```markdown
+I paragrafi sono una o più linee di testo adiacenti separate da una o più righe vuote.
-Qeusto è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
+Questo è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
Ora sono nel paragrafo 2.
Anche questa linea è nel paragrafo 2!
Qui siamo nel paragrafo 3!
+```
-<!-- Se volete inserire l'elemento HTML <br />, potete terminare la linea con due o più spazi e poi iniziare un nuovo paragrafo. -->
+Se volete inserire l'elemento HTML `<br />`, potete terminare la linea con due o più spazi e poi iniziare un nuovo paragrafo.
+```markdown
Questa frase finisce con due spazi (evidenziatemi per vederli).
C'è un <br /> sopra di me!
+```
-<!-- Le citazioni sono semplici da inserire, basta usare il carattere >. -->
+Le citazioni sono semplici da inserire, basta usare il carattere >.
+```markdown
> Questa è una citazione. Potete
> mandare a capo manualmente le linee e inserire un `>` prima di ognuna, oppure potete usare una sola linea e lasciare che vada a capo automaticamente.
> Non c'è alcuna differenza, basta che iniziate ogni riga con `>`.
@@ -78,9 +110,12 @@ C'è un <br /> sopra di me!
>> di indentazione!
> Quanto è comodo?
-<!-- Liste -->
-<!-- Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini -->
+```
+
+## Liste
+Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini
+```markdown
* Oggetto
* Oggetto
* Altro oggetto
@@ -96,149 +131,180 @@ oppure
- Oggetto
- Oggetto
- Un ultimo oggetto
+```
-<!-- Le liste ordinate invece, sono inserite con un numero seguito da un punto. -->
+Le liste ordinate invece, sono inserite con un numero seguito da un punto.
+```markdown
1. Primo oggetto
2. Secondo oggetto
3. Terzo oggetto
+```
-<!-- Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea. -->
+Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea.
+```markdown
1. Primo oggetto
1. Secondo oggetto
1. Terzo oggetto
-<!-- (Questa lista verrà visualizzata esattamente come quella dell'esempio prima) -->
+```
+(Questa lista verrà visualizzata esattamente come quella dell'esempio prima)
-<!-- Potete inserire anche sotto liste -->
+Potete inserire anche sotto liste
+```markdown
1. Primo oggetto
2. Secondo oggetto
3. Terzo oggetto
* Sotto-oggetto
* Sotto-oggetto
4. Quarto oggetto
+```
-<!-- Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML. -->
+Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML.
+```markdown
I box senza la 'x' sono checkbox HTML ancora da completare.
- [ ] Primo task da completare.
- [ ] Secondo task che deve essere completato.
Il box subito sotto è una checkbox HTML spuntata.
- [x] Questo task è stato completato.
+```
+## Estratti di codice
-<!-- Estratti di codice -->
-<!-- Potete inserire un estratto di codice (che utilizza l'elemento <code>) indentando una linea con quattro spazi oppure con un carattere tab -->
+Potete inserire un estratto di codice (che utilizza l'elemento `<code>`) indentando una linea con quattro spazi oppure con un carattere tab.
+```markdown
Questa è una linea di codice
Come questa
+```
-<!-- Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice -->
+Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice
+```markdown
my_array.each do |item|
puts item
end
+```
-<!-- Codice inline può essere inserito usando il carattere backtick ` -->
+Codice inline può essere inserito usando il carattere backtick `
+```markdown
Giovanni non sapeva neppure a cosa servisse la funzione `go_to()`!
+```
-<!-- In Github Flavored Markdown, potete inoltre usare una sintassi speciale per il codice -->
-
-\`\`\`ruby <!-- In realtà dovete rimuovere i backslash, usate solo ```ruby ! -->
+In Github Flavored Markdown, potete inoltre usare una sintassi speciale per il codice
+<pre>
+<code class="highlight">&#x60;&#x60;&#x60;ruby
def foobar
puts "Hello world!"
end
-\`\`\` <!-- Anche qui, niente backslash, solamente ``` -->
+&#x60;&#x60;&#x60;</code></pre>
+Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre Github userà l'evidenziazione della sintassi del linguaggio specificato dopo i \`\`\` iniziali
-<!-- Se usate questa sintassi, il testo non richiederà di essere indentanto, inoltre Github userà la syntax highlighting del linguaggio specificato dopo i ``` iniziali -->
-
-<!-- Linea orizzontale (<hr />) -->
-<!-- Le linee orizzontali sono inserite facilemtne usanto tre o più asterischi o trattini senza spazi consecutivi e senza spazi. -->
+## Linea orizzontale
+Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asterischi o trattini, con o senza spazi.
+```markdown
***
---
- - -
****************
+```
-<!-- Link -->
-<!-- Una delle funzionalità migliori di markdown è la facilità con cui si possono inserire i link. Mettete il testo da visualizzare fra parentesi quadre [] seguite dall'url messo fra parentesi tonde () -->
+## Links
+Una delle funzionalità migliori di markdown è la facilità con cui si possono inserire i link. Mettete il testo da visualizzare fra parentesi quadre [] seguite dall'url messo fra parentesi tonde ()
+```markdown
[Cliccami!](http://test.com/)
+```
-<!-- Potete inoltre aggiungere al link un titolo mettendolo fra doppie apici dopo il link -->
+Potete inoltre aggiungere al link un titolo mettendolo fra doppi apici dopo il link
+```markdown
[Cliccami!](http://test.com/ "Link a Test.com")
+```
-<!-- La sintassi funziona anche i path relativi. -->
+La sintassi funziona anche con i path relativi.
+```markdown
[Vai a musica](/music/).
+```
-<!-- Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo -->
-
+Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo.
+```markdown
[Apri questo link][link1] per più informazioni!
[Guarda anche questo link][foobar] se ti va.
[link1]: http://test.com/ "Bello!"
[foobar]: http://foobar.biz/ "Va bene!"
+```
+l titolo può anche essere inserito in apici singoli o in parentesi, oppure omesso interamente. Il riferimento può essere inserito in un punto qualsiasi del vostro documento e l'identificativo del riferimento può essere lungo a piacere a patto che sia univoco.
-<!-- Il titolo può anche essere inserito in apici singoli o in parentesi, oppure omesso interamente. Il riferimento può essere inserito in un punto qualsiasi del vostro documento e l'identificativo del riferimento può essere lungo a piacere a patto che sia univoco. -->
-
-<!-- Esiste anche un "identificativo implicito" che vi permette di usare il testo del link come id -->
-
+Esiste anche un "identificativo implicito" che vi permette di usare il testo del link come id.
+```markdown
[Questo][] è un link.
[Questo]: http://thisisalink.com/
+```
+Ma non è comunemente usato.
-<!-- Ma non è comunemente usato. -->
-
-<!-- Immagini -->
-<!-- Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre! -->
+## Immagini
+Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre!
+```markdown
![Qeusto è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
+```
-<!-- E la modalità a riferimento funziona esattamente come ci si aspetta -->
+E la modalità a riferimento funziona esattamente come ci si aspetta
+```markdown
![Questo è il testo alternativo.][myimage]
[myimage]: relative/urls/cool/image.jpg "Se vi serve un titolo, lo mettete qui"
+```
+## Miscellanea
+### Auto link
-<!-- Miscellanea -->
-<!-- Auto link -->
-
+```markdown
<http://testwebsite.com/> è equivalente ad
[http://testwebsite.com/](http://testwebsite.com/)
+```
+### Auto link per le email
-<!-- Auto link per le email -->
-
+```markdown
<foo@bar.com>
+```
+### Caratteri di escaping
-<!-- Caratteri di escaping -->
-
+```markdown
Voglio inserire *questo testo circondato da asterischi* ma non voglio che venga renderizzato in corsivo, quindi lo inserirò così: \*questo testo è circondato da asterischi\*.
+```
-<!-- Combinazioni di tasti -->
-<!-- In Github Flavored Markdown, potete utilizzare il tag <kbd> per raffigurare i tasti della tastiera -->
+### Combinazioni di tasti
+In Github Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
+```markdown
Il tuo computer è crashato? Prova a premere
<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Canc</kbd>
+```
-<!-- Tabelle -->
-<!-- Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue: -->
+### Tabelle
+Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
+```markdown
| Col1 | Col2 | Col3 |
| :------------------- | :------: | -----------------: |
| Allineato a sinistra | Centrato | Allineato a destra |
| blah | blah | blah |
+```
+oppure, per lo stesso risultato
-<!-- oppure, per lo stesso risultato -->
-
+```markdown
Col 1 | Col2 | Col3
:-- | :-: | --:
È una cosa orrenda | fatela | finire in fretta
-
-<!-- Finito! -->
-
```
+---
Per altre informazioni, leggete il post ufficiale di John Gruber sulla sintassi [qui](http://daringfireball.net/projects/markdown/syntax) e il magnifico cheatsheet di Adam Pritchard [qui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index 25e123c0..aed23df1 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -226,10 +226,12 @@ for (i in array) {
//Itera sobre um mapa
def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
-x = 0
+x = ""
for ( e in map ) {
x += e.value
+ x += " "
}
+assert x.equals("Roberto Grails Groovy ")
/*
Operadores
diff --git a/pt-br/qt-pt.html.markdown b/pt-br/qt-pt.html.markdown
new file mode 100644
index 00000000..99579c35
--- /dev/null
+++ b/pt-br/qt-pt.html.markdown
@@ -0,0 +1,174 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-pt.cpp
+contributors:
+ - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+ - ["Lucas Pugliesi", "https://github.com/fplucas"]
+lang: pt-br
+---
+
+**Qt** é amplamente conhecido como um framework para desenvolvimento de
+software multi-plataforma que pode rodar em vários outras plataformas de
+softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém
+o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido
+originalmente escrito em *C++*, é possível utilizá-lo em outras linguagens:
+*[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** é ótimo para criar aplicações com interface gráfica (GUI). Esse tutorial
+será feito em *C++*.
+
+```c++
+/*
+ * Vamos começar
+ */
+
+// Todos as dependências do framework Qt iniciam com a letra 'Q' maiúscula
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+ // Cria um objeto para utilizar todos os recursos da aplicação
+ QApplication app(argc, argv);
+
+ // Cria um widget com linha editável e exibe na tela
+ QLineEdit lineEdit("Hello world!");
+ lineEdit.show();
+
+ // Inicia a aplicação em um evento de loop
+ return app.exec();
+}
+```
+
+A parte gráfica do **Qt** é toda composta de *widgets* e *conexões* entre eles.
+
+[LEIA MAIS SOBRE WIDGETS](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Vamos criar um label e um botão.
+ * Um label irá aparecer quando o botão for clicado
+ *
+ * O próprio código do Qt é autoexplicativo.
+ */
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ // Adiciona um layout vertical
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ QLabel textLabel("Thanks for pressing that button");
+ layout.addWidget(&textLabel);
+ textLabel.hide();
+
+ QPushButton button("Press me");
+ layout.addWidget(&button);
+
+ // Exibe o label oculto quando o botão é clicado
+ QObject::connect(&button, &QPushButton::pressed,
+ &textLabel, &QLabel::show);
+
+ return app.exec();
+}
+```
+
+Veja o *QObject::connect*. O método é usado para conectar o *SINAL* de um objeto
+ao *ENCAIXE* outro.
+
+**Sinais** são emitidos quando algo ocorre com o objeto, como quando o sinal de
+*clique* é acionado apertando o QPushButton.
+
+**Encaixes** são *ações* que são executadas em resposta aos sinais recebidos.
+
+[LEIA MAIS SOBRE SINAIS E ENCAIXES](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+A seguir vamos aprender como usar não somente o comportamento padrão dos
+widgets, mas também extender seus comportamentos usando herança. Vamos criar um
+botão e contar quantas vezes é pressionado. Para esse propósito definiremos
+nossa própria classe *CounterLabel*. Ela deve ser declarada em um arquivo
+diferente devido a estrutura específica do Qt.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+ Q_OBJECT // Define os macros presente em todo objeto Qt
+
+public:
+ CounterLabel() : counter(0) {
+ setText("Counter has not been increased yet"); // método do QLabel
+ }
+
+public slots:
+ // Ação que será chamada em resposta ao clique do botão
+ void increaseCounter() {
+ setText(QString("Counter value: %1").arg(QString::number(++counter)));
+ }
+
+private:
+ int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// Quase igual ao exemplo anterior
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ CounterLabel counterLabel;
+ layout.addWidget(&counterLabel);
+
+ QPushButton button("Push me once more");
+ layout.addWidget(&button);
+ QObject::connect(&button, &QPushButton::pressed,
+ &counterLabel, &CounterLabel::increaseCounter);
+
+ return app.exec();
+}
+```
+
+É isso! Claro, o framework Qt é muito maior do que exemplificamos no tutorial,
+então esteja preparado para ler e praticar mais.
+
+## Leitura complementar
+
+- [Tutoriais Qt 4.8](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Tutoriais Qt 5](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Boa sorte e divirta-se!
diff --git a/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown
index 8134d3c5..8134d3c5 100644
--- a/rust-pt.html.markdown
+++ b/pt-br/rust-pt.html.markdown
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index ebf74b6f..bf410352 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -389,13 +389,13 @@ if mySquare === mySquare {
// Podem conter métodos do mesmo jeito que classes.
enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
diff --git a/pt-pt/swift-pt.html.markdown b/pt-pt/swift-pt.html.markdown
index 9462ee1c..6b263942 100644
--- a/pt-pt/swift-pt.html.markdown
+++ b/pt-pt/swift-pt.html.markdown
@@ -445,49 +445,49 @@ if let circle = myEmptyCircle {
// Enums pode opcionalmente ser um tipo especifico ou não.
// Enums podem conter métodos tal como as classes.
-enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+enum suit {
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
// Os valores de Enum permitem syntax reduzida, não é preciso escrever o tipo do enum
// quando a variável é explicitamente definida.
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
// Enums que não sejam inteiros obrigam a atribuições valor bruto (raw value) diretas
enum BookName: String {
- case John = "John"
- case Luke = "Luke"
+ case john = "John"
+ case luke = "Luke"
}
-print("Name: \(BookName.John.rawValue)")
+print("Name: \(BookName.john.rawValue)")
// Enum com valores associados
enum Furniture {
// Associar com um inteiro (Int)
- case Desk(height: Int)
+ case desk(height: Int)
// Associar com uma String e um Int
- case Chair(String, Int)
+ case chair(String, Int)
func description() -> String {
switch self {
- case .Desk(let height):
+ case .desk(let height):
return "Desk with \(height) cm"
- case .Chair(let brand, let height):
+ case .chair(let brand, let height):
return "Chair of \(brand) with \(height) cm"
}
}
}
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
print(desk.description()) // "Desk with 80 cm"
-var chair = Furniture.Chair("Foo", 40)
+var chair = Furniture.chair("Foo", 40)
print(chair.description()) // "Chair of Foo with 40 cm"
diff --git a/ru-ru/swift-ru.html.markdown b/ru-ru/swift-ru.html.markdown
index 7ff660e1..f2b1fd36 100644
--- a/ru-ru/swift-ru.html.markdown
+++ b/ru-ru/swift-ru.html.markdown
@@ -376,14 +376,14 @@ print("Имя :\(name)") // Имя: Яков
// Протокол `Error` используется для перехвата выбрасываемых ошибок
enum MyError: Error {
- case BadValue(msg: String)
- case ReallyBadValue(msg: String)
+ case badValue(msg: String)
+ case reallyBadValue(msg: String)
}
// фунции помеченные словом `throws` должны вызываться с помощью `try`
func fakeFetch(value: Int) throws -> String {
guard 7 == value else {
- throw MyError.ReallyBadValue(msg: "Действительно плохое значение")
+ throw MyError.reallyBadValue(msg: "Действительно плохое значение")
}
return "тест"
@@ -401,7 +401,7 @@ func testTryStuff() {
do {
// обычно try оператор, позволяющий обработать ошибку в `catch` блоке
try fakeFetch(value: 1)
- } catch MyError.BadValue(let msg) {
+ } catch MyError.badValue(let msg) {
print("Ошибка: \(msg)")
} catch {
// все остальное
@@ -535,49 +535,49 @@ if let circle = myEmptyCircle {
// Они могут содержать методы подобно классам.
enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
// Значения перечислений допускают сокращенный синтаксис, нет необходимости
// указывать тип перечисления, когда переменная объявляется явно
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
// Значения нецелочисленных перечислений должны быть указаны явно
// или могут выводится с помощью функции `rawValue` из имени
enum BookName: String {
- case John
- case Luke = "Лука"
+ case john
+ case luke = "Лука"
}
-print("Имя: \(BookName.John.rawValue)")
+print("Имя: \(BookName.john.rawValue)")
// Перечисление (enum) со связанными значениями
enum Furniture {
// Связать с типом Int
- case Desk(height: Int)
+ case desk(height: Int)
// Связать с типами String и Int
- case Chair(String, Int)
+ case chair(String, Int)
func description() -> String {
switch self {
- case .Desk(let height):
+ case .desk(let height):
return "Письменный стол высотой \(height) см."
- case .Chair(let brand, let height):
+ case .chair(let brand, let height):
return "Стул марки \(brand) высотой \(height) см."
}
}
}
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
print(desk.description()) // "Письменный стол высотой 80 см."
-var chair = Furniture.Chair("Foo", 40)
+var chair = Furniture.chair("Foo", 40)
print(chair.description()) // "Стул марки Foo высотой 40 см."
diff --git a/swift.html.markdown b/swift.html.markdown
index 60915d72..516debed 100644
--- a/swift.html.markdown
+++ b/swift.html.markdown
@@ -361,14 +361,14 @@ print("Name is \(name)") // Name is Them
// The `Error` protocol is used when throwing errors to catch
enum MyError: Error {
- case BadValue(msg: String)
- case ReallyBadValue(msg: String)
+ case badValue(msg: String)
+ case reallyBadValue(msg: String)
}
// functions marked with `throws` must be called using `try`
func fakeFetch(value: Int) throws -> String {
guard 7 == value else {
- throw MyError.ReallyBadValue(msg: "Some really bad value")
+ throw MyError.reallyBadValue(msg: "Some really bad value")
}
return "test"
@@ -385,7 +385,7 @@ func testTryStuff() {
do {
// normal try operation that provides error handling via `catch` block
try fakeFetch(value: 1)
- } catch MyError.BadValue(let msg) {
+ } catch MyError.badValue(let msg) {
print("Error message: \(msg)")
} catch {
// must be exhaustive
@@ -518,49 +518,49 @@ if let circle = myEmptyCircle {
// They can contain methods like classes.
enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
// Enum values allow short hand syntax, no need to type the enum type
// when the variable is explicitly declared
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
// String enums can have direct raw value assignments
// or their raw values will be derived from the Enum field
enum BookName: String {
- case John
- case Luke = "Luke"
+ case john
+ case luke = "Luke"
}
-print("Name: \(BookName.John.rawValue)")
+print("Name: \(BookName.john.rawValue)")
// Enum with associated Values
enum Furniture {
// Associate with Int
- case Desk(height: Int)
+ case desk(height: Int)
// Associate with String and Int
- case Chair(String, Int)
+ case chair(String, Int)
func description() -> String {
switch self {
- case .Desk(let height):
+ case .desk(let height):
return "Desk with \(height) cm"
- case .Chair(let brand, let height):
+ case .chair(let brand, let height):
return "Chair of \(brand) with \(height) cm"
}
}
}
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
print(desk.description()) // "Desk with 80 cm"
-var chair = Furniture.Chair("Foo", 40)
+var chair = Furniture.chair("Foo", 40)
print(chair.description()) // "Chair of Foo with 40 cm"
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index e694d95d..4c2cf59b 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -443,47 +443,47 @@ if let daire = benimBosDairem {
// Sınıflar gibi metotlar içerebilirler.
enum Kart {
- case Kupa, Maca, Sinek, Karo
+ case kupa, maca, sinek, karo
func getIcon() -> String {
switch self {
- case .Maca: return "♤"
- case .Kupa: return "♡"
- case .Karo: return "♢"
- case .Sinek: return "♧"
+ case .maca: return "♤"
+ case .kupa: return "♡"
+ case .karo: return "♢"
+ case .sinek: return "♧"
}
}
}
// Enum değerleri kısayol syntaxa izin verir. Eğer değişken tipi açık olarak belirtildiyse enum tipini yazmaya gerek kalmaz.
-var kartTipi: Kart = .Kupa
+var kartTipi: Kart = .kupa
// Integer olmayan enumlar direk değer (rawValue) atama gerektirir.
enum KitapAdi: String {
- case John = "John"
- case Luke = "Luke"
+ case john = "John"
+ case luke = "Luke"
}
-print("Name: \(KitapAdi.John.rawValue)")
+print("Name: \(KitapAdi.john.rawValue)")
// Değerlerle ilişkilendirilmiş Enum
enum Mobilya {
// Int ile ilişkilendirilmiş
- case Masa(yukseklik: Int)
+ case masa(yukseklik: Int)
// String ve Int ile ilişkilendirilmiş
- case Sandalye(String, Int)
-
+ case sandalye(String, Int)
+
func aciklama() -> String {
switch self {
- case .Masa(let yukseklik):
+ case .masa(let yukseklik):
return "Masa boyu \(yukseklik) cm"
- case .Sandalye(let marka, let yukseklik):
+ case .sandalye(let marka, let yukseklik):
return "\(brand) marka sandalyenin boyu \(yukseklik) cm"
}
}
}
-var masa: Mobilya = .Masa(yukseklik: 80)
+var masa: Mobilya = .masa(yukseklik: 80)
print(masa.aciklama()) // "Masa boyu 80 cm"
-var sandalye = Mobilya.Sandalye("Foo", 40)
+var sandalye = Mobilya.sandalye("Foo", 40)
print(sandalye.aciklama()) // "Foo marka sandalyenin boyu 40 cm"
diff --git a/zh-cn/groovy-cn.html.markdown b/zh-cn/groovy-cn.html.markdown
index 562a0284..0e7a020c 100644
--- a/zh-cn/groovy-cn.html.markdown
+++ b/zh-cn/groovy-cn.html.markdown
@@ -219,10 +219,12 @@ for (i in array) {
//遍历映射
def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
-x = 0
+x = ""
for ( e in map ) {
x += e.value
+ x += " "
}
+assert x.equals("Roberto Grails Groovy ")
/*
运算符
diff --git a/zh-cn/swift-cn.html.markdown b/zh-cn/swift-cn.html.markdown
index cba9252d..c25b2918 100644
--- a/zh-cn/swift-cn.html.markdown
+++ b/zh-cn/swift-cn.html.markdown
@@ -445,47 +445,47 @@ if let circle = myEmptyCircle {
// 枚举可以像类一样，拥有方法
enum Suit {
- case Spades, Hearts, Diamonds, Clubs
+ case spades, hearts, diamonds, clubs
func getIcon() -> String {
switch self {
- case .Spades: return "♤"
- case .Hearts: return "♡"
- case .Diamonds: return "♢"
- case .Clubs: return "♧"
+ case .spades: return "♤"
+ case .hearts: return "♡"
+ case .diamonds: return "♢"
+ case .clubs: return "♧"
}
}
}
// 当变量类型明确指定为某个枚举类型时，赋值时可以省略枚举类型
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
// 非整型的枚举类型需要在定义时赋值
enum BookName: String {
- case John = "John"
- case Luke = "Luke"
+ case john = "John"
+ case luke = "Luke"
}
-print("Name: \(BookName.John.rawValue)")
+print("Name: \(BookName.john.rawValue)")
// 与特定数据类型关联的枚举
enum Furniture {
// 和 Int 型数据关联的枚举记录
- case Desk(height: Int)
+ case desk(height: Int)
// 和 String, Int 关联的枚举记录
- case Chair(brand: String, height: Int)
+ case chair(brand: String, height: Int)
func description() -> String {
switch self {
- case .Desk(let height):
+ case .desk(let height):
return "Desk with \(height) cm"
- case .Chair(let brand, let height):
+ case .chair(let brand, let height):
return "Chair of \(brand) with \(height) cm"
}
}
}
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
print(desk.description()) // "Desk with 80 cm"
-var chair = Furniture.Chair(brand: "Foo", height: 40)
+var chair = Furniture.chair(brand: "Foo", height: 40)
print(chair.description()) // "Chair of Foo with 40 cm"