From cfb7b656ae16c803485c7a30365e43f11c12f63d Mon Sep 17 00:00:00 2001 From: Mathieu Gemard Date: Mon, 9 Oct 2017 12:03:58 +0200 Subject: [java/fr] -Create java-fr.html.markdown (#2762) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Create java-fr.html.markdown * Update java-fr.html.markdown * Update java-fr.html.markdown translation finished * typos * [java/en] changement switch/polymorphisme/interface * [java/fr] ajout d'un exemple pour l'opérateur ?: On pouvait penser qu'il fallait obligatoirement utiliser = avec ?: * [java/fr] typo --- fr-fr/java-fr.html.markdown | 939 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 939 insertions(+) create mode 100644 fr-fr/java-fr.html.markdown (limited to 'fr-fr') 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 + int fooInt; + // Declarez plusieurs variables du même type , , + // + int fooInt1, fooInt2, fooInt3; + + /* + * Initialisation de variable + */ + + // Initialisez une variable sous la forme = + int barInt = 1; + // Initialisez plusieurs variables du même type et avec la même valeur + // sous la forme + // , , + // = = = + 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 + // [] = new []; + // [] = new []; + 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(; ; ) + 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 ( : ) + // 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 + // sinon utilisez la ". + 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 COUNTRIES = new HashSet(); + 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 COUNTRIES = new HashSet() {{ + 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: +// class { +// // 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 : + // ( + // ) + + // 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 +// interface extends { +// // 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: +// abstract class extends { +// // 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 +// 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: + // final () + + // 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) -- cgit v1.2.3 From 0aaae2653cc4edef745c7f0de2b5c038097337d2 Mon Sep 17 00:00:00 2001 From: LukaxFeh <32396925+LukaxFeh@users.noreply.github.com> Date: Sun, 29 Oct 2017 13:09:01 -0200 Subject: Fix file names in french (#2984) * fix file name * fix file names * fix file names * fix file names * fix file names * fix file names --- fr-fr/d-fr.html.markdown | 264 +++++++++++++++ fr-fr/d.html.markdown | 264 --------------- fr-fr/haskell-fr.html.markdown | 431 +++++++++++++++++++++++++ fr-fr/haskell.html.markdown | 431 ------------------------- fr-fr/markdown-fr.html.markdown | 289 +++++++++++++++++ fr-fr/markdown.html.markdown | 289 ----------------- fr-fr/php-fr.html.markdown | 697 ++++++++++++++++++++++++++++++++++++++++ fr-fr/php.html.markdown | 697 ---------------------------------------- fr-fr/scala-fr.html.markdown | 460 ++++++++++++++++++++++++++ fr-fr/scala.html.markdown | 460 -------------------------- fr-fr/vim-fr.html.markdown | 239 ++++++++++++++ fr-fr/vim.html.markdown | 239 -------------- 12 files changed, 2380 insertions(+), 2380 deletions(-) create mode 100644 fr-fr/d-fr.html.markdown delete mode 100644 fr-fr/d.html.markdown create mode 100644 fr-fr/haskell-fr.html.markdown delete mode 100644 fr-fr/haskell.html.markdown create mode 100644 fr-fr/markdown-fr.html.markdown delete mode 100644 fr-fr/markdown.html.markdown create mode 100644 fr-fr/php-fr.html.markdown delete mode 100644 fr-fr/php.html.markdown create mode 100644 fr-fr/scala-fr.html.markdown delete mode 100644 fr-fr/scala.html.markdown create mode 100644 fr-fr/vim-fr.html.markdown delete mode 100644 fr-fr/vim.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/d-fr.html.markdown b/fr-fr/d-fr.html.markdown new file mode 100644 index 00000000..8d98f9dc --- /dev/null +++ b/fr-fr/d-fr.html.markdown @@ -0,0 +1,264 @@ +--- +language: D +filename: learnd-fr.d +contributors: + - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"] +translators: + - ["Quentin Ladeveze", "aceawan.eu"] +lang: fr-fr +--- + +```c +// Commençons par un classique +module hello; + +import std.stdio; + +// args n'est pas obligatoire +void main(string[] args) { + writeln("Bonjour le monde !"); +} +``` + +Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a +de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/). +D est un langage de programmation moderne, généraliste, multi-paradigmes qui contient +des fonctionnalités aussi bien de bas niveau que de haut niveau. + +D est activement développé par de nombreuses personnes très intelligents, guidées par +[Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et +[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu). +Après cette petite introduction, jetons un coup d'oeil à quelques exemples. + +```c +import std.stdio; + +void main() { + //Les conditions et les boucles sont classiques. + for(int i = 0; i < 10000; i++) { + writeln(i); + } + + // On peut utiliser auto pour inférer automatiquement le + // type d'une variable. + auto n = 1; + + // On peut faciliter la lecture des valeurs numériques + // en y insérant des `_`. + while(n < 10_000) { + n += n; + } + + do { + n -= (n / 2); + } while(n > 0); + + // For et while sont très utiles, mais en D, on préfère foreach. + // Les deux points : '..', créent un intervalle continu de valeurs + // incluant la première mais excluant la dernière. + foreach(i; 1..1_000_000) { + if(n % 2 == 0) + writeln(i); + } + + // On peut également utiliser foreach_reverse pour itérer à l'envers. + foreach_reverse(i; 1..int.max) { + if(n % 2 == 1) { + writeln(i); + } else { + writeln("Non !"); + } + } +} +``` +On peut définir de nouveaux types avec les mots-clés `struct`, `class`, +`union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés) +De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques. + +```c +// Ici, 'T' est un paramètre de type. Il est similaire au de C++/C#/Java. +struct LinkedList(T) { + T data = null; + + // Utilisez '!' pour instancier un type paramétré. + // Encore une fois semblable à '' + LinkedList!(T)* next; +} + +class BinTree(T) { + T data = null; + + // S'il n'y a qu'un seul paramètre de template, + // on peut s'abstenir de mettre des parenthèses. + BinTree!T left; + BinTree!T right; +} + +enum Day { + Sunday, + Monday, + Tuesday, + Wednesday, + Thursday, + Friday, + Saturday, +} + +// Utilisez alias pour créer des abreviations pour les types. +alias IntList = LinkedList!int; +alias NumTree = BinTree!double; + +// On peut tout aussi bien créer des templates de function ! +T max(T)(T a, T b) { + if(a < b) + return b; + + return a; +} + +// On peut utiliser le mot-clé ref pour s'assurer que quelque chose est passé +// par référence, et ceci, même si a et b sont d'ordinaire passés par valeur. +// Ici ils seront toujours passés par référence à 'swap()'. +void swap(T)(ref T a, ref T b) { + auto temp = a; + + a = b; + b = temp; +} + +// Avec les templates, on peut également passer des valeurs en paramètres. +class Matrix(uint m, uint n, T = int) { + T[m] rows; + T[n] columns; +} + +auto mat = new Matrix!(3, 3); // T est 'int' par défaut + +``` +À propos de classes, parlons des propriétés. Une propriété est, en gros, +une méthode qui peut se comporter comme une lvalue. On peut donc utiliser +la syntaxe des structures classiques (`struct.x = 7`) comme si il +s'agissait de méthodes getter ou setter. + +```c +// Considérons une classe paramétrée avec les types 'T' et 'U' +class MyClass(T, U) { + T _data; + U _other; +} + +// Et des méthodes "getter" et "setter" comme suit: +class MyClass(T, U) { + T _data; + U _other; + + // Les constructeurs s'appellent toujours 'this'. + this(T t, U u) { + // Ceci va appeller les setters ci-dessous. + data = t; + other = u; + } + + // getters + @property T data() { + return _data; + } + + @property U other() { + return _other; + } + + // setters + @property void data(T t) { + _data = t; + } + + @property void other(U u) { + _other = u; + } +} + +// Et on l'utilise de cette façon: +void main() { + auto mc = new MyClass!(int, string)(7, "seven"); + + // Importer le module 'stdio' de la bibliothèque standard permet + // d'écrire dans la console (les imports peuvent être locaux à une portée) + import std.stdio; + + // On appelle les getters pour obtenir les valeurs. + writefln("Earlier: data = %d, str = %s", mc.data, mc.other); + + // On appelle les setter pour assigner de nouvelles valeurs. + mc.data = 8; + mc.other = "eight"; + + // On appelle les setter pour obtenir les nouvelles valeurs. + writefln("Later: data = %d, str = %s", mc.data, mc.other); +} +``` +Avec les propriétés, on peut construire nos setters et nos getters +comme on le souhaite, tout en gardant une syntaxe très propre, +comme si on accédait directement à des membres de la classe. + +Les autres fonctionnalités orientées objets à notre disposition +incluent les interfaces, les classes abstraites, et la surcharge +de méthodes. D gère l'héritage comme Java: On ne peut hériter que +d'une seule classe et implémenter autant d'interface que voulu. + +Nous venons d'explorer les fonctionnalités objet du D, mais changeons +un peu de domaine. D permet la programmation fonctionelle, avec les fonctions +de premier ordre, les fonctions `pures` et les données immuables. +De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter) +sont disponibles dans le module `std.algorithm`. + +```c +import std.algorithm : map, filter, reduce; +import std.range : iota; // construit un intervalle excluant la dernière valeur. + +void main() { + // On veut un algorithme qui affiche la somme de la liste des carrés + // des entiers paires de 1 à 100. Un jeu d'enfant ! + + // On se contente de passer des expressions lambda en paramètre à des templates. + // On peut fournir au template n'importe quelle fonction, mais dans notre + // cas, les lambdas sont pratiques. + auto num = iota(1, 101).filter!(x => x % 2 == 0) + .map!(y => y ^^ 2) + .reduce!((a, b) => a + b); + + writeln(num); +} +``` + +Vous voyez qu'on a calculé `num` comme on le ferait en haskell par exemple ? +C'est grâce à une innovation de D qu'on appelle "Uniform Function Call Syntax". +Avec l'UFCS, on peut choisir d'écrire un appel à une fonction de manière +classique, ou comme un appel à une méthode. Walter Brighter a écrit un +article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) +Pour faire court, on peut appeller une fonction dont le premier paramètre +est de type A, comme si c'était une méthode de A. + +J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça. +Voyons comment on le fait en D ! + +```c +import std.stdio; +import std.parallelism : parallel; +import std.math : sqrt; + +void main() { + // On veut calculer la racine carrée de tous les nombres + // dans notre tableau, et profiter de tous les coeurs + // à notre disposition. + auto arr = new double[1_000_000]; + + // On utilise un index et une référence à chaque élément du tableau. + // On appelle juste la fonction parallel sur notre tableau ! + foreach(i, ref elem; parallel(arr)) { + ref = sqrt(i + 1.0); + } +} + + +``` diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown deleted file mode 100644 index 8d98f9dc..00000000 --- a/fr-fr/d.html.markdown +++ /dev/null @@ -1,264 +0,0 @@ ---- -language: D -filename: learnd-fr.d -contributors: - - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"] -translators: - - ["Quentin Ladeveze", "aceawan.eu"] -lang: fr-fr ---- - -```c -// Commençons par un classique -module hello; - -import std.stdio; - -// args n'est pas obligatoire -void main(string[] args) { - writeln("Bonjour le monde !"); -} -``` - -Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a -de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/). -D est un langage de programmation moderne, généraliste, multi-paradigmes qui contient -des fonctionnalités aussi bien de bas niveau que de haut niveau. - -D est activement développé par de nombreuses personnes très intelligents, guidées par -[Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et -[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu). -Après cette petite introduction, jetons un coup d'oeil à quelques exemples. - -```c -import std.stdio; - -void main() { - //Les conditions et les boucles sont classiques. - for(int i = 0; i < 10000; i++) { - writeln(i); - } - - // On peut utiliser auto pour inférer automatiquement le - // type d'une variable. - auto n = 1; - - // On peut faciliter la lecture des valeurs numériques - // en y insérant des `_`. - while(n < 10_000) { - n += n; - } - - do { - n -= (n / 2); - } while(n > 0); - - // For et while sont très utiles, mais en D, on préfère foreach. - // Les deux points : '..', créent un intervalle continu de valeurs - // incluant la première mais excluant la dernière. - foreach(i; 1..1_000_000) { - if(n % 2 == 0) - writeln(i); - } - - // On peut également utiliser foreach_reverse pour itérer à l'envers. - foreach_reverse(i; 1..int.max) { - if(n % 2 == 1) { - writeln(i); - } else { - writeln("Non !"); - } - } -} -``` -On peut définir de nouveaux types avec les mots-clés `struct`, `class`, -`union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés) -De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques. - -```c -// Ici, 'T' est un paramètre de type. Il est similaire au de C++/C#/Java. -struct LinkedList(T) { - T data = null; - - // Utilisez '!' pour instancier un type paramétré. - // Encore une fois semblable à '' - LinkedList!(T)* next; -} - -class BinTree(T) { - T data = null; - - // S'il n'y a qu'un seul paramètre de template, - // on peut s'abstenir de mettre des parenthèses. - BinTree!T left; - BinTree!T right; -} - -enum Day { - Sunday, - Monday, - Tuesday, - Wednesday, - Thursday, - Friday, - Saturday, -} - -// Utilisez alias pour créer des abreviations pour les types. -alias IntList = LinkedList!int; -alias NumTree = BinTree!double; - -// On peut tout aussi bien créer des templates de function ! -T max(T)(T a, T b) { - if(a < b) - return b; - - return a; -} - -// On peut utiliser le mot-clé ref pour s'assurer que quelque chose est passé -// par référence, et ceci, même si a et b sont d'ordinaire passés par valeur. -// Ici ils seront toujours passés par référence à 'swap()'. -void swap(T)(ref T a, ref T b) { - auto temp = a; - - a = b; - b = temp; -} - -// Avec les templates, on peut également passer des valeurs en paramètres. -class Matrix(uint m, uint n, T = int) { - T[m] rows; - T[n] columns; -} - -auto mat = new Matrix!(3, 3); // T est 'int' par défaut - -``` -À propos de classes, parlons des propriétés. Une propriété est, en gros, -une méthode qui peut se comporter comme une lvalue. On peut donc utiliser -la syntaxe des structures classiques (`struct.x = 7`) comme si il -s'agissait de méthodes getter ou setter. - -```c -// Considérons une classe paramétrée avec les types 'T' et 'U' -class MyClass(T, U) { - T _data; - U _other; -} - -// Et des méthodes "getter" et "setter" comme suit: -class MyClass(T, U) { - T _data; - U _other; - - // Les constructeurs s'appellent toujours 'this'. - this(T t, U u) { - // Ceci va appeller les setters ci-dessous. - data = t; - other = u; - } - - // getters - @property T data() { - return _data; - } - - @property U other() { - return _other; - } - - // setters - @property void data(T t) { - _data = t; - } - - @property void other(U u) { - _other = u; - } -} - -// Et on l'utilise de cette façon: -void main() { - auto mc = new MyClass!(int, string)(7, "seven"); - - // Importer le module 'stdio' de la bibliothèque standard permet - // d'écrire dans la console (les imports peuvent être locaux à une portée) - import std.stdio; - - // On appelle les getters pour obtenir les valeurs. - writefln("Earlier: data = %d, str = %s", mc.data, mc.other); - - // On appelle les setter pour assigner de nouvelles valeurs. - mc.data = 8; - mc.other = "eight"; - - // On appelle les setter pour obtenir les nouvelles valeurs. - writefln("Later: data = %d, str = %s", mc.data, mc.other); -} -``` -Avec les propriétés, on peut construire nos setters et nos getters -comme on le souhaite, tout en gardant une syntaxe très propre, -comme si on accédait directement à des membres de la classe. - -Les autres fonctionnalités orientées objets à notre disposition -incluent les interfaces, les classes abstraites, et la surcharge -de méthodes. D gère l'héritage comme Java: On ne peut hériter que -d'une seule classe et implémenter autant d'interface que voulu. - -Nous venons d'explorer les fonctionnalités objet du D, mais changeons -un peu de domaine. D permet la programmation fonctionelle, avec les fonctions -de premier ordre, les fonctions `pures` et les données immuables. -De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter) -sont disponibles dans le module `std.algorithm`. - -```c -import std.algorithm : map, filter, reduce; -import std.range : iota; // construit un intervalle excluant la dernière valeur. - -void main() { - // On veut un algorithme qui affiche la somme de la liste des carrés - // des entiers paires de 1 à 100. Un jeu d'enfant ! - - // On se contente de passer des expressions lambda en paramètre à des templates. - // On peut fournir au template n'importe quelle fonction, mais dans notre - // cas, les lambdas sont pratiques. - auto num = iota(1, 101).filter!(x => x % 2 == 0) - .map!(y => y ^^ 2) - .reduce!((a, b) => a + b); - - writeln(num); -} -``` - -Vous voyez qu'on a calculé `num` comme on le ferait en haskell par exemple ? -C'est grâce à une innovation de D qu'on appelle "Uniform Function Call Syntax". -Avec l'UFCS, on peut choisir d'écrire un appel à une fonction de manière -classique, ou comme un appel à une méthode. Walter Brighter a écrit un -article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) -Pour faire court, on peut appeller une fonction dont le premier paramètre -est de type A, comme si c'était une méthode de A. - -J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça. -Voyons comment on le fait en D ! - -```c -import std.stdio; -import std.parallelism : parallel; -import std.math : sqrt; - -void main() { - // On veut calculer la racine carrée de tous les nombres - // dans notre tableau, et profiter de tous les coeurs - // à notre disposition. - auto arr = new double[1_000_000]; - - // On utilise un index et une référence à chaque élément du tableau. - // On appelle juste la fonction parallel sur notre tableau ! - foreach(i, ref elem; parallel(arr)) { - ref = sqrt(i + 1.0); - } -} - - -``` diff --git a/fr-fr/haskell-fr.html.markdown b/fr-fr/haskell-fr.html.markdown new file mode 100644 index 00000000..a34dc098 --- /dev/null +++ b/fr-fr/haskell-fr.html.markdown @@ -0,0 +1,431 @@ +--- +language: Haskell +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["David Baumgartner", "http://davidbaumgartner.ch"] +lang: fr-fr +filename: learnhaskell-fr.hs +--- + +Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie. + +```haskell +-- Un commentaire en une ligne commence avec deux tirets. +{- Un commentaire sur plusieurs lignes peut être contenu dans +un bloc de cette façon. +-} + +---------------------------------------------------- +-- 1. Types de données primitifs et opérateurs +---------------------------------------------------- + +-- Vous avez les nombres +3 -- 3 + +-- Les maths sont comme vous vous y attendez +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 +35 / 5 -- 7.0 + +-- La division n'est pas entière par défaut +35 / 4 -- 8.75 + +-- division entière +35 `div` 4 -- 8 + +-- Les booléens sont primitifs +True +False + +-- Opérations avec les booléens +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur. +-- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous +-- les arguments sont juste listés après la fonction. Le schéma général est +-- donc : +-- func arg1 arg2 arg3... +-- Voyez la section sur les fonctions pour savoir comment écrire les vôtres. + +-- Caractères et chaînes de caractère +"Ceci est une chaîne de caractère." +'a' -- caractère +'Vous ne pouvez pas utiliser des apostrophes pour les chaînes de caractère.' -- erreur ! + +-- Les chaînes peuvent être concaténées +"Hello " ++ "world!" -- "Hello world!" + +-- Une chaîne de caractère est *réellement* une liste +"Ceci est une chaîne." !! 0 -- 'C' + + +---------------------------------------------------- +-- 2. Listes et tuples +---------------------------------------------------- + +-- Tous les éléments d'une liste doit avoir le même type. +-- les deux lignes suivantes sont semblables +[1, 2, 3, 4, 5] +[1..5] + +-- Il y a aussi des listes infinies en Haskell ! +[1..] -- une liste de tous les nombres naturels + +-- Les listes infinies fonctionnent parce que Haskell est « paresseux »: +-- ça veut dire qu'il n'évalue que ce qui a besoin de l'être. Vous pouvez +-- donc vous demander le 1000e élément de votre liste et il vous le donnera : + +[1..] !! 999 -- 1000 + +-- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste +-- de cette liste « infinie » n'existe pas encore ! En fait, Haskell ne va jamais +-- le faire à moins qu'il ne le doive. + +-- Adjoindre deux listes +[1..5] ++ [6..10] + +-- ajouter au début de la liste +0:[1..5] -- [0, 1, 2, 3, 4, 5] + +-- l'indice d'une liste +[0..] !! 5 -- 5 + +-- d'autres opérations sur les listes +head [1..5] -- 1 +tail [1..5] -- [2, 3, 4, 5] +init [1..5] -- [1, 2, 3, 4] +last [1..5] -- 5 + +--liste en compréhension +[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] + +--avec un conditionnel +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Chaque élément d'un tuple peut être d'un type différent, mais un +-- tuple a une longueur fixée. +-- Un tuple : +("haskell", 1) + +-- accéder aux éléments d'un tuple +fst ("haskell", 1) -- "haskell" +snd ("haskell", 1) -- 1 + +---------------------------------------------------- +-- 3. Functions +---------------------------------------------------- +-- Une simple fonction qui prend deux paramètres +add a b = a + b + +-- Notez que si vous utilisez ghci (l'interpréteur Haskell) +-- vous devrez utiliser `let`. Par exemple : +-- let add a b = a + b + +-- Utiliser une fonction +add 1 2 -- 3 + +-- Vous pouvez également mettre le nom de la fonction entre les +-- deux arguments avec des accents graves : +1 `add` 2 -- 3 + +-- Vous pouvez également définir des fonctions qui n'ont pas de +-- lettres ! Ça vous laisse créer vos propres opérateurs ! Voilà +-- un opérateur qui fait une division entière : +(//) a b = a `div` b +35 // 4 -- 8 + +-- Gardes : Une façon de gérer la valeur de vos arguments en amont +fib x + | x < 2 = x + | otherwise = fib (x - 1) + fib (x - 2) + +-- Le filtrage par motif est similaire. Là, on a donné trois +-- définitions différentes de `fib`. Haskell appellera automatiquement +-- la première fonction qui correspond au motif de la valeur. +fib 1 = 1 +fib 2 = 2 +fib x = fib (x - 1) + fib (x - 2) + +-- Filtrage par motif sur un tuple. +foo (x, y) = (x + 1, y + 2) + +-- Filtrage par motif sur des listes. Ici, `x` est le premier +-- élément de la liste, et `xs` le reste. On peut écrire notre +-- propre fonction `map` : +myMap func [] = [] +myMap func (x:xs) = func x:(myMap func xs) + +-- Les fonctions anonymes sont créées avec des barres obliques +-- inverses, suivies de tous les arguments. +myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] + +-- Une utilisation de fold (appelée `inject` dans quelques autres +-- langages) avec comme paramètre une fonction anonyme. +-- `foldl1` veut dire fold left -- soit littéralement pli gauche -- +-- et utilise la première valeur de la liste comme accumulateur. +foldl1 (\acc x -> acc + x) [1..5] -- 15 + +---------------------------------------------------- +-- 4. Plus de fonctions +---------------------------------------------------- + +-- curryfication : si vous n'appliquez pas tous les arguments à une +-- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne +-- une fonction qui prend le reste des arguments. + +add a b = a + b +foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10 +foo 5 -- 15 + +-- Une autre façon de l'écrire +foo = (+10) +foo 5 -- 15 + +-- Composition de fonctions +-- la fonction (.) enchaîne deux fonctions. +-- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute +-- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale. +foo = (*5) . (+10) + +-- (5 + 10) * 5 = 75 +foo 5 -- 75 + +-- fixation de priorité +-- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité +-- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite +-- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` +-- pour vous débarrasser de beaucoup de parenthèses : + +-- avant +(even (fib 7)) -- False + +-- ensuite +even . fib $ 7 -- False + +---------------------------------------------------- +-- 5. Signature de type +---------------------------------------------------- + +-- Haskell a un système de types très strict : par exemple, tout a un type. + +-- Quelques types simples : +5 :: Integer +"hello" :: String +True :: Bool + +-- Les fonctions ont également des types. +-- `not` prend un booléen et retourne un booléen. +-- not :: Bool -> Bool + +-- Voilà une fonction qui prend deux paramètres. +-- add :: Integer -> Integer -> Integer + +-- Quand vous définissez une valeur (souvenez-vous, tout est valeur en +-- Haskell), une bonne pratique est d'écrire son type explicitement +double :: Integer -> Integer +double x = x * 2 + +---------------------------------------------------- +-- 6. Flux de contrôle et structures conditionnelles +---------------------------------------------------- + +-- structure conditionnelle if +haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" + +-- les structures if peuvent être écrites sur plusieurs lignes +haskell = if 1 == 1 + then "awesome" + else "awful" + +-- les structures case : voilà comment vous pourriez analyser les arguments de +-- ligne de commande +case args of + "help" -> printHelp + "start" -> startProgram + _ -> putStrLn "bad args" + + +-- Haskell n'a pas de boucles parce qu'il utilise la récursion. +-- `map` applique une fonction sur chaque élément d'une liste + +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +-- vous pouvez créer une fonction `for` en utilisant `map` +for array func = map func array + +-- et l'utiliser +for [0..5] $ \i -> show i + +-- nous aurions pu l'écrire également ainsi +for [0..5] show + +-- vous pouvez utiliser foldl et foldr pour +-- réduire une liste +-- foldl +foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 + +-- C'est donc la même chose que +(2 * (2 * (2 * 4 + 1) + 2) + 3) + +-- foldl évalue de gauche à droite, foldr +-- de droite à gauche +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- Et c'est équivalent à +(2 * 3 + (2 * 2 + (2 * 1 + 4))) + +---------------------------------------------------- +-- 7. Types de données +---------------------------------------------------- + +-- Vous pouvez écrire vos propres types de données en Haskell + +data Couleur = Rouge | Bleu | Vert + +-- Et maintenant l'utiliser dans une fonction + + +say :: Couleur -> String +say Rouge = "Vous êtes Rouge !" +say Bleu = "Vous êtes Bleu !" +say Vert = "Vous êtes Vert !" + +-- Vos types peuvent également avoir des paramètres + +data Maybe a = Nothing | Just a + +-- Tous les exemples ci-dessous sont issus du type Maybe +Just "hello" -- of type `Maybe String` +Just 1 -- of type `Maybe Int` +Nothing -- of type `Maybe a` for any `a` + +---------------------------------------------------- +-- 8. Haskell IO +---------------------------------------------------- + +-- Tandis que l'IO ne peut pas être totalement expliqué pleinement +-- sans que les monades ne le soient, il n'est pas difficile +-- d'expliquer suffisamment pour commencer. + +-- Quand un programme en Haskell est exécuté, la fonction `main` +-- est appelée. Il doit retourner une valeur de type `IO ()`. +-- Par exemple : + +main :: IO () +main = putStrLn $ "Bonjour, le ciel ! " ++ (say Blue) +-- putStrLn a comme type String -> IO () + +-- La façon la plus simple pour faire de l'IO est de faire un programme +-- fonction de String vers String. La fonction +-- interact :: (String -> String) -> IO () +-- prend un texte, applique une fonction et affiche le résultat. + +countLines :: String -> String +countLines = show . length . lines + +main' = interact countLines + +-- Vous pouvez considérer qu'une valeur de type `IO ()` représente +-- une séquence d'actions que l'ordinateur exécute, un peu comme +-- dans un langage impératif. On peut utiliser la structure `do` +-- pour enchaîner des actions. Par exemple : + +sayHello :: IO () +sayHello = do + putStrLn "Quel est ton nom ?" + name <- getLine -- prend une ligne et assigne sa valeur à `name` + putStrLn $ "Salut, " ++ name + +-- Exercice : écrire votre propre version d'`interact` qui ne fait +-- que de lire une ligne d'entrée. + +-- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule +-- action qui sera exécutée est la valeur de `main`. +-- Pour lancer `sayHello`, commentez l'ancienne définition de `main` +-- et remplacez-le par : +-- main = sayHello + +-- Essaions de mieux comprendre comment la fonction `getLine` que +-- nous venons d'utiliser. Son type est : +-- getLine :: IO String +-- vous pouvez considérer le type `IO a` comme un programme que +-- le programme va générer comme une valeur de type `a` quand +-- il sera exécuté. On peut l'enregistrer et la réutiliser en +-- utilisant `<-`. On peut aussi faire nos propres actions +-- de type `IO String` : + +action :: IO String +action = do + putStrLn "C'est une ligne. Heu" + input1 <- getLine + input2 <- getLine + -- Le type de la structure `do` est celui de sa dernière ligne. + -- `return` n'est pas un mot clef, mais simplement une fonction. + return (input1 ++ "\n" ++ input2) -- return :: String -> IO String + +-- On peut maintenant l'utiliser comme on a utilisé `getLine` +-- tout à l'heure + +main'' = do + putStrLn "Je vais afficher deux lignes !" + result <- action + putStrLn result + putStrLn "C'était tout !" + +-- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise +-- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe +-- quelle fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO) +-- devient marqué comme `IO` dans la signature de son type. Ça nous montre +-- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur +-- ou ne changent pas d'état) et quelles fonctions ne le sont pas. + +-- C'est une fonctionnalité très puissante, car il est facile d'exécuter +-- des fonctions pures simultanément, et donc la concurrence en Haskell +-- est très facile. + + +---------------------------------------------------- +-- 9. Le REPL de Haskell +---------------------------------------------------- + +-- Lancer le REPL en tapant `ghci`. +-- Vous pouvez maintenant taper du code Haskell. +-- Toutes les nouvelles valeurs peuvent être crées +-- avec `let` : + +let foo = 5 + +-- Vous pouvez voir le type de n'importe quelle valeur avec `:t` : + +>:t foo +foo :: Integer + +-- Vous pouvez également lancer des actions de type `IO ()` + +> sayHello +Quel est ton nom ? +Ami +Salut, Ami ! + +``` + +Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple : une implémentation de quicksort : + +```haskell +qsort [] = [] +qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater + where lesser = filter (< p) xs + greater = filter (>= p) xs +``` + +Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/). + +Vous pouvez trouver une approche beaucoup plus douce avec les excellents +[Learn you a Haskell](http://lyah.haskell.fr/) ou +[Real World Haskell (en)](http://book.realworldhaskell.org/). diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown deleted file mode 100644 index a34dc098..00000000 --- a/fr-fr/haskell.html.markdown +++ /dev/null @@ -1,431 +0,0 @@ ---- -language: Haskell -contributors: - - ["Adit Bhargava", "http://adit.io"] -translators: - - ["David Baumgartner", "http://davidbaumgartner.ch"] -lang: fr-fr -filename: learnhaskell-fr.hs ---- - -Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie. - -```haskell --- Un commentaire en une ligne commence avec deux tirets. -{- Un commentaire sur plusieurs lignes peut être contenu dans -un bloc de cette façon. --} - ----------------------------------------------------- --- 1. Types de données primitifs et opérateurs ----------------------------------------------------- - --- Vous avez les nombres -3 -- 3 - --- Les maths sont comme vous vous y attendez -1 + 1 -- 2 -8 - 1 -- 7 -10 * 2 -- 20 -35 / 5 -- 7.0 - --- La division n'est pas entière par défaut -35 / 4 -- 8.75 - --- division entière -35 `div` 4 -- 8 - --- Les booléens sont primitifs -True -False - --- Opérations avec les booléens -not True -- False -not False -- True -1 == 1 -- True -1 /= 1 -- False -1 < 10 -- True - --- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur. --- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous --- les arguments sont juste listés après la fonction. Le schéma général est --- donc : --- func arg1 arg2 arg3... --- Voyez la section sur les fonctions pour savoir comment écrire les vôtres. - --- Caractères et chaînes de caractère -"Ceci est une chaîne de caractère." -'a' -- caractère -'Vous ne pouvez pas utiliser des apostrophes pour les chaînes de caractère.' -- erreur ! - --- Les chaînes peuvent être concaténées -"Hello " ++ "world!" -- "Hello world!" - --- Une chaîne de caractère est *réellement* une liste -"Ceci est une chaîne." !! 0 -- 'C' - - ----------------------------------------------------- --- 2. Listes et tuples ----------------------------------------------------- - --- Tous les éléments d'une liste doit avoir le même type. --- les deux lignes suivantes sont semblables -[1, 2, 3, 4, 5] -[1..5] - --- Il y a aussi des listes infinies en Haskell ! -[1..] -- une liste de tous les nombres naturels - --- Les listes infinies fonctionnent parce que Haskell est « paresseux »: --- ça veut dire qu'il n'évalue que ce qui a besoin de l'être. Vous pouvez --- donc vous demander le 1000e élément de votre liste et il vous le donnera : - -[1..] !! 999 -- 1000 - --- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste --- de cette liste « infinie » n'existe pas encore ! En fait, Haskell ne va jamais --- le faire à moins qu'il ne le doive. - --- Adjoindre deux listes -[1..5] ++ [6..10] - --- ajouter au début de la liste -0:[1..5] -- [0, 1, 2, 3, 4, 5] - --- l'indice d'une liste -[0..] !! 5 -- 5 - --- d'autres opérations sur les listes -head [1..5] -- 1 -tail [1..5] -- [2, 3, 4, 5] -init [1..5] -- [1, 2, 3, 4] -last [1..5] -- 5 - ---liste en compréhension -[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] - ---avec un conditionnel -[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] - --- Chaque élément d'un tuple peut être d'un type différent, mais un --- tuple a une longueur fixée. --- Un tuple : -("haskell", 1) - --- accéder aux éléments d'un tuple -fst ("haskell", 1) -- "haskell" -snd ("haskell", 1) -- 1 - ----------------------------------------------------- --- 3. Functions ----------------------------------------------------- --- Une simple fonction qui prend deux paramètres -add a b = a + b - --- Notez que si vous utilisez ghci (l'interpréteur Haskell) --- vous devrez utiliser `let`. Par exemple : --- let add a b = a + b - --- Utiliser une fonction -add 1 2 -- 3 - --- Vous pouvez également mettre le nom de la fonction entre les --- deux arguments avec des accents graves : -1 `add` 2 -- 3 - --- Vous pouvez également définir des fonctions qui n'ont pas de --- lettres ! Ça vous laisse créer vos propres opérateurs ! Voilà --- un opérateur qui fait une division entière : -(//) a b = a `div` b -35 // 4 -- 8 - --- Gardes : Une façon de gérer la valeur de vos arguments en amont -fib x - | x < 2 = x - | otherwise = fib (x - 1) + fib (x - 2) - --- Le filtrage par motif est similaire. Là, on a donné trois --- définitions différentes de `fib`. Haskell appellera automatiquement --- la première fonction qui correspond au motif de la valeur. -fib 1 = 1 -fib 2 = 2 -fib x = fib (x - 1) + fib (x - 2) - --- Filtrage par motif sur un tuple. -foo (x, y) = (x + 1, y + 2) - --- Filtrage par motif sur des listes. Ici, `x` est le premier --- élément de la liste, et `xs` le reste. On peut écrire notre --- propre fonction `map` : -myMap func [] = [] -myMap func (x:xs) = func x:(myMap func xs) - --- Les fonctions anonymes sont créées avec des barres obliques --- inverses, suivies de tous les arguments. -myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] - --- Une utilisation de fold (appelée `inject` dans quelques autres --- langages) avec comme paramètre une fonction anonyme. --- `foldl1` veut dire fold left -- soit littéralement pli gauche -- --- et utilise la première valeur de la liste comme accumulateur. -foldl1 (\acc x -> acc + x) [1..5] -- 15 - ----------------------------------------------------- --- 4. Plus de fonctions ----------------------------------------------------- - --- curryfication : si vous n'appliquez pas tous les arguments à une --- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne --- une fonction qui prend le reste des arguments. - -add a b = a + b -foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10 -foo 5 -- 15 - --- Une autre façon de l'écrire -foo = (+10) -foo 5 -- 15 - --- Composition de fonctions --- la fonction (.) enchaîne deux fonctions. --- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute --- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale. -foo = (*5) . (+10) - --- (5 + 10) * 5 = 75 -foo 5 -- 75 - --- fixation de priorité --- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité --- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite --- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` --- pour vous débarrasser de beaucoup de parenthèses : - --- avant -(even (fib 7)) -- False - --- ensuite -even . fib $ 7 -- False - ----------------------------------------------------- --- 5. Signature de type ----------------------------------------------------- - --- Haskell a un système de types très strict : par exemple, tout a un type. - --- Quelques types simples : -5 :: Integer -"hello" :: String -True :: Bool - --- Les fonctions ont également des types. --- `not` prend un booléen et retourne un booléen. --- not :: Bool -> Bool - --- Voilà une fonction qui prend deux paramètres. --- add :: Integer -> Integer -> Integer - --- Quand vous définissez une valeur (souvenez-vous, tout est valeur en --- Haskell), une bonne pratique est d'écrire son type explicitement -double :: Integer -> Integer -double x = x * 2 - ----------------------------------------------------- --- 6. Flux de contrôle et structures conditionnelles ----------------------------------------------------- - --- structure conditionnelle if -haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" - --- les structures if peuvent être écrites sur plusieurs lignes -haskell = if 1 == 1 - then "awesome" - else "awful" - --- les structures case : voilà comment vous pourriez analyser les arguments de --- ligne de commande -case args of - "help" -> printHelp - "start" -> startProgram - _ -> putStrLn "bad args" - - --- Haskell n'a pas de boucles parce qu'il utilise la récursion. --- `map` applique une fonction sur chaque élément d'une liste - -map (*2) [1..5] -- [2, 4, 6, 8, 10] - --- vous pouvez créer une fonction `for` en utilisant `map` -for array func = map func array - --- et l'utiliser -for [0..5] $ \i -> show i - --- nous aurions pu l'écrire également ainsi -for [0..5] show - --- vous pouvez utiliser foldl et foldr pour --- réduire une liste --- foldl -foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 - --- C'est donc la même chose que -(2 * (2 * (2 * 4 + 1) + 2) + 3) - --- foldl évalue de gauche à droite, foldr --- de droite à gauche -foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 - --- Et c'est équivalent à -(2 * 3 + (2 * 2 + (2 * 1 + 4))) - ----------------------------------------------------- --- 7. Types de données ----------------------------------------------------- - --- Vous pouvez écrire vos propres types de données en Haskell - -data Couleur = Rouge | Bleu | Vert - --- Et maintenant l'utiliser dans une fonction - - -say :: Couleur -> String -say Rouge = "Vous êtes Rouge !" -say Bleu = "Vous êtes Bleu !" -say Vert = "Vous êtes Vert !" - --- Vos types peuvent également avoir des paramètres - -data Maybe a = Nothing | Just a - --- Tous les exemples ci-dessous sont issus du type Maybe -Just "hello" -- of type `Maybe String` -Just 1 -- of type `Maybe Int` -Nothing -- of type `Maybe a` for any `a` - ----------------------------------------------------- --- 8. Haskell IO ----------------------------------------------------- - --- Tandis que l'IO ne peut pas être totalement expliqué pleinement --- sans que les monades ne le soient, il n'est pas difficile --- d'expliquer suffisamment pour commencer. - --- Quand un programme en Haskell est exécuté, la fonction `main` --- est appelée. Il doit retourner une valeur de type `IO ()`. --- Par exemple : - -main :: IO () -main = putStrLn $ "Bonjour, le ciel ! " ++ (say Blue) --- putStrLn a comme type String -> IO () - --- La façon la plus simple pour faire de l'IO est de faire un programme --- fonction de String vers String. La fonction --- interact :: (String -> String) -> IO () --- prend un texte, applique une fonction et affiche le résultat. - -countLines :: String -> String -countLines = show . length . lines - -main' = interact countLines - --- Vous pouvez considérer qu'une valeur de type `IO ()` représente --- une séquence d'actions que l'ordinateur exécute, un peu comme --- dans un langage impératif. On peut utiliser la structure `do` --- pour enchaîner des actions. Par exemple : - -sayHello :: IO () -sayHello = do - putStrLn "Quel est ton nom ?" - name <- getLine -- prend une ligne et assigne sa valeur à `name` - putStrLn $ "Salut, " ++ name - --- Exercice : écrire votre propre version d'`interact` qui ne fait --- que de lire une ligne d'entrée. - --- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule --- action qui sera exécutée est la valeur de `main`. --- Pour lancer `sayHello`, commentez l'ancienne définition de `main` --- et remplacez-le par : --- main = sayHello - --- Essaions de mieux comprendre comment la fonction `getLine` que --- nous venons d'utiliser. Son type est : --- getLine :: IO String --- vous pouvez considérer le type `IO a` comme un programme que --- le programme va générer comme une valeur de type `a` quand --- il sera exécuté. On peut l'enregistrer et la réutiliser en --- utilisant `<-`. On peut aussi faire nos propres actions --- de type `IO String` : - -action :: IO String -action = do - putStrLn "C'est une ligne. Heu" - input1 <- getLine - input2 <- getLine - -- Le type de la structure `do` est celui de sa dernière ligne. - -- `return` n'est pas un mot clef, mais simplement une fonction. - return (input1 ++ "\n" ++ input2) -- return :: String -> IO String - --- On peut maintenant l'utiliser comme on a utilisé `getLine` --- tout à l'heure - -main'' = do - putStrLn "Je vais afficher deux lignes !" - result <- action - putStrLn result - putStrLn "C'était tout !" - --- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise --- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe --- quelle fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO) --- devient marqué comme `IO` dans la signature de son type. Ça nous montre --- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur --- ou ne changent pas d'état) et quelles fonctions ne le sont pas. - --- C'est une fonctionnalité très puissante, car il est facile d'exécuter --- des fonctions pures simultanément, et donc la concurrence en Haskell --- est très facile. - - ----------------------------------------------------- --- 9. Le REPL de Haskell ----------------------------------------------------- - --- Lancer le REPL en tapant `ghci`. --- Vous pouvez maintenant taper du code Haskell. --- Toutes les nouvelles valeurs peuvent être crées --- avec `let` : - -let foo = 5 - --- Vous pouvez voir le type de n'importe quelle valeur avec `:t` : - ->:t foo -foo :: Integer - --- Vous pouvez également lancer des actions de type `IO ()` - -> sayHello -Quel est ton nom ? -Ami -Salut, Ami ! - -``` - -Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple : une implémentation de quicksort : - -```haskell -qsort [] = [] -qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater - where lesser = filter (< p) xs - greater = filter (>= p) xs -``` - -Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/). - -Vous pouvez trouver une approche beaucoup plus douce avec les excellents -[Learn you a Haskell](http://lyah.haskell.fr/) ou -[Real World Haskell (en)](http://book.realworldhaskell.org/). diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown new file mode 100644 index 00000000..2e4e8461 --- /dev/null +++ b/fr-fr/markdown-fr.html.markdown @@ -0,0 +1,289 @@ +--- +language: markdown +contributors: +- ["Andrei Curelaru", "http://www.infinidad.fr"] +filename: markdown-fr.md +lang: fr-fr +--- + +Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe +facile à lire et à écrire, aisément convertible en HTML + (et beaucoup d'autres formats aussi à présent). + +Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" +et envoyer des pull request! + + +```markdown + + + + + + + + +# Ceci est un

+## Ceci est un

+### Ceci est un

+#### Ceci est un

+##### Ceci est un

+###### Ceci est un
+ + + +Ceci est un h1 +============= + +Ceci est un h2 +------------- + + + + +*Ce texte est en italique.* +_Celui-ci aussi._ + +**Ce texte est en gras.** +__Celui-là aussi.__ + +***Ce texte a les deux styles.*** +**_Pareil ici_** +*__Et là!__* + + + +~~Ce texte est barré avec strikethrough.~~ + + + +Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non? + +Maintenant je suis dans le paragraphe 2. +Je suis toujours dans le paragraphe 2! + + +Puis là, eh oui, le paragraphe 3! + + + +J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). + +Bigre, il y a un
au dessus de moi! + + + +> Ceci est une superbe citation. Vous pouvez même +> revenir à la ligne quand ça vous chante, et placer un `>` +> devant chaque bout de ligne faisant partie +> de la citation. +> La taille ne compte pas^^ tant que chaque ligne commence par un `>`. + +> Vous pouvez aussi utiliser plus d'un niveau +>> d'imbrication! +> Classe et facile, pas vrai? + + + + +* Item +* Item +* Un autre item + +ou + ++ Item ++ Item ++ Encore un item + +ou + +- Item +- Item +- Un dernier item + + + +1. Item un +2. Item deux +3. Item trois + + + +1. Item un +1. Item deux +1. Item trois + + + + +1. Item un +2. Item deux +3. Item trois +* Sub-item +* Sub-item +4. Item quatre + + + +Les [ ] ci dessous, n'ayant pas de [ x ], +deviendront des cases à cocher HTML non-cochées. + +- [ ] Première tache à réaliser. +- [ ] Une autre chose à faire. +La case suivante sera une case à cocher HTML cochée. +- [x] Ça ... c'est fait! + + + + + echo "Ça, c'est du Code!"; + var Ça = "aussi !"; + + + + my_array.each do |item| + puts item + end + + + +La fonction `run()` ne vous oblige pas à aller courir! + + + +\`\`\`ruby + +def foobar +puts "Hello world!" +end +\`\`\` + +<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub +va utiliser une coloration syntaxique pour le langage indiqué après les ``` --> + + + + +*** +--- +- - - +**************** + + + + +[Clic moi!](http://test.com/) + + + +[Clic moi!](http://test.com/ "Lien vers Test.com") + + + +[En avant la musique](/music/). + + + +[Cliquez ici][link1] pour plus d'information! +[Regardez aussi par ici][foobar] si vous voulez. + +[link1]: http://test.com/ "Cool!" +[foobar]: http://foobar.biz/ "Alright!" + + + + + +[Ceci][] est un lien. + +[ceci]: http://ceciestunlien.com/ + + + + + + +![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel") + + + +![Ceci est l'attribut ALT de l'image][monimage] + +[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici." + + + + + est équivalent à : +[http://testwebsite.com/](http://testwebsite.com/) + + + + + + +Il suffit de précéder les caractères spécifiques à ignorer par des backslash \ + +Pour taper *ce texte* entouré d'astérisques mais pas en italique : +Tapez \*ce texte\*. + + + + +| Col1 | Col2 | Col3 | +| :----------- | :------: | ------------: | +| Alignement Gauche | Centé | Alignement Droite | +| bla | bla | bla | + + + +Col 1 | Col2 | Col3 +:-- | :-: | --: +Ough que c'est moche | svp | arrêtez + + + +``` + +Pour plus d'information : + consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, + et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard. diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown deleted file mode 100644 index 2e4e8461..00000000 --- a/fr-fr/markdown.html.markdown +++ /dev/null @@ -1,289 +0,0 @@ ---- -language: markdown -contributors: -- ["Andrei Curelaru", "http://www.infinidad.fr"] -filename: markdown-fr.md -lang: fr-fr ---- - -Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe -facile à lire et à écrire, aisément convertible en HTML - (et beaucoup d'autres formats aussi à présent). - -Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" -et envoyer des pull request! - - -```markdown - - - - - - - - -# Ceci est un

-## Ceci est un

-### Ceci est un

-#### Ceci est un

-##### Ceci est un

-###### Ceci est un
- - - -Ceci est un h1 -============= - -Ceci est un h2 -------------- - - - - -*Ce texte est en italique.* -_Celui-ci aussi._ - -**Ce texte est en gras.** -__Celui-là aussi.__ - -***Ce texte a les deux styles.*** -**_Pareil ici_** -*__Et là!__* - - - -~~Ce texte est barré avec strikethrough.~~ - - - -Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non? - -Maintenant je suis dans le paragraphe 2. -Je suis toujours dans le paragraphe 2! - - -Puis là, eh oui, le paragraphe 3! - - - -J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). - -Bigre, il y a un
au dessus de moi! - - - -> Ceci est une superbe citation. Vous pouvez même -> revenir à la ligne quand ça vous chante, et placer un `>` -> devant chaque bout de ligne faisant partie -> de la citation. -> La taille ne compte pas^^ tant que chaque ligne commence par un `>`. - -> Vous pouvez aussi utiliser plus d'un niveau ->> d'imbrication! -> Classe et facile, pas vrai? - - - - -* Item -* Item -* Un autre item - -ou - -+ Item -+ Item -+ Encore un item - -ou - -- Item -- Item -- Un dernier item - - - -1. Item un -2. Item deux -3. Item trois - - - -1. Item un -1. Item deux -1. Item trois - - - - -1. Item un -2. Item deux -3. Item trois -* Sub-item -* Sub-item -4. Item quatre - - - -Les [ ] ci dessous, n'ayant pas de [ x ], -deviendront des cases à cocher HTML non-cochées. - -- [ ] Première tache à réaliser. -- [ ] Une autre chose à faire. -La case suivante sera une case à cocher HTML cochée. -- [x] Ça ... c'est fait! - - - - - echo "Ça, c'est du Code!"; - var Ça = "aussi !"; - - - - my_array.each do |item| - puts item - end - - - -La fonction `run()` ne vous oblige pas à aller courir! - - - -\`\`\`ruby - -def foobar -puts "Hello world!" -end -\`\`\` - -<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub -va utiliser une coloration syntaxique pour le langage indiqué après les ``` --> - - - - -*** ---- -- - - -**************** - - - - -[Clic moi!](http://test.com/) - - - -[Clic moi!](http://test.com/ "Lien vers Test.com") - - - -[En avant la musique](/music/). - - - -[Cliquez ici][link1] pour plus d'information! -[Regardez aussi par ici][foobar] si vous voulez. - -[link1]: http://test.com/ "Cool!" -[foobar]: http://foobar.biz/ "Alright!" - - - - - -[Ceci][] est un lien. - -[ceci]: http://ceciestunlien.com/ - - - - - - -![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel") - - - -![Ceci est l'attribut ALT de l'image][monimage] - -[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici." - - - - - est équivalent à : -[http://testwebsite.com/](http://testwebsite.com/) - - - - - - -Il suffit de précéder les caractères spécifiques à ignorer par des backslash \ - -Pour taper *ce texte* entouré d'astérisques mais pas en italique : -Tapez \*ce texte\*. - - - - -| Col1 | Col2 | Col3 | -| :----------- | :------: | ------------: | -| Alignement Gauche | Centé | Alignement Droite | -| bla | bla | bla | - - - -Col 1 | Col2 | Col3 -:-- | :-: | --: -Ough que c'est moche | svp | arrêtez - - - -``` - -Pour plus d'information : - consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, - et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard. diff --git a/fr-fr/php-fr.html.markdown b/fr-fr/php-fr.html.markdown new file mode 100644 index 00000000..823630bd --- /dev/null +++ b/fr-fr/php-fr.html.markdown @@ -0,0 +1,697 @@ +--- +language: PHP +filename: php-fr.php +contributors: + - ["Malcolm Fell", "http://emarref.net/"] + - ["Trismegiste", "https://github.com/Trismegiste"] +translators: + - ["Pascal Boutin", "http://pboutin.net/"] +lang: fr-fr +--- + +This document describes PHP 5+. + +```php + // Le code PHP doit être placé à l'intérieur de balises '' + +// Deux barres obliques amorcent un commentaire simple. + +# Le dièse aussi, bien que les barres obliques soient plus courantes + +/* + Les barres obliques et les astérisques peuvent être utilisés + pour faire un commentaire multi-lignes. +*/ + +// Utilisez "echo" ou "print" afficher une sortie +print('Hello '); // Affiche "Hello " sans retour à la ligne + +// Les parenthèses sont facultatives pour print et echo +echo "World\n"; // Affiche "World" avec un retour à la ligne + +// toutes les instructions doivent se terminer par un point-virgule + +// Tout ce qui se trouve en dehors des est automatiquement +// affiché en sortie +Hello World Again! + 12 +$int2 = -12; // => -12 +$int3 = 012; // => 10 (un 0 devant la valeur désigne une valeur octale) +$int4 = 0x0F; // => 15 (un 0x devant la valeur désigne une valeur hexadécimale) + +// Réels (floats, doubles) +$float = 1.234; +$float = 1.2e3; +$float = 7E-10; + +// Suppression d'une variable +unset($int1); + +// Arithmétique +$sum = 1 + 1; // 2 (addition) +$difference = 2 - 1; // 1 (soustraction) +$product = 2 * 2; // 4 (produit) +$quotient = 2 / 1; // 2 (division) + +// Arithmétique (raccourcis) +$number = 0; +$number += 2; // Incrémente $number de 2 +echo $number++; // Affiche 2 (incrémente après l'évaluation) +echo ++$number; // Affiche 4 (incrémente avant l'évaluation) +$number /= $float; // Divise et assigne le quotient à $number + +// Les chaînes de caractères (strings) doivent être à +// l'intérieur d'une paire d'apostrophes +$sgl_quotes = '$String'; // => '$String' + +// Évitez les guillemets sauf pour inclure le contenu d'une autre variable +$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.' + +// Les caractères spéciaux sont seulement échappés avec des guillemets +$escaped = "This contains a \t tab character."; +$unescaped = 'This just contains a slash and a t: \t'; + +// En cas de besoin, placez la variable dans des accolades +$money = "I have $${number} in the bank."; + +// Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes +// multi-lignes non-interprétées +$nowdoc = <<<'END' +Multi line +string +END; + +// Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées +$heredoc = << 1, 'Two' => 2, 'Three' => 3); + +// PHP 5.4 a introduit une nouvelle syntaxe +$associative = ['One' => 1, 'Two' => 2, 'Three' => 3]; + +echo $associative['One']; // affiche 1 + +// Dans une liste simple, l'index est automatiquement attribué en tant que clé +$array = ['One', 'Two', 'Three']; +echo $array[0]; // => "One" + +// Ajoute un élément à la fin du tableau +$array[] = 'Four'; + +// Retrait d'un élément du tableau +unset($array[3]); + +/******************************** + * Affichage + */ + +echo('Hello World!'); +// Affiche Hello World! dans stdout. +// Stdout est la page web si on exécute depuis un navigateur. + +print('Hello World!'); // Pareil à "écho" + +// Pour écho, vous n'avez pas besoin des parenthèses +echo 'Hello World!'; +print 'Hello World!'; // Pour print non plus + +$paragraph = 'paragraph'; + +echo 100; // Affichez un scalaire directement +echo $paragraph; // ou des variables + +// Si le raccourci de sortie est configuré, ou si votre version de PHP est +// 5.4.0+, vous pouvez utiliser ceci: +?> +

+ 2 +echo $z; // => 2 +$y = 0; +echo $x; // => 2 +echo $z; // => 0 + +// Affiche le type et la valeur de la variable dans stdout +var_dump($z); // prints int(0) + +// Affiche la variable dans stdout dans un format plus convivial +print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three ) + +/******************************** + * Logique + */ +$a = 0; +$b = '0'; +$c = '1'; +$d = '1'; + +// assert affiche un avertissement dans son argument n'est pas vrai + +// Ces comparaisons vont toujours être vraies, même si leurs +// types ne sont pas les mêmes. +assert($a == $b); // égalité +assert($c != $a); // inégalité +assert($c <> $a); // inégalité (moins courant) +assert($a < $c); +assert($c > $b); +assert($a <= $b); +assert($c >= $d); + +// Ces comparaisons vont seulement être vraies si les types concordent. +assert($c === $d); +assert($a !== $d); +assert(1 === '1'); +assert(1 !== '1'); + +// Opérateur 'spaceship' depuis PHP 7 +$a = 100; +$b = 1000; + +echo $a <=> $a; // 0 car ils sont égaux +echo $a <=> $b; // -1 car $a < $b +echo $b <=> $a; // 1 car $b > $a + +// Les variables peuvent être transtypées dépendamment de leur usage. + +$integer = 1; +echo $integer + $integer; // => 2 + +$string = '1'; +echo $string + $string; // => 2 + +$string = 'one'; +echo $string + $string; // => 0 +// Donne 0 car l'opérateur + ne peut pas transtyper la chaîne 'one' en un nombre + +// On peut également transtyper manuellement pour utiliser +// une variable dans un autre type + +$boolean = (boolean) 1; // => true + +$zero = 0; +$boolean = (boolean) $zero; // => false + +// Il y a également des fonctions dédiées pour transtyper +$integer = 5; +$string = strval($integer); + +$var = null; // Valeur nulle + + +/******************************** + * Structures de contrôle + */ + +if (true) { + print 'Je suis affiché'; +} + +if (false) { + print 'Je ne le suis pas'; +} else { + print 'Je suis affiché'; +} + +if (false) { + print 'Je ne suis pas affiché'; +} elseif (true) { + print 'Je le suis'; +} + +// Opérateur ternaire +print (false ? 'N\'est pas affiché' : 'L\'est'); + +// Opérateur ternaire depuis PHP 5.3 +// équivalent de $x ? $x : 'Does' +$x = false; +print($x ?: 'Does'); + +// depuis PHP 7, on peut facilement vérifier si une valeur est nulle +$a = null; +$b = 'Hello World'; +echo $a ?? 'a is not set'; // Affiche 'a is not set' +echo $b ?? 'b is not set'; // Affiche 'Hello World' + + +$x = 0; +if ($x === '0') { + print 'Pas affiché'; +} elseif($x == '1') { + print 'Pas affiché'; +} else { + print 'Affiché'; +} + + +// Cette syntaxe alternative est particulièrement utile avec du HTML: +?> + + +

Ceci est affiché si $x est vrai

+ +

Ceci est affiché si $x est faux

+ + + 2, 'car' => 4]; + +// Les boucles 'foreach' sont utiles pour parcourir les tableaux +foreach ($wheels as $wheel_count) { + echo $wheel_count; +} // Affiche "24" + +echo "\n"; + +// Il est également possible d'accéder aux clés du tableau +foreach ($wheels as $vehicle => $wheel_count) { + echo "The $vehicle have $wheel_count wheels"; +} + +echo "\n"; + +$i = 0; +while ($i < 5) { + if ($i === 3) { + break; // Permet d'arrêter la boucle + } + echo $i++; +} // Affiche "012" + +for ($i = 0; $i < 5; $i++) { + if ($i === 3) { + continue; // Permet de passer immédiatement à l'itération suivante + } + echo $i; +} // Affiche "0124" + + +/******************************** + * Fonctions + */ + +// On peut déclarer une fonction avec le mot clé 'function' +function my_function () { + return 'Hello'; +} + +echo my_function(); // => "Hello" + + +// Les noms de fonction débutent par le symbole $ +// Un nom de variable valide commence par une lettre ou un souligné, +// suivi de n'importe quelle lettre, nombre ou de soulignés. + +function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1 + $result = $x + $y; + return $result; +} + +echo add(4); // => 5 +echo add(4, 2); // => 6 + +// $result n'est pas accessible en dehors de la fonction +// print $result; // Retourne un avertissement + +// Depuis PHP 5.3 on peut déclarer des fonctions anonymes +$inc = function ($x) { + return $x + 1; +}; + +echo $inc(2); // => 3 + +function foo ($x, $y, $z) { + echo "$x - $y - $z"; +} + +// Une fonction peut retourner une fonction +function bar ($x, $y) { + // On peut utiliser 'use' pour passer des variables externes + return function ($z) use ($x, $y) { + foo($x, $y, $z); + }; +} + +$bar = bar('A', 'B'); +$bar('C'); // Affiche "A - B - C" + +// On peut exécuter une fonction par son nom en chaîne de caractères +$function_name = 'add'; +echo $function_name(1, 2); // => 3 +// Utile pour déterminer par programmation quelle fonction exécuter. + +// On peut également utiliser +call_user_func(callable $callback [, $parameter [, ... ]]); + +/******************************** + * Insertions + */ + +instanceProp = $instanceProp; + } + + // Les méthodes sont déclarés par des fonctions au sein de la classe + public function myMethod() + { + print 'MyClass'; + } + + // le mot clé 'final' rend la function impossible à surcharger + final function youCannotOverrideMe() + { + } + +/* + * Les attributs et méthodes statiques peuvent être accédés sans devoir + * instancier la classe. Les attributs statiques ne sont pas accessibles depuis + * une instance, même si les méthodes statiques le sont. + */ + + public static function myStaticMethod() + { + print 'I am static'; + } +} + +// Les constantes d'une classe peuvent toujours être utilisé de façon statique +echo MyClass::MY_CONST; // Outputs 'value'; + +echo MyClass::$staticVar; // Retourne 'static'; +MyClass::myStaticMethod(); // Retourne 'I am static'; + +// On peut instancier une classe en utilisant le mot clé 'new' +$my_class = new MyClass('An instance property'); + +// On peut accéder aux attributs/méthodes d'une instance avec -> +echo $my_class->property; // => "public" +echo $my_class->instanceProp; // => "An instance property" +$my_class->myMethod(); // => "MyClass" + + +// On peut hériter d'une classe en utilisant 'extends' +class MyOtherClass extends MyClass +{ + function printProtectedProperty() + { + echo $this->prot; + } + + // Surcharge d'une méthode + function myMethod() + { + parent::myMethod(); + print ' > MyOtherClass'; + } +} + +$my_other_class = new MyOtherClass('Instance prop'); +$my_other_class->printProtectedProperty(); // => Retourne "protected" +$my_other_class->myMethod(); // Retourne "MyClass > MyOtherClass" + +// On peut empêcher qu'une classe soit héritée +final class YouCannotExtendMe +{ +} + +// On peut utiliser des "méthodes magiques" pour se faire des accesseurs +class MyMapClass +{ + private $property; + + public function __get($key) + { + return $this->$key; + } + + public function __set($key, $value) + { + $this->$key = $value; + } +} + +$x = new MyMapClass(); +echo $x->property; // Va utiliser la méthode __get() +$x->property = 'Something'; // Va utiliser la méthode __set() + +// Les classes peuvent être abstraites (en utilisant le mot clé 'abstract'), ou +// elle peuvent implémenter une interface (en utilisant le mot clé 'implement'). + +// Une interface peut être déclarée avec le mot clé 'interface' + +interface InterfaceOne +{ + public function doSomething(); +} + +interface InterfaceTwo +{ + public function doSomethingElse(); +} + +// Les interfaces peuvent hériter d'autres interfaces +interface InterfaceThree extends InterfaceTwo +{ + public function doAnotherContract(); +} + +abstract class MyAbstractClass implements InterfaceOne +{ + public $x = 'doSomething'; +} + +class MyConcreteClass extends MyAbstractClass implements InterfaceTwo +{ + public function doSomething() + { + echo $x; + } + + public function doSomethingElse() + { + echo 'doSomethingElse'; + } +} + + +// Les classes peuvent implémenter plusieurs interfaces à la fois +class SomeOtherClass implements InterfaceOne, InterfaceTwo +{ + public function doSomething() + { + echo 'doSomething'; + } + + public function doSomethingElse() + { + echo 'doSomethingElse'; + } +} + +/******************************** + * Espaces de noms (namespaces) + */ + +// Cette section est séparée, car une déclaration d'espace de nom doit être +// la première chose que l'on retrouve dans un fichier PHP, +// imaginons que c'est le cas + +' - -// Deux barres obliques amorcent un commentaire simple. - -# Le dièse aussi, bien que les barres obliques soient plus courantes - -/* - Les barres obliques et les astérisques peuvent être utilisés - pour faire un commentaire multi-lignes. -*/ - -// Utilisez "echo" ou "print" afficher une sortie -print('Hello '); // Affiche "Hello " sans retour à la ligne - -// Les parenthèses sont facultatives pour print et echo -echo "World\n"; // Affiche "World" avec un retour à la ligne - -// toutes les instructions doivent se terminer par un point-virgule - -// Tout ce qui se trouve en dehors des est automatiquement -// affiché en sortie -Hello World Again! - 12 -$int2 = -12; // => -12 -$int3 = 012; // => 10 (un 0 devant la valeur désigne une valeur octale) -$int4 = 0x0F; // => 15 (un 0x devant la valeur désigne une valeur hexadécimale) - -// Réels (floats, doubles) -$float = 1.234; -$float = 1.2e3; -$float = 7E-10; - -// Suppression d'une variable -unset($int1); - -// Arithmétique -$sum = 1 + 1; // 2 (addition) -$difference = 2 - 1; // 1 (soustraction) -$product = 2 * 2; // 4 (produit) -$quotient = 2 / 1; // 2 (division) - -// Arithmétique (raccourcis) -$number = 0; -$number += 2; // Incrémente $number de 2 -echo $number++; // Affiche 2 (incrémente après l'évaluation) -echo ++$number; // Affiche 4 (incrémente avant l'évaluation) -$number /= $float; // Divise et assigne le quotient à $number - -// Les chaînes de caractères (strings) doivent être à -// l'intérieur d'une paire d'apostrophes -$sgl_quotes = '$String'; // => '$String' - -// Évitez les guillemets sauf pour inclure le contenu d'une autre variable -$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.' - -// Les caractères spéciaux sont seulement échappés avec des guillemets -$escaped = "This contains a \t tab character."; -$unescaped = 'This just contains a slash and a t: \t'; - -// En cas de besoin, placez la variable dans des accolades -$money = "I have $${number} in the bank."; - -// Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes -// multi-lignes non-interprétées -$nowdoc = <<<'END' -Multi line -string -END; - -// Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées -$heredoc = << 1, 'Two' => 2, 'Three' => 3); - -// PHP 5.4 a introduit une nouvelle syntaxe -$associative = ['One' => 1, 'Two' => 2, 'Three' => 3]; - -echo $associative['One']; // affiche 1 - -// Dans une liste simple, l'index est automatiquement attribué en tant que clé -$array = ['One', 'Two', 'Three']; -echo $array[0]; // => "One" - -// Ajoute un élément à la fin du tableau -$array[] = 'Four'; - -// Retrait d'un élément du tableau -unset($array[3]); - -/******************************** - * Affichage - */ - -echo('Hello World!'); -// Affiche Hello World! dans stdout. -// Stdout est la page web si on exécute depuis un navigateur. - -print('Hello World!'); // Pareil à "écho" - -// Pour écho, vous n'avez pas besoin des parenthèses -echo 'Hello World!'; -print 'Hello World!'; // Pour print non plus - -$paragraph = 'paragraph'; - -echo 100; // Affichez un scalaire directement -echo $paragraph; // ou des variables - -// Si le raccourci de sortie est configuré, ou si votre version de PHP est -// 5.4.0+, vous pouvez utiliser ceci: -?> -

- 2 -echo $z; // => 2 -$y = 0; -echo $x; // => 2 -echo $z; // => 0 - -// Affiche le type et la valeur de la variable dans stdout -var_dump($z); // prints int(0) - -// Affiche la variable dans stdout dans un format plus convivial -print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three ) - -/******************************** - * Logique - */ -$a = 0; -$b = '0'; -$c = '1'; -$d = '1'; - -// assert affiche un avertissement dans son argument n'est pas vrai - -// Ces comparaisons vont toujours être vraies, même si leurs -// types ne sont pas les mêmes. -assert($a == $b); // égalité -assert($c != $a); // inégalité -assert($c <> $a); // inégalité (moins courant) -assert($a < $c); -assert($c > $b); -assert($a <= $b); -assert($c >= $d); - -// Ces comparaisons vont seulement être vraies si les types concordent. -assert($c === $d); -assert($a !== $d); -assert(1 === '1'); -assert(1 !== '1'); - -// Opérateur 'spaceship' depuis PHP 7 -$a = 100; -$b = 1000; - -echo $a <=> $a; // 0 car ils sont égaux -echo $a <=> $b; // -1 car $a < $b -echo $b <=> $a; // 1 car $b > $a - -// Les variables peuvent être transtypées dépendamment de leur usage. - -$integer = 1; -echo $integer + $integer; // => 2 - -$string = '1'; -echo $string + $string; // => 2 - -$string = 'one'; -echo $string + $string; // => 0 -// Donne 0 car l'opérateur + ne peut pas transtyper la chaîne 'one' en un nombre - -// On peut également transtyper manuellement pour utiliser -// une variable dans un autre type - -$boolean = (boolean) 1; // => true - -$zero = 0; -$boolean = (boolean) $zero; // => false - -// Il y a également des fonctions dédiées pour transtyper -$integer = 5; -$string = strval($integer); - -$var = null; // Valeur nulle - - -/******************************** - * Structures de contrôle - */ - -if (true) { - print 'Je suis affiché'; -} - -if (false) { - print 'Je ne le suis pas'; -} else { - print 'Je suis affiché'; -} - -if (false) { - print 'Je ne suis pas affiché'; -} elseif (true) { - print 'Je le suis'; -} - -// Opérateur ternaire -print (false ? 'N\'est pas affiché' : 'L\'est'); - -// Opérateur ternaire depuis PHP 5.3 -// équivalent de $x ? $x : 'Does' -$x = false; -print($x ?: 'Does'); - -// depuis PHP 7, on peut facilement vérifier si une valeur est nulle -$a = null; -$b = 'Hello World'; -echo $a ?? 'a is not set'; // Affiche 'a is not set' -echo $b ?? 'b is not set'; // Affiche 'Hello World' - - -$x = 0; -if ($x === '0') { - print 'Pas affiché'; -} elseif($x == '1') { - print 'Pas affiché'; -} else { - print 'Affiché'; -} - - -// Cette syntaxe alternative est particulièrement utile avec du HTML: -?> - - -

Ceci est affiché si $x est vrai

- -

Ceci est affiché si $x est faux

- - - 2, 'car' => 4]; - -// Les boucles 'foreach' sont utiles pour parcourir les tableaux -foreach ($wheels as $wheel_count) { - echo $wheel_count; -} // Affiche "24" - -echo "\n"; - -// Il est également possible d'accéder aux clés du tableau -foreach ($wheels as $vehicle => $wheel_count) { - echo "The $vehicle have $wheel_count wheels"; -} - -echo "\n"; - -$i = 0; -while ($i < 5) { - if ($i === 3) { - break; // Permet d'arrêter la boucle - } - echo $i++; -} // Affiche "012" - -for ($i = 0; $i < 5; $i++) { - if ($i === 3) { - continue; // Permet de passer immédiatement à l'itération suivante - } - echo $i; -} // Affiche "0124" - - -/******************************** - * Fonctions - */ - -// On peut déclarer une fonction avec le mot clé 'function' -function my_function () { - return 'Hello'; -} - -echo my_function(); // => "Hello" - - -// Les noms de fonction débutent par le symbole $ -// Un nom de variable valide commence par une lettre ou un souligné, -// suivi de n'importe quelle lettre, nombre ou de soulignés. - -function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1 - $result = $x + $y; - return $result; -} - -echo add(4); // => 5 -echo add(4, 2); // => 6 - -// $result n'est pas accessible en dehors de la fonction -// print $result; // Retourne un avertissement - -// Depuis PHP 5.3 on peut déclarer des fonctions anonymes -$inc = function ($x) { - return $x + 1; -}; - -echo $inc(2); // => 3 - -function foo ($x, $y, $z) { - echo "$x - $y - $z"; -} - -// Une fonction peut retourner une fonction -function bar ($x, $y) { - // On peut utiliser 'use' pour passer des variables externes - return function ($z) use ($x, $y) { - foo($x, $y, $z); - }; -} - -$bar = bar('A', 'B'); -$bar('C'); // Affiche "A - B - C" - -// On peut exécuter une fonction par son nom en chaîne de caractères -$function_name = 'add'; -echo $function_name(1, 2); // => 3 -// Utile pour déterminer par programmation quelle fonction exécuter. - -// On peut également utiliser -call_user_func(callable $callback [, $parameter [, ... ]]); - -/******************************** - * Insertions - */ - -instanceProp = $instanceProp; - } - - // Les méthodes sont déclarés par des fonctions au sein de la classe - public function myMethod() - { - print 'MyClass'; - } - - // le mot clé 'final' rend la function impossible à surcharger - final function youCannotOverrideMe() - { - } - -/* - * Les attributs et méthodes statiques peuvent être accédés sans devoir - * instancier la classe. Les attributs statiques ne sont pas accessibles depuis - * une instance, même si les méthodes statiques le sont. - */ - - public static function myStaticMethod() - { - print 'I am static'; - } -} - -// Les constantes d'une classe peuvent toujours être utilisé de façon statique -echo MyClass::MY_CONST; // Outputs 'value'; - -echo MyClass::$staticVar; // Retourne 'static'; -MyClass::myStaticMethod(); // Retourne 'I am static'; - -// On peut instancier une classe en utilisant le mot clé 'new' -$my_class = new MyClass('An instance property'); - -// On peut accéder aux attributs/méthodes d'une instance avec -> -echo $my_class->property; // => "public" -echo $my_class->instanceProp; // => "An instance property" -$my_class->myMethod(); // => "MyClass" - - -// On peut hériter d'une classe en utilisant 'extends' -class MyOtherClass extends MyClass -{ - function printProtectedProperty() - { - echo $this->prot; - } - - // Surcharge d'une méthode - function myMethod() - { - parent::myMethod(); - print ' > MyOtherClass'; - } -} - -$my_other_class = new MyOtherClass('Instance prop'); -$my_other_class->printProtectedProperty(); // => Retourne "protected" -$my_other_class->myMethod(); // Retourne "MyClass > MyOtherClass" - -// On peut empêcher qu'une classe soit héritée -final class YouCannotExtendMe -{ -} - -// On peut utiliser des "méthodes magiques" pour se faire des accesseurs -class MyMapClass -{ - private $property; - - public function __get($key) - { - return $this->$key; - } - - public function __set($key, $value) - { - $this->$key = $value; - } -} - -$x = new MyMapClass(); -echo $x->property; // Va utiliser la méthode __get() -$x->property = 'Something'; // Va utiliser la méthode __set() - -// Les classes peuvent être abstraites (en utilisant le mot clé 'abstract'), ou -// elle peuvent implémenter une interface (en utilisant le mot clé 'implement'). - -// Une interface peut être déclarée avec le mot clé 'interface' - -interface InterfaceOne -{ - public function doSomething(); -} - -interface InterfaceTwo -{ - public function doSomethingElse(); -} - -// Les interfaces peuvent hériter d'autres interfaces -interface InterfaceThree extends InterfaceTwo -{ - public function doAnotherContract(); -} - -abstract class MyAbstractClass implements InterfaceOne -{ - public $x = 'doSomething'; -} - -class MyConcreteClass extends MyAbstractClass implements InterfaceTwo -{ - public function doSomething() - { - echo $x; - } - - public function doSomethingElse() - { - echo 'doSomethingElse'; - } -} - - -// Les classes peuvent implémenter plusieurs interfaces à la fois -class SomeOtherClass implements InterfaceOne, InterfaceTwo -{ - public function doSomething() - { - echo 'doSomething'; - } - - public function doSomethingElse() - { - echo 'doSomethingElse'; - } -} - -/******************************** - * Espaces de noms (namespaces) - */ - -// Cette section est séparée, car une déclaration d'espace de nom doit être -// la première chose que l'on retrouve dans un fichier PHP, -// imaginons que c'est le cas - - + + C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive. + Vous pouvez y exécuter des commandes. + Allons-y : +*/ + +println(10) // affiche l'integer 10 + +println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo! + + +// Quelques basiques + +// Imprimer et forcer une nouvelle ligne à la prochaine impression +println("Hello world!") +// Imprimer sans forcer une nouvelle ligne à la prochaine impression +print("Hello world") + +// Pour déclarer des valeurs on utilise var ou val +// Les déclarations val sont immuables, tandis que les var sont muables. +// L'immuabilité est une bonne chose. + +val x = 10 // x vaut maintenant 10 +x = 20 // erreur : réaffectation à val +var x = 10 +x = 20 // x vaut maintenant 20 + +// Les commentaires d'une ligne commencent par deux slashs + +/* +Les commentaires multilignes ressemblent à ça. +*/ + +// les valeurs booléennes +true +false + +// Les opérateurs booléens +!true // false +!false // true +true == false // false +10 > 5 // true + +// Les opérateurs mathématiques sont habituels +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 + + +// Le REPL donne le type et la valeur du résultat quand vous évaluez une commande + +1 + 7 + +/* Les lignes ci-dessous donnent les résultats : + + scala> 1 + 7 + res29: Int = 8 + + Ça signifie que le résultat de l'évaluation 1 + 7 est un objet de + type Int avec une valeur de 8 + + 1+7 donnera le même résultat +*/ + + +// Tout est un objet, même une fonction. Tapez ceci dans le REPL : + +7 // donne res30: Int = 7 (res30 est seulement un nom de variable généré pour le résultat) + + +// La ligne suivante est une fonction qui prend un Int et retourne son carré +(x:Int) => x * x + + +// On peut assigner cette fonction à un identifieur comme ceci : +val sq = (x:Int) => x * x + +/* La ligne suivante nous dit : + + sq: Int => Int = + + Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur. + sq est une fonction qui prend un Int et retourne un Int. + + + sq peut être exécutée comme ci-dessous : +*/ + +sq(10) // donne comme résultat : res33: Int = 100. + + +// les deux-points définissent explicitement le type de la valeur, +// dans ce cas une fonction qui prend un Int et retourne un Int. +val add10: Int => Int = _ + 10 + +// Scala autorise des méthodes et des fonctions à retourner +// ou prendre comme paramètres des autres fonctions ou méthodes + + +List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments + + +// Les fonctions anonymes peuvent être utilisées à la place des fonctions nommées : +List(1, 2, 3) map (x => x + 10) + + + + +// Le tiret du bas peut être utilisé si la fonction anonyme ne prend qu'un paramètre. +// Il se comporte comme une variable +List(1, 2, 3) map (_ + 10) + + + +// Si le bloc et la fonction anonyme prennent tous les deux un seul argument, +// vous pouvez omettre le tiret du bas +List("Dom", "Bob", "Natalia") foreach println + + + +// Les structures de données + +val a = Array(1, 2, 3, 5, 8, 13) +a(0) +a(3) +a(21) // Lance une exception + +val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +m("fork") +m("spoon") +m("bottle") // Lance une exception + +val safeM = m.withDefaultValue("no lo se") +safeM("bottle") + +val s = Set(1, 3, 7) +s(0) +s(1) + +/* Jetez un oeil sur la documentation de map ici - + * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map + */ + + +// Tuples + +(1, 2) + +(4, 3, 2) + +(1, 2, "three") + +(a, 2, "three") + +// Exemple d'utilisation +val divideInts = (x:Int, y:Int) => (x / y, x % y) + + +divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division + +// Pour accéder à un élément d'un tuple, utilisez _._n +// où n est l'index de base 1 de l'élément +val d = divideInts(10,3) + +d._1 + +d._2 + + + +// Des combinaisons + +s.map(sq) + +val sSquared = s. map(sq) + +sSquared.filter(_ < 10) + +sSquared.reduce (_+_) + + + +// La fonction filter prend un prédicat (une fonction de type A -> Booléen) et +// sélectionne tous les éléments qui satisfont ce prédicat +List(1, 2, 3) filter (_ > 2) // List(3) +case class Person(name: String, age: Int) +List( + Person(name = "Dom", age = 23), + Person(name = "Bob", age = 30) +).filter(_.age > 25) // List(Person("Bob", 30)) + + + +// Scala a une méthode foreach définie pour certaines collections +// qui prend en argument une fonction renvoyant Unit (une méthode void) +val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) +aListOfNumbers foreach (x => println(x)) +aListOfNumbers foreach println + + + + +// Compréhensions de listes + +for { n <- s } yield sq(n) + +val nSquared2 = for { n <- s } yield sq(n) + +for { n <- nSquared2 if n < 10 } yield n + +for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared + + + +/* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for + est "répète", alors qu'une for-compréhension définit une relation + entre deux ensembles de données. */ + + + +// Boucles et itération + +1 to 5 +val r = 1 to 5 +r.foreach( println ) + +r foreach println +// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément. +// Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais. + + +(5 to 1 by -1) foreach ( println ) + +// Une boucle while +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + +while (i < 10) { println("i " + i); i+=1 } // Oui, encore. Qu'est-ce qui s'est passé ? Pourquoi ? + + + + + + +i // Montre la valeur de i. Notez que while est une boucle au sens classique. + // Il exécute séquentiellement pendant que la variable de boucle change. + // While est très rapide, + // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus + // facile pour comprendre et pour faire la parallélisation + +i = 0 +// La boucle do while +do { + println("x is still less than 10"); + i += 1 +} while (i < 10) + + +// La récursivité est un moyen idiomatique de faire une chose répétitive en Scala. +// Les fonctions récursives ont besoin d'un type de retour explicite, +// le compilateur ne peut pas le déduire. +// Ici c'est Unit. +def showNumbersInRange(a:Int, b:Int):Unit = { + print(a) + if (a < b) + showNumbersInRange(a + 1, b) +} + + + +// Structures de contrôle + +val x = 10 + +if (x == 1) println("yeah") +if (x == 10) println("yeah") +if (x == 11) println("yeah") +if (x == 11) println ("yeah") else println("nay") + +println(if (x == 10) "yeah" else "nope") +val text = if (x == 10) "yeah" else "nope" + +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + + + +// Les caractéristiques "Orienté Objet" + +// Création d'une classe Dog +class Dog { + // Une méthode appelée bark qui retourne une chaîne de caractère + def bark: String = { + // le corps de la méthode + "Woof, woof!" + } +} + + +// Les classes peuvent contenir presque n'importe quelle autre construction, incluant d'autres classes, +// des fonctions, des méthodes, des objets, des classes case, des traits, etc ... + + + +// Les classes case + +case class Person(name:String, phoneNumber:String) + +Person("George", "1234") == Person("Kate", "1236") + + + + +// Correspondances de motifs + +val me = Person("George", "1234") + +me match { case Person(name, number) => { + "We matched someone : " + name + ", phone : " + number }} + +me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." } + +me match { case Person("George", number) => "Match"; case _ => "Hm..." } + +me match { case Person("Kate", number) => "Match"; case _ => "Hm..." } + +me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } + +val kate = Person("Kate", "1234") + +kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } + + + +// Expressions régulières + +val email = "(.*)@(.*)".r // On fait une Regex en invoquant r sur la chaîne de caractère + +val email(user, domain) = "henry@zkpr.com" + +"mrbean@pyahoo.com" match { + case email(name, domain) => "I know your name, " + name +} + + + +// Les chaînes de caractères + +"Les chaînes de caractères Scala sont entourées de doubles guillements" +'a' // Un caractère de Scala +// 'Les simples guillemets n'existent pas en Scala' // Erreur +"Les chaînes de caractères possèdent les méthodes usuelles de Java".length +"Il y a aussi quelques méthodes extra de Scala.".reverse + +// Voir également : scala.collection.immutable.StringOps + +println("ABCDEF".length) +println("ABCDEF".substring(2, 6)) +println("ABCDEF".replace("C", "3")) + +val n = 45 +println(s"We have $n apples") + +val a = Array(11, 9, 6) +println(s"My second daughter is ${a(2-1)} years old") + +// Certains caractères ont besoin d'être "échappés", +// ex un guillemet à l'intérieur d'une chaîne de caractères : +val a = "They stood outside the \"Rose and Crown\"" + +// Les triples guillemets permettent d'écrire des chaînes de caractères +// sur plusieurs lignes et peuvent contenir des guillemets + +val html = """
+

Press belo', Joe

+ | +
""" + + + +// Structure et organisation d'une application + +// Importer des chaînes de caratères +import scala.collection.immutable.List + +// Importer tous les sous-paquets +import scala.collection.immutable._ + +// Importer plusieurs classes en une seule instruction +import scala.collection.immutable.{List, Map} + +// Renommer un import en utilisant '=>' +import scala.collection.immutable.{ List => ImmutableList } + +// Importer toutes les classes, à l'exception de certaines. +// La ligne suivante exclut Map et Set : +import scala.collection.immutable.{Map => _, Set => _, _} + +// Le point d'entrée du programme est défini dans un fichier scala +// utilisant un objet, avec une simple méthode main : +object Application { + def main(args: Array[String]): Unit = { + // Votre code ici. + } +} + +// Les fichiers peuvent contenir plusieurs classes et plusieurs objets. +// On les compile avec scalac + + + + +// Entrée et Sortie + +// Pour lire un fichier ligne par ligne +import scala.io.Source +for(line <- Source.fromFile("myfile.txt").getLines()) + println(line) + +// On utilise le PrintWriter de Java pour écrire un fichier + + +``` + +## Autres ressources + +[Scala for the impatient](http://horstmann.com/scala/) + +[Twitter Scala school](http://twitter.github.io/scala_school/) + +[The scala documentation](http://docs.scala-lang.org/) + +[Try Scala in your browser](http://scalatutorials.com/tour/) + +Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user) diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown deleted file mode 100644 index c6a61745..00000000 --- a/fr-fr/scala.html.markdown +++ /dev/null @@ -1,460 +0,0 @@ ---- -language: Scala -contributors: - - ["George Petrov", "http://github.com/petrovg"] - - ["Dominic Bou-Samra", "http://dbousamra.github.com"] -translators: - - ["Anne-Catherine Dehier", "https://github.com/spellart"] -filename: learnscala-fr.scala -lang: fr-fr ---- - -### Scala - le langage évolutif - -```scala - -/* - Pour vous préparer : - - 1) (Téléchargez Scala)[http://www.scala-lang.org/downloads] - 2) Dézippez/décompressez dans votre endroit préféré - et ajoutez le chemin du sous-répertoire bin au chemin du système - 3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur : - - scala> - - C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive. - Vous pouvez y exécuter des commandes. - Allons-y : -*/ - -println(10) // affiche l'integer 10 - -println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo! - - -// Quelques basiques - -// Imprimer et forcer une nouvelle ligne à la prochaine impression -println("Hello world!") -// Imprimer sans forcer une nouvelle ligne à la prochaine impression -print("Hello world") - -// Pour déclarer des valeurs on utilise var ou val -// Les déclarations val sont immuables, tandis que les var sont muables. -// L'immuabilité est une bonne chose. - -val x = 10 // x vaut maintenant 10 -x = 20 // erreur : réaffectation à val -var x = 10 -x = 20 // x vaut maintenant 20 - -// Les commentaires d'une ligne commencent par deux slashs - -/* -Les commentaires multilignes ressemblent à ça. -*/ - -// les valeurs booléennes -true -false - -// Les opérateurs booléens -!true // false -!false // true -true == false // false -10 > 5 // true - -// Les opérateurs mathématiques sont habituels -1 + 1 // 2 -2 - 1 // 1 -5 * 3 // 15 -6 / 2 // 3 - - -// Le REPL donne le type et la valeur du résultat quand vous évaluez une commande - -1 + 7 - -/* Les lignes ci-dessous donnent les résultats : - - scala> 1 + 7 - res29: Int = 8 - - Ça signifie que le résultat de l'évaluation 1 + 7 est un objet de - type Int avec une valeur de 8 - - 1+7 donnera le même résultat -*/ - - -// Tout est un objet, même une fonction. Tapez ceci dans le REPL : - -7 // donne res30: Int = 7 (res30 est seulement un nom de variable généré pour le résultat) - - -// La ligne suivante est une fonction qui prend un Int et retourne son carré -(x:Int) => x * x - - -// On peut assigner cette fonction à un identifieur comme ceci : -val sq = (x:Int) => x * x - -/* La ligne suivante nous dit : - - sq: Int => Int = - - Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur. - sq est une fonction qui prend un Int et retourne un Int. - - - sq peut être exécutée comme ci-dessous : -*/ - -sq(10) // donne comme résultat : res33: Int = 100. - - -// les deux-points définissent explicitement le type de la valeur, -// dans ce cas une fonction qui prend un Int et retourne un Int. -val add10: Int => Int = _ + 10 - -// Scala autorise des méthodes et des fonctions à retourner -// ou prendre comme paramètres des autres fonctions ou méthodes - - -List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments - - -// Les fonctions anonymes peuvent être utilisées à la place des fonctions nommées : -List(1, 2, 3) map (x => x + 10) - - - - -// Le tiret du bas peut être utilisé si la fonction anonyme ne prend qu'un paramètre. -// Il se comporte comme une variable -List(1, 2, 3) map (_ + 10) - - - -// Si le bloc et la fonction anonyme prennent tous les deux un seul argument, -// vous pouvez omettre le tiret du bas -List("Dom", "Bob", "Natalia") foreach println - - - -// Les structures de données - -val a = Array(1, 2, 3, 5, 8, 13) -a(0) -a(3) -a(21) // Lance une exception - -val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") -m("fork") -m("spoon") -m("bottle") // Lance une exception - -val safeM = m.withDefaultValue("no lo se") -safeM("bottle") - -val s = Set(1, 3, 7) -s(0) -s(1) - -/* Jetez un oeil sur la documentation de map ici - - * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map - */ - - -// Tuples - -(1, 2) - -(4, 3, 2) - -(1, 2, "three") - -(a, 2, "three") - -// Exemple d'utilisation -val divideInts = (x:Int, y:Int) => (x / y, x % y) - - -divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division - -// Pour accéder à un élément d'un tuple, utilisez _._n -// où n est l'index de base 1 de l'élément -val d = divideInts(10,3) - -d._1 - -d._2 - - - -// Des combinaisons - -s.map(sq) - -val sSquared = s. map(sq) - -sSquared.filter(_ < 10) - -sSquared.reduce (_+_) - - - -// La fonction filter prend un prédicat (une fonction de type A -> Booléen) et -// sélectionne tous les éléments qui satisfont ce prédicat -List(1, 2, 3) filter (_ > 2) // List(3) -case class Person(name: String, age: Int) -List( - Person(name = "Dom", age = 23), - Person(name = "Bob", age = 30) -).filter(_.age > 25) // List(Person("Bob", 30)) - - - -// Scala a une méthode foreach définie pour certaines collections -// qui prend en argument une fonction renvoyant Unit (une méthode void) -val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) -aListOfNumbers foreach (x => println(x)) -aListOfNumbers foreach println - - - - -// Compréhensions de listes - -for { n <- s } yield sq(n) - -val nSquared2 = for { n <- s } yield sq(n) - -for { n <- nSquared2 if n < 10 } yield n - -for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared - - - -/* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for - est "répète", alors qu'une for-compréhension définit une relation - entre deux ensembles de données. */ - - - -// Boucles et itération - -1 to 5 -val r = 1 to 5 -r.foreach( println ) - -r foreach println -// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément. -// Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais. - - -(5 to 1 by -1) foreach ( println ) - -// Une boucle while -var i = 0 -while (i < 10) { println("i " + i); i+=1 } - -while (i < 10) { println("i " + i); i+=1 } // Oui, encore. Qu'est-ce qui s'est passé ? Pourquoi ? - - - - - - -i // Montre la valeur de i. Notez que while est une boucle au sens classique. - // Il exécute séquentiellement pendant que la variable de boucle change. - // While est très rapide, - // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus - // facile pour comprendre et pour faire la parallélisation - -i = 0 -// La boucle do while -do { - println("x is still less than 10"); - i += 1 -} while (i < 10) - - -// La récursivité est un moyen idiomatique de faire une chose répétitive en Scala. -// Les fonctions récursives ont besoin d'un type de retour explicite, -// le compilateur ne peut pas le déduire. -// Ici c'est Unit. -def showNumbersInRange(a:Int, b:Int):Unit = { - print(a) - if (a < b) - showNumbersInRange(a + 1, b) -} - - - -// Structures de contrôle - -val x = 10 - -if (x == 1) println("yeah") -if (x == 10) println("yeah") -if (x == 11) println("yeah") -if (x == 11) println ("yeah") else println("nay") - -println(if (x == 10) "yeah" else "nope") -val text = if (x == 10) "yeah" else "nope" - -var i = 0 -while (i < 10) { println("i " + i); i+=1 } - - - -// Les caractéristiques "Orienté Objet" - -// Création d'une classe Dog -class Dog { - // Une méthode appelée bark qui retourne une chaîne de caractère - def bark: String = { - // le corps de la méthode - "Woof, woof!" - } -} - - -// Les classes peuvent contenir presque n'importe quelle autre construction, incluant d'autres classes, -// des fonctions, des méthodes, des objets, des classes case, des traits, etc ... - - - -// Les classes case - -case class Person(name:String, phoneNumber:String) - -Person("George", "1234") == Person("Kate", "1236") - - - - -// Correspondances de motifs - -val me = Person("George", "1234") - -me match { case Person(name, number) => { - "We matched someone : " + name + ", phone : " + number }} - -me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." } - -me match { case Person("George", number) => "Match"; case _ => "Hm..." } - -me match { case Person("Kate", number) => "Match"; case _ => "Hm..." } - -me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } - -val kate = Person("Kate", "1234") - -kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } - - - -// Expressions régulières - -val email = "(.*)@(.*)".r // On fait une Regex en invoquant r sur la chaîne de caractère - -val email(user, domain) = "henry@zkpr.com" - -"mrbean@pyahoo.com" match { - case email(name, domain) => "I know your name, " + name -} - - - -// Les chaînes de caractères - -"Les chaînes de caractères Scala sont entourées de doubles guillements" -'a' // Un caractère de Scala -// 'Les simples guillemets n'existent pas en Scala' // Erreur -"Les chaînes de caractères possèdent les méthodes usuelles de Java".length -"Il y a aussi quelques méthodes extra de Scala.".reverse - -// Voir également : scala.collection.immutable.StringOps - -println("ABCDEF".length) -println("ABCDEF".substring(2, 6)) -println("ABCDEF".replace("C", "3")) - -val n = 45 -println(s"We have $n apples") - -val a = Array(11, 9, 6) -println(s"My second daughter is ${a(2-1)} years old") - -// Certains caractères ont besoin d'être "échappés", -// ex un guillemet à l'intérieur d'une chaîne de caractères : -val a = "They stood outside the \"Rose and Crown\"" - -// Les triples guillemets permettent d'écrire des chaînes de caractères -// sur plusieurs lignes et peuvent contenir des guillemets - -val html = """
-

Press belo', Joe

- | -
""" - - - -// Structure et organisation d'une application - -// Importer des chaînes de caratères -import scala.collection.immutable.List - -// Importer tous les sous-paquets -import scala.collection.immutable._ - -// Importer plusieurs classes en une seule instruction -import scala.collection.immutable.{List, Map} - -// Renommer un import en utilisant '=>' -import scala.collection.immutable.{ List => ImmutableList } - -// Importer toutes les classes, à l'exception de certaines. -// La ligne suivante exclut Map et Set : -import scala.collection.immutable.{Map => _, Set => _, _} - -// Le point d'entrée du programme est défini dans un fichier scala -// utilisant un objet, avec une simple méthode main : -object Application { - def main(args: Array[String]): Unit = { - // Votre code ici. - } -} - -// Les fichiers peuvent contenir plusieurs classes et plusieurs objets. -// On les compile avec scalac - - - - -// Entrée et Sortie - -// Pour lire un fichier ligne par ligne -import scala.io.Source -for(line <- Source.fromFile("myfile.txt").getLines()) - println(line) - -// On utilise le PrintWriter de Java pour écrire un fichier - - -``` - -## Autres ressources - -[Scala for the impatient](http://horstmann.com/scala/) - -[Twitter Scala school](http://twitter.github.io/scala_school/) - -[The scala documentation](http://docs.scala-lang.org/) - -[Try Scala in your browser](http://scalatutorials.com/tour/) - -Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user) diff --git a/fr-fr/vim-fr.html.markdown b/fr-fr/vim-fr.html.markdown new file mode 100644 index 00000000..b2f1d24d --- /dev/null +++ b/fr-fr/vim-fr.html.markdown @@ -0,0 +1,239 @@ +--- +category: tool +tool: vim +filename: LearnVim-fr.txt +contributors: + - ["RadhikaG", "https://github.com/RadhikaG"] +translators: + - ["Thibault", "https://github.com/napnac"] +lang: fr-fr +--- + + +[Vim](http://www.vim.org) +(Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix. +Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour +objectif la rapidité ainsi que l'augmentation de la productivité. Il a de +nombreux raccourcis claviers pour une navigation et une édition plus rapide. + +## Navigation basique avec Vim + +``` + vim # Ouvre avec vim + :q # Quitte vim + :w # Sauvegarde le fichier actuel + :wq # Sauvegarde le fichier actuel et quitte vim + :q! # Quitte vim sans sauvegarder + # ! *force* l'exécution de :q, ce qui par conséquent + # oblige vim à quitter sans sauvegarder + :x # Sauvegarde le fichier et quitte vim (raccourcis de :wq) + + u # Annuler + CTRL+R # Rétablir + + h # Déplace le curseur vers la gauche + j # Déplace le curseur vers le bas + k # Déplace le curseur vers le haut + l # Déplace le curseur vers la droite + + # Mouvements au sein d'une ligne + + 0 # Va au début de la ligne + $ # Va à la fin de la ligne + ^ # Va au premier caractère non blanc de la ligne + + # Rechercher dans un texte + + /mot # Surligne toutes les occurrences du mot après le curseur + ?mot # Surligne toutes les occurrences du mot avant le curseur + n # Déplace le curseur sur la prochaine occurrence du mot recherché + N # Déplace le curseur sur la précédente occurrence du mot recherché + + :%s/abc/def/g # Transforme les 'abc' en 'def' sur chaque ligne du texte + :s/abc/def/g # Transforme les 'abc' en 'def' sur la ligne actuelle + + # Se déplacer vers un caractère + + f # Se déplace en avant jusqu'à + t # Se déplace en avant juste avant + + # Par exemple + f< # Se déplace en avant jusqu'à < + t< # Se déplace en avant juste avant < + + # Se déplacer dans un mot + + w # Avance d'un mot + b # Recule d'un mot + e # Se déplace jusqu'à la fin du mot actuel + + # D'autres raccourcis pour se déplacer + + gg # Va au début du fichier + G # Va à la fin du fichier + :NB # Va à la ligne numéro NB (où NB est un nombre) + H # Se déplace jusqu'en haut de l'écran + M # Se déplace jusqu'au milieu de l'écran + L # Se déplace jusqu'en bas de l'écran +``` + +## Modes + +Vim est basé sur le concept de **modes**. + +Mode Commande - pour se déplacer et exécuter des commandes (vim démarre dans ce mode) +Mode Insertion - pour éditer le fichier +Mode Visuel - pour sélectionner du texte et réaliser des opérations dessus +Mode Ex - pour entrer des commandes avec ':' + +``` + i # Mode insertion, avant le curseur + a # Mode insertion, après le curseur + v # Mode visuel + : # Mode ex + # 'Echap' permet de revenir dans le mode commande + + # Copier/Coller du texte + + y # Copie le texte sélectionné + yy # Copie la ligne actuelle + d # Supprime ce qui est sélectionné + dd # Supprime la ligne actuelle + p # Colle après le curseur + P # Colle avant le curseur + x # Supprime le caractère sous le curseur +``` + +## La "Grammaire" de Vim + +Vim peut être vu comme un ensemble de commande sous la forme +'Verbe-Modificateur-Nom' : + +Verbe - notre action +Modificateur - la manière de faire l'action +Nom - l'objet désigné par l'action + +Quelques exemples importants de 'Verbes', 'Modificateurs', et de 'Noms' : + +``` + # 'Verbes' + + d # Supprime + c # Transforme + y # Copie + v # Sélectionne + + # 'Modificateurs' + + i # A l'intérieur + a # Autour + NB # Nombre + f # Cherche quelque chose et se déplace dessus + t # Cherche quelque chose et se déplace juste avant + / # Cherche une chaîne de caractères après le curseur + ? # Cherche une chaîne de caractères avant le curseur + + # 'Noms' + + w # Mot + s # Phrase + p # Paragraphe + b # Bloc + + # Exemple de 'phrases' ou commandes + + d2w # Supprime 2 mots + cis # Transforme l'intérieur de la phrase + yip # Copie l'intérieur du paragraphe + ct< # Transforme le texte du curseur jusqu'au caractère avant le < + d$ # Supprime jusqu'à la fin de la ligne +``` + +## Quelques raccourcis et astuces + +``` + > # Indente la sélection d'un bloc + < # Dé-indente la sélection d'un bloc + :earlier 15m # Retrouve le document comme il était il y a 15 minutes + :later 15m # Inverse la commande précédente + ddp # Echange la position de deux lignes consécutives (dd puis p) + . # Répète la dernière action effectuée +``` + +## Macros + +Les macros sont des actions enregistrables. +Quand on commence à enregistrer une macro, Vim enregistre **toutes** les actions +et les commandes que vous utilisez, jusqu'à ce que vous arrêtiez d'enregistrer. +Lorsque vous appelez une macro, elle applique exactement les mêmes actions et +commandes sur le texte sélectionné. + +``` + qa # Commence l'enregistrement de la macro 'a' + q # Arrête l'enregistrement + @a # Appelle la macro 'a' +``` + +### Configuration de ~/.vimrc + +Le fichier .vimrc est utilisé pour configurer Vim lors du démarrage. + +Voici un exemple de fichier ~/.vimrc : + +``` +" Exemple de ~/.vimrc +" 2015.10 + +" Nécessaire à Vim pour être 'iMproved' +set nocompatible + +" Détermine l'extension du fichier à partir du nom pour permettre une indentation +" automatique intelligente, etc. +filetype indent plugin on + +" Active la coloration syntaxique +syntax on + +" Une meilleure complétion de la ligne de commande +set wildmenu + +" Utilise une recherche insensible à la case sauf quand on utilise des majuscules +set ignorecase +set smartcase + +" Quand on commence une nouvelle ligne et qu'aucun type d'indentation n'est activé +" on utilise la même indentation que sur la ligne précédente +set autoindent + +" Affiche le numéro de la ligne sur la gauche de l'écran +set number + +" Options d'indentation, à changer en fonction des préférences personnelles + +" Nombre d'espaces visuels par tabulation +set tabstop=4 + +" Nombre d'espaces par tabulation +set softtabstop=4 + +" Nombre d'espaces indentés avec les opérations d'indentations (>> et <<) +set shiftwidth=4 + +" Convertis les tabulations en espaces +set expandtab + +" Active des tabulations et des espaces intelligents pour l'indentation et l'alignement +set smarttab +``` + +### Références + +[Vim | Home](http://www.vim.org/index.php) + +`$ vimtutor` + +[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/) + +[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) + +[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) diff --git a/fr-fr/vim.html.markdown b/fr-fr/vim.html.markdown deleted file mode 100644 index b2f1d24d..00000000 --- a/fr-fr/vim.html.markdown +++ /dev/null @@ -1,239 +0,0 @@ ---- -category: tool -tool: vim -filename: LearnVim-fr.txt -contributors: - - ["RadhikaG", "https://github.com/RadhikaG"] -translators: - - ["Thibault", "https://github.com/napnac"] -lang: fr-fr ---- - - -[Vim](http://www.vim.org) -(Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix. -Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour -objectif la rapidité ainsi que l'augmentation de la productivité. Il a de -nombreux raccourcis claviers pour une navigation et une édition plus rapide. - -## Navigation basique avec Vim - -``` - vim # Ouvre avec vim - :q # Quitte vim - :w # Sauvegarde le fichier actuel - :wq # Sauvegarde le fichier actuel et quitte vim - :q! # Quitte vim sans sauvegarder - # ! *force* l'exécution de :q, ce qui par conséquent - # oblige vim à quitter sans sauvegarder - :x # Sauvegarde le fichier et quitte vim (raccourcis de :wq) - - u # Annuler - CTRL+R # Rétablir - - h # Déplace le curseur vers la gauche - j # Déplace le curseur vers le bas - k # Déplace le curseur vers le haut - l # Déplace le curseur vers la droite - - # Mouvements au sein d'une ligne - - 0 # Va au début de la ligne - $ # Va à la fin de la ligne - ^ # Va au premier caractère non blanc de la ligne - - # Rechercher dans un texte - - /mot # Surligne toutes les occurrences du mot après le curseur - ?mot # Surligne toutes les occurrences du mot avant le curseur - n # Déplace le curseur sur la prochaine occurrence du mot recherché - N # Déplace le curseur sur la précédente occurrence du mot recherché - - :%s/abc/def/g # Transforme les 'abc' en 'def' sur chaque ligne du texte - :s/abc/def/g # Transforme les 'abc' en 'def' sur la ligne actuelle - - # Se déplacer vers un caractère - - f # Se déplace en avant jusqu'à - t # Se déplace en avant juste avant - - # Par exemple - f< # Se déplace en avant jusqu'à < - t< # Se déplace en avant juste avant < - - # Se déplacer dans un mot - - w # Avance d'un mot - b # Recule d'un mot - e # Se déplace jusqu'à la fin du mot actuel - - # D'autres raccourcis pour se déplacer - - gg # Va au début du fichier - G # Va à la fin du fichier - :NB # Va à la ligne numéro NB (où NB est un nombre) - H # Se déplace jusqu'en haut de l'écran - M # Se déplace jusqu'au milieu de l'écran - L # Se déplace jusqu'en bas de l'écran -``` - -## Modes - -Vim est basé sur le concept de **modes**. - -Mode Commande - pour se déplacer et exécuter des commandes (vim démarre dans ce mode) -Mode Insertion - pour éditer le fichier -Mode Visuel - pour sélectionner du texte et réaliser des opérations dessus -Mode Ex - pour entrer des commandes avec ':' - -``` - i # Mode insertion, avant le curseur - a # Mode insertion, après le curseur - v # Mode visuel - : # Mode ex - # 'Echap' permet de revenir dans le mode commande - - # Copier/Coller du texte - - y # Copie le texte sélectionné - yy # Copie la ligne actuelle - d # Supprime ce qui est sélectionné - dd # Supprime la ligne actuelle - p # Colle après le curseur - P # Colle avant le curseur - x # Supprime le caractère sous le curseur -``` - -## La "Grammaire" de Vim - -Vim peut être vu comme un ensemble de commande sous la forme -'Verbe-Modificateur-Nom' : - -Verbe - notre action -Modificateur - la manière de faire l'action -Nom - l'objet désigné par l'action - -Quelques exemples importants de 'Verbes', 'Modificateurs', et de 'Noms' : - -``` - # 'Verbes' - - d # Supprime - c # Transforme - y # Copie - v # Sélectionne - - # 'Modificateurs' - - i # A l'intérieur - a # Autour - NB # Nombre - f # Cherche quelque chose et se déplace dessus - t # Cherche quelque chose et se déplace juste avant - / # Cherche une chaîne de caractères après le curseur - ? # Cherche une chaîne de caractères avant le curseur - - # 'Noms' - - w # Mot - s # Phrase - p # Paragraphe - b # Bloc - - # Exemple de 'phrases' ou commandes - - d2w # Supprime 2 mots - cis # Transforme l'intérieur de la phrase - yip # Copie l'intérieur du paragraphe - ct< # Transforme le texte du curseur jusqu'au caractère avant le < - d$ # Supprime jusqu'à la fin de la ligne -``` - -## Quelques raccourcis et astuces - -``` - > # Indente la sélection d'un bloc - < # Dé-indente la sélection d'un bloc - :earlier 15m # Retrouve le document comme il était il y a 15 minutes - :later 15m # Inverse la commande précédente - ddp # Echange la position de deux lignes consécutives (dd puis p) - . # Répète la dernière action effectuée -``` - -## Macros - -Les macros sont des actions enregistrables. -Quand on commence à enregistrer une macro, Vim enregistre **toutes** les actions -et les commandes que vous utilisez, jusqu'à ce que vous arrêtiez d'enregistrer. -Lorsque vous appelez une macro, elle applique exactement les mêmes actions et -commandes sur le texte sélectionné. - -``` - qa # Commence l'enregistrement de la macro 'a' - q # Arrête l'enregistrement - @a # Appelle la macro 'a' -``` - -### Configuration de ~/.vimrc - -Le fichier .vimrc est utilisé pour configurer Vim lors du démarrage. - -Voici un exemple de fichier ~/.vimrc : - -``` -" Exemple de ~/.vimrc -" 2015.10 - -" Nécessaire à Vim pour être 'iMproved' -set nocompatible - -" Détermine l'extension du fichier à partir du nom pour permettre une indentation -" automatique intelligente, etc. -filetype indent plugin on - -" Active la coloration syntaxique -syntax on - -" Une meilleure complétion de la ligne de commande -set wildmenu - -" Utilise une recherche insensible à la case sauf quand on utilise des majuscules -set ignorecase -set smartcase - -" Quand on commence une nouvelle ligne et qu'aucun type d'indentation n'est activé -" on utilise la même indentation que sur la ligne précédente -set autoindent - -" Affiche le numéro de la ligne sur la gauche de l'écran -set number - -" Options d'indentation, à changer en fonction des préférences personnelles - -" Nombre d'espaces visuels par tabulation -set tabstop=4 - -" Nombre d'espaces par tabulation -set softtabstop=4 - -" Nombre d'espaces indentés avec les opérations d'indentations (>> et <<) -set shiftwidth=4 - -" Convertis les tabulations en espaces -set expandtab - -" Active des tabulations et des espaces intelligents pour l'indentation et l'alignement -set smarttab -``` - -### Références - -[Vim | Home](http://www.vim.org/index.php) - -`$ vimtutor` - -[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/) - -[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) - -[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) -- cgit v1.2.3