diff options
31 files changed, 1693 insertions, 146 deletions
diff --git a/bash.html.markdown b/bash.html.markdown index 76710aa8..981d7a1e 100644 --- a/bash.html.markdown +++ b/bash.html.markdown @@ -15,6 +15,7 @@ contributors: - ["Leo Rudberg", "https://github.com/LOZORD"] - ["Betsy Lorton", "https://github.com/schbetsy"] - ["John Detter", "https://github.com/jdetter"] + - ["Harry Mumford-Turner", "https://github.com/harrymt"] filename: LearnBash.sh --- @@ -235,10 +236,8 @@ EOF python hello.py < "input.in" # pass input.in as input to the script python hello.py > "output.out" # redirect output from the script to output.out python hello.py 2> "error.err" # redirect error output to error.err -python hello.py > "output-and-error.log" 2>&1 # redirect both output and - # errors to output-and-error.log -python hello.py > /dev/null 2>&1 # redirect all output and errors to - # the black hole, /dev/null, i.e., no output +python hello.py > "output-and-error.log" 2>&1 # redirect both output and errors to output-and-error.log +python hello.py > /dev/null 2>&1 # redirect all output and errors to the black hole, /dev/null, i.e., no output # The output error will overwrite the file if it exists, # if you want to append instead, use ">>": python hello.py >> "output.out" 2>> "error.err" diff --git a/c.html.markdown b/c.html.markdown index 1ff8658c..87a047be 100644 --- a/c.html.markdown +++ b/c.html.markdown @@ -348,7 +348,7 @@ int main (int argc, char** argv) printf("Error occurred at i = %d & j = %d.\n", i, j); /* https://ideone.com/GuPhd6 - this will print out "Error occurred at i = 52 & j = 99." + this will print out "Error occurred at i = 51 & j = 99." */ /////////////////////////////////////// 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/haml.html.markdown b/haml.html.markdown index 5dd4cb6d..bb8bdc54 100644 --- a/haml.html.markdown +++ b/haml.html.markdown @@ -3,6 +3,7 @@ language: haml filename: learnhaml.haml contributors: - ["Simon Neveu", "https://github.com/sneveu"] + - ["Vasiliy Petrov", "https://github.com/Saugardas"] --- Haml is a markup language predominantly used with Ruby that cleanly and simply describes the HTML of any web document without the use of inline code. It is a popular alternative to using Rails templating language (.erb) and allows you to embed Ruby code into your markup. @@ -11,7 +12,9 @@ It aims to reduce repetition in your markup by closing tags for you based on the You can also use Haml on a project independent of Ruby, by installing the Haml gem on your machine and using the command line to convert it to html. +```shell $ haml input_file.haml output_file.html +``` ```haml @@ -55,8 +58,17 @@ $ haml input_file.haml output_file.html </header> </body> -/ The div tag is the default element, so they can be written simply like this -.foo +/ + The div tag is the default element, so it can be omitted. + You can define only class/id using . or # + For example + +%div.my_class + %div#my_id + +/ Can be written +.my_class + #my_id / To add content to a tag, add the text directly after the declaration %h1 Headline copy @@ -97,6 +109,15 @@ $ haml input_file.haml output_file.html / To write data-attributes, use the :data key with its value as another hash %div{:data => {:attribute => 'foo'}} +/ For Ruby version 1.9 or higher you can use Ruby's new hash syntax +%div{ data: { attribute: 'foo' } } + +/ Also you can use HTML-style attribute syntax. +%a(href='#' title='bar') + +/ And both syntaxes together +%a(href='#'){ title: @my_class.title } + / ------------------------------------------- / Inserting Ruby @@ -120,7 +141,7 @@ $ haml input_file.haml output_file.html - books.shuffle.each_with_index do |book, index| %h1= book - if book do + - if book do %p This is a book / Adding ordered / unordered list @@ -166,12 +187,33 @@ $ haml input_file.haml output_file.html / ------------------------------------------- / - Use the colon to define Haml filters, one example of a filter you can - use is :javascript, which can be used for writing inline js + Filters pass the block to another filtering program and return the result in Haml + To use a filter, type a colon and the name of the filter + +/ Markdown filter +:markdown + # Header + Text **inside** the *block* + +/ The code above is compiled into +<h1>Header</h1> + +<p>Text <strong>inside</strong> the <em>block</em></p> + +/ Javascript filter :javascript console.log('This is inline <script>'); +/ is compiled into +<script> + console.log('This is inline <script>'); +</script> + +/ + There are many types of filters (:markdown, :javascript, :coffee, :css, :ruby and so on) + Also you can define your own filters using Haml::Filters + ``` ## Additional resources diff --git a/id-id/hq9+-id.html.markdown b/id-id/hq9+-id.html.markdown new file mode 100644 index 00000000..46abcf42 --- /dev/null +++ b/id-id/hq9+-id.html.markdown @@ -0,0 +1,45 @@ +--- +language: HQ9+ +filename: hq9+-id.html +contributors: + - ["Alexey Nazaroff", "https://github.com/rogaven"] +translators: + - ["Haydar Ali Ismail", "http://github.com/haydarai"] +lang: id-id +--- + +HQ9+ adalah bahasa pemrograman gurauan yang dibuat oleh Cliff Biffle. Bahasa +ini hanya memiliki empat perintah dan tidak memenuhi Turing-complete. + +``` +Hanya ada 4 perintah, masing-masing direpresentasikan oleh karakter berikut +H: mencetak "Hello, world!" +Q: mencetak kode sumber dari program ini (Quine) +9: mencetak lirik dari lagu "99 Bottles of Beer" ++: menambah nilai satu ke akumulator (nilai dari akumulator tidak dapat + diakses) +Karakter lain akan dihiraukan. + +Ok. Mari kita menulis beberapa program: + HQ9 + +Hasil: + Hello world! + HQ9 + +HQ9+ sangat sederhana, tetapi membuat anda bisa melakukan hal yang sangat sulit +dilakukan di bahasa lain. Sebagai contoh, berikut sebuah program yang +menciptakan tiga salinan dirinya sendiri ke layar: + QQQ + +Ini menghasilakn: + QQQ + QQQ + QQQ +``` + +Dan itu semuanya. Ada banyak interpreters untuk HQ9+. Kamu bisa menemukannya di +bawah + ++ [Salah satu interpreter online](https://almnet.de/esolang/hq9plus.php) ++ [Website resmi HQ9+](http://cliffle.com/esoterica/hq9plus.html) diff --git a/id-id/rst-id.html.markdown b/id-id/rst-id.html.markdown new file mode 100644 index 00000000..06d80089 --- /dev/null +++ b/id-id/rst-id.html.markdown @@ -0,0 +1,122 @@ +--- +language: restructured text (RST) +filename: rst-id.html +contributors: + - ["DamienVGN", "https://github.com/martin-damien"] + - ["Andre Polykanine", "https://github.com/Oire"] +translators: + - ["Haydar Ali Ismail", "https://github.com/haydarai"] +lang: id-id +--- + +RST adalah sebual format file yang dibuat oleh komunitas Python untuk menulis +dokumentasi (dan menjadi bagian dari Docutils). + +File-file RST adalah sebuah file-file teks simpel dengan sintaks yang ringan +(dibandingkan dengan HTML). + + +## Pemasangan + +Untuk menggunakan RST, anda harus memasang [Python](http://www.python.org) dan +paket `docutils` terlebih dahulu. + +`docutils` bisa dipasang menggunakan command berikut: + +```bash +$ easy_install docutils +``` + +Jika sistem anda sudah mempunyai `pip`, anda bisa menggunakannya juga: + +```bash +$ pip install docutils +``` + + +## Sintaks file + +Sebuah contoh sederhana dari sintaks file: + +``` +.. Baris yang dimulai dengan dua titik adalah perintah spesial. Tetapi jika +perintah tidak ditemukan, maka baris tersebut akan dianggap sebagai komentar + +=============================================================================== +Judul utama ditulis menggunakan rentetan tanda sama dengan di atas dan bawahnya +=============================================================================== + +Ingat bahwa jumlah tanda sama dengan harus sama panjangnya dengan total +karakter judul + +Judul juga digarisbawahi dengan tanda sama dengan juga +====================================================== + +Sub-judul dengan menggunakan dash +--------------------------------- + +Dan sub-sub-judul dengan menggunakan tilde +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Anda bisa menulis teks dalam *italik* atau *tebal*, anda bisa "menandai" teks +sebagai kode dengan menggunakan backquote ganda ``: ``print()``. + +Membuat daftar semudah seperti dalam Markdown: + +- Barang pertama +- Barang kedua + - Sub barang + +atau + +* Barang pertama +* Barang kedua + * Sub barang + +Tabel sangat mudah untuk ditulis: + +=========== ======== +Negara Ibu Kota +=========== ======== +Prancis Paris +Jepang Tokyo +=========== ======== + +Tabel yang lebih kompleks bisa dibuat dengan mudah (kolom tergabung atau/dan +baris) tetapi saya menyarankan anda untuk membaca dokumentasi lengkap tentang +ini :) + +Ada berbagai macam cara untuk membuat tautan: + +- Dengan menambahkan garis bawah setelah sebuah huruf : Github_ dan dengan +menambahkan URL target setelah teks (cara ini mempunyai kelebihan dengan tidak +memasukkan URL yang tidak penting ke dalam teks yang bisa dibaca). +- Dengan mengetik URL lengkap yang dapat dipahami : https://github.com (akan +otomatis diubah menjadi sebuah link) +- Dengan membuat link seperti di Markdown: `Github <https://github.com/>`_ . + +.. _Github https://github.com/ + +``` + + +## Bagaimana Cara Menggunakannya + +RST hadir dengan docutils di mana anda mempunyai `rst2html`, sebagai contoh: + +```bash +$ rst2html fileku.rst hasil.html +``` + +*Catatan : Di beberapa sistem, perintah tersebut bisa menjadi rst2html.py* + +Tetapi ada beberapa aplikasi kompleks yang menggunakan format RST: + +- [Pelican](http://blog.getpelican.com/), Generator web statik +- [Sphinx](http://sphinx-doc.org/), Generator dokumnetasi +- dan masih banyak lainnya + + +## Bacaan + +- [Referensi singkat resmi](http://docutils.sourceforge.net/docs/user/rst/quickref.html) diff --git a/it-it/html-it.html.markdown b/it-it/html-it.html.markdown new file mode 100644 index 00000000..1d2a0618 --- /dev/null +++ b/it-it/html-it.html.markdown @@ -0,0 +1,120 @@ +--- +language: html +filename: learnhtml-it.html +contributors: + - ["Christophe THOMAS", "https://github.com/WinChris"] +translators: + - ["Ale46", "http://github.com/Ale46/"] +--- + +HTML sta per HyperText Markup Language (linguaggio a marcatori per ipertesti). +È un linguaggio che consente di scrivere pagine web per il world wide web. +È un linguaggio di markup, che permette di scrivere pagine web usando del codice che indica come il testo ed i dati devono essere mostrati. +Infatti, i files html sono semplici file di testo. +Cos'è il markup? È un metodo per organizzare i dati della pagina circondandoli con tag di apertura e tag di chiusura. +Questo markup serve a dare significato al testo che racchiude. +Come altri linguaggi di programmazione, HTML ha molte versioni. Qui discuteremo di HTML5. + +**NOTA :** Puoi testare i differenti tags ed elementi man mano che prosegui nel tutorial in un sito come [codepen](http://codepen.io/pen/) per vedere i loro effetti, capire come lavorano e familiarizzare con il linguaggio. +Questo articolo riguarda principalmente la sintassi HTML ed alcuni suggerimenti utili. + + +```html +<!-- I commenti sono racchiusi come in questa riga! --> + +<!-- #################### I Tags #################### --> + +<!-- Ecco un esempio di file HTML che andremo ad analizzare. --> + +<!doctype html> + <html> + <head> + <title>Il mio sito</title> + </head> + <body> + <h1>Ciao, mondo!</h1> + <a href = "http://codepen.io/anon/pen/xwjLbZ">Vieni a vedere ciò che mostra</a> + <p>Questo è un paragrafo.</p> + <p>Questo è un altro paragrafo.</p> + <ul> + <li>Questo è un elemento di un elenco non numerato (elenco puntato)</li> + <li>Questo è un altro elemento</li> + <li>E questo è l'ultimo elemento dell'elenco</li> + </ul> + </body> + </html> + +<!-- Un file HTML inizia sempre indicando al browser che la pagina è HTML. --> +<!doctype html> + +<!-- Dopo questo, inizia aprendo un tag <html>. --> +<html> + +<!-- che sarà chiuso alla fine del file con </html>. --> +</html> + +<!-- Nulla dovrebbe apparire dopo questo tag finale. --> + +<!-- All'interno (tra i tag di apertura e chiusura <html> </html>) troviamo: --> + +<!-- Un'intestazione definita da <head> (deve essere chiusa con </head>). --> +<!-- L'intestazione contiene alcune descrizioni e informazioni aggiuntive non visualizzate; questi sono i metadati. --> + +<head> + <title>Il mio sito</title> <!-- Il tag <title> indica al browser il titolo da mostrare nella barra del titolo della finestra del browser e nel nome della scheda. --> +</head> + +<!-- Dopo la sezione <head>, troviamo il tag - <body> --> +<!-- Fino a questo punto, niente di ciò che abbiamo descritto verrà visualizzato nella finestra del browser. --> +<!-- Dobbiamo riempire il corpo con il contenuto da visualizzare. --> + +<body> + <h1>Ciao, mondo!</h1> <!-- Il tag h1 crea un titolo. --> + <!-- Ci sono anche sottotitoli a <h1> dal più importante (h2) al più preciso (h6). --> + <a href = "http://codepen.io/anon/pen/xwjLbZ">Vieni a vedere ciò che mostra</a> <!-- un collegamento ipertestuale all'URL fornito dall'attributo href="" --> + <p>Questo è un paragrafo.</p> <!-- Il tag <p> ci permette di includere del testo nella pagina html. --> + <p>Questo è un altro paragrafo.</p> + <ul> <!-- Il tag <ul> crea un elenco puntato. --> + <!-- Per avere un elenco numerato, invece, usiamo <ol> che restituisce 1. per il primo elemento, 2. per il secondo, etc. --> + <li>Questo è un elemento in un elenco non elencato (elenco puntato)</li> + <li>Questo è un altro elemento</li> + <li>E questo è l'ultimo elemento dell'elenco</li> + </ul> +</body> + +<!-- E questo è tutto, creare un file HTML può essere molto semplice. --> + +<!-- Ma è possibile aggiungere molti altri tipi di tag HTML. --> + +<!-- Per inserire un'immagine. --> +<img src="http://i.imgur.com/XWG0O.gif"/> <!-- La fonte dell'immagine viene indicata usando l'attributo src="" --> +<!-- La fonte può essere un URL o persino un percorso di un file sul tuo computer. --> + +<!-- È anche possibile creare una tabella. --> + +<table> <!-- Apriamo un elemento <table>. --> + <tr> <!-- <tr> ci permette di creare una riga. --> + <th>Prima intestazione</th> <!-- <th> ci permette di dare un titolo ad una colonna della tabella. --> + <th>Seconda intestazione</th> + </tr> + <tr> + <td>prima riga, prima colonna</td> <!-- <td> ci permette di creare una cella della tabella. --> + <td>prima riga, seconda colonna</td> + </tr> + <tr> + <td>seconda riga, prima colonna</td> + <td>seconda riga, seconda colonna</td> + </tr> +</table> + +``` + +## Uso + +HTML è scritto in files che finiscono con `.html`. + +## Per saperne di più + +* [wikipedia](https://it.wikipedia.org/wiki/HTML) +* [HTML tutorial](https://developer.mozilla.org/it/docs/Web/HTML) +* [W3School](http://www.w3schools.com/html/html_intro.asp) diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown index aeb42658..8d6d4385 100644 --- a/it-it/matlab-it.html.markdown +++ b/it-it/matlab-it.html.markdown @@ -217,7 +217,7 @@ A .* B % Moltiplica ogni elemento di A per il corrispondente elemento di B % l'altra (il cui nome termina con m) agisce sull'intera matrice. exp(A) % Calcola l'esponenziale di ogni elemento expm(A) % Calcola la matrice esponenziale -sqrt(A) % Calcola la radice quadrata di ogni elementotake the square root of each element +sqrt(A) % Calcola la radice quadrata di ogni elemento sqrtm(A) % Trova la matrice di cui A nè è la matrice quadrata diff --git a/java.html.markdown b/java.html.markdown index fa1ff3d1..7b59b085 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -418,6 +418,8 @@ public class LearnJava { // String class, and a few special classes that wrap primitive types: // Character, Byte, Short, and Integer. // Starting in Java 7 and above, we can also use the String type. + // Note: Do remember that, not adding "break" at end any particular case ends up in + // executing the very next case(given it satisfies the condition provided) as well. int month = 3; String monthString; switch (month) { @@ -660,7 +662,7 @@ public interface Edible { public interface Digestible { public void digest(); // Since Java 8, interfaces can have default method. - public void defaultMethod() { + public default void defaultMethod() { System.out.println("Hi from default method ..."); } } @@ -886,6 +888,8 @@ The links provided here below are just to get an understanding of the topic, fee * [Codingbat.com](http://codingbat.com/java) +* [Codewars - Java Katas](https://www.codewars.com/?language=java) + **Books**: * [Head First Java](http://www.headfirstlabs.com/books/hfjava/) diff --git a/pt-br/amd.html.markdown b/pt-br/amd-pt.html.markdown index 38c1f70f..38c1f70f 100644 --- a/pt-br/amd.html.markdown +++ b/pt-br/amd-pt.html.markdown diff --git a/pt-br/bf.html.markdown b/pt-br/bf-pt.html.markdown index 52a5269e..52a5269e 100644 --- a/pt-br/bf.html.markdown +++ b/pt-br/bf-pt.html.markdown diff --git a/pt-br/csharp.html.markdown b/pt-br/csharp-pt.html.markdown index 547f4817..547f4817 100644 --- a/pt-br/csharp.html.markdown +++ b/pt-br/csharp-pt.html.markdown diff --git a/pt-br/elixir.html.markdown b/pt-br/elixir-pt.html.markdown index f8c56101..f8c56101 100644 --- a/pt-br/elixir.html.markdown +++ b/pt-br/elixir-pt.html.markdown 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/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown new file mode 100644 index 00000000..10d55784 --- /dev/null +++ b/pt-br/pyqt-pt.html.markdown @@ -0,0 +1,92 @@ +--- +category: tool +tool: PyQT +filename: learnpyqt-pt.py +contributors: + - ["Nathan Hughes", "https://github.com/sirsharpest"] +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++*. + + +Essa é uma adaptação de uma introdução ao QT em C++ por +[Aleksey Kholovchuk](https://github.com/vortexxx192), alguns dos exemplos de +código podem resultar na mesma funcionalidade que essa versão, apenas usando +o pyqt! + +```python +import sys +from PyQt4 import QtGui + +def window(): + # Cria um objeto para a aplicação + app = QtGui.QApplication(sys.argv) + # Cria um widget onde o nosso label será inserido + w = QtGui.QWidget() + # Adiciona um label ao widget + b = QtGui.QLabel(w) + # Informa algum texto ao label + b.setText("Hello World!") + # Define os tamanhos e posições dos objetos + w.setGeometry(100, 100, 200, 50) + b.move(50, 20) + # Define o título da janela + w.setWindowTitle("PyQt") + # Exibe a janela + w.show() + # Executa tudo o que foi pedido, apenas uma vez + sys.exit(app.exec_()) + +if __name__ == '__main__': + window() + +``` + +Para utilizar mais funcionalidades no **pyqt** veremos a construção de alguns +outros elementos. +Aqui mostraremos como criar uma janela popup, muito útil para perguntar ao +usuário qual decisão tomar ou exibir alguma informação. + +```Python +import sys +from PyQt4.QtGui import * +from PyQt4.QtCore import * + + +def window(): + app = QApplication(sys.argv) + w = QWidget() + # Cria um botão e o anexa ao widget w + b = QPushButton(w) + b.setText("Press me") + b.move(50, 50) + # Informa b a chamar essa função quando for clicado + # observe que a função chamada não necessita de "()" + b.clicked.connect(showdialog) + w.setWindowTitle("PyQt Dialog") + w.show() + sys.exit(app.exec_()) + +# Essa função deve criar uma janela de diálogo com um botão, +# aguarda ser clicado e encerra o programa +def showdialog(): + d = QDialog() + b1 = QPushButton("ok", d) + b1.move(50, 50) + d.setWindowTitle("Dialog") + # Essa modalidade define que o popup deve bloquear as outras janelas quando ativo + d.setWindowModality(Qt.ApplicationModal) + # Ao ser clicado deve encerrar o processo + b1.clicked.connect(sys.exit) + d.exec_() + +if __name__ == '__main__': + window() +``` 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/bf.html.markdown b/pt-pt/bf-pt.html.markdown index 13c22387..13c22387 100644 --- a/pt-pt/bf.html.markdown +++ b/pt-pt/bf-pt.html.markdown diff --git a/pt-pt/swift.html.markdown b/pt-pt/swift-pt.html.markdown index 9462ee1c..6b263942 100644 --- a/pt-pt/swift.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" |