From 5bff1e956ef8003eddfcb64ffdc1161ee3d622bc Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 16:49:49 +0200 Subject: Create typescript-fr.html.markdown Translate the reading block, the introduction part and the type part. --- fr-fr/typescript-fr.html.markdown | 171 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 fr-fr/typescript-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown new file mode 100644 index 00000000..e87bacac --- /dev/null +++ b/fr-fr/typescript-fr.html.markdown @@ -0,0 +1,171 @@ +--- +language: TypeScript +contributors: + - ["Philippe Vlérick", "https://github.com/pvlerick"] +translators: + - ["Alois de Gouvello", "https://github.com/aloisdg"] +filename: learntypescript-fr.ts +lang: fr-fr +--- + +TypeScript est un langage visant à faciliter le developpement d'applications large et scalable écrite en JavaScript. +TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript. +C'est une surcouche à JavaScript: tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le compilateur TypeScript émet du JavaScript. + +Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). + +Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript. + +```js +// Il y a 3 types basiques en in TypeScript +var isDone: boolean = false; +var lines: number = 42; +var name: string = "Anders"; + +// Quand c'est impossible de savoir, il ya le type `Any` +var notSure: any = 4; +notSure = "maybe a string instead"; +notSure = false; // ok, définitvement un booléen + +// Pour les collections, il y a les tableaux typés et les tableaux génériques +var list: number[] = [1, 2, 3]; // Un tableaux typé +var list: Array = [1, 2, 3]; // un tableau générique + +// Pour les énumeration +enum Color {Red, Green, Blue}; +var c: Color = Color.Green; + +// Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien +function bigHorribleAlert(): void { + alert("I'm a little annoying box!"); +} + +// Functions are first class citizens, support the lambda "fat arrow" syntax and +// use type inference + +// The following are equivalent, the same signature will be infered by the +// compiler, and same JavaScript will be emitted +var f1 = function(i: number): number { return i * i; } +// Return type inferred +var f2 = function(i: number) { return i * i; } +var f3 = (i: number): number => { return i * i; } +// Return type inferred +var f4 = (i: number) => { return i * i; } +// Return type inferred, one-liner means no return keyword needed +var f5 = (i: number) => i * i; + +// Interfaces are structural, anything that has the properties is compliant with +// the interface +interface Person { + name: string; + // Optional properties, marked with a "?" + age?: number; + // And of course functions + move(): void; +} + +// Object that implements the "Person" interface +// Can be treated as a Person since it has the name and move properties +var p: Person = { name: "Bobby", move: () => {} }; +// Objects that have the optional property: +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// Is not a person because age is not a number +var invalidPerson: Person = { name: "Bobby", age: true }; + +// Interfaces can also describe a function type +interface SearchFunc { + (source: string, subString: string): boolean; +} +// Only the parameters' types are important, names are not important. +var mySearch: SearchFunc; +mySearch = function(src: string, sub: string) { + return src.search(sub) != -1; +} + +// Classes - members are public by default +class Point { + // Properties + x: number; + + // Constructor - the public/private keywords in this context will generate + // the boiler plate code for the property and the initialization in the + // constructor. + // In this example, "y" will be defined just like "x" is, but with less code + // Default values are also supported + + constructor(x: number, public y: number = 0) { + this.x = x; + } + + // Functions + dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } + + // Static members + static origin = new Point(0, 0); +} + +var p1 = new Point(10 ,20); +var p2 = new Point(25); //y will be 0 + +// Inheritance +class Point3D extends Point { + constructor(x: number, y: number, public z: number = 0) { + super(x, y); // Explicit call to the super class constructor is mandatory + } + + // Overwrite + dist() { + var d = super.dist(); + return Math.sqrt(d * d + this.z * this.z); + } +} + +// Modules, "." can be used as separator for sub modules +module Geometry { + export class Square { + constructor(public sideLength: number = 0) { + } + area() { + return Math.pow(this.sideLength, 2); + } + } +} + +var s1 = new Geometry.Square(5); + +// Local alias for referencing a module +import G = Geometry; + +var s2 = new G.Square(10); + +// Generics +// Classes +class Tuple { + constructor(public item1: T1, public item2: T2) { + } +} + +// Interfaces +interface Pair { + item1: T; + item2: T; +} + +// And functions +var pairToTuple = function(p: Pair) { + return new Tuple(p.item1, p.item2); +}; + +var tuple = pairToTuple({ item1:"hello", item2:"world"}); + +// Including references to a definition file: +/// + +``` + +## Lectures complémentaires + * [Site officiel de TypeScript] (http://www.typescriptlang.org/) + * [Spécification du langage TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238) + * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript) + * [Code source sur GitHub] (https://github.com/Microsoft/TypeScript) + * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/) -- cgit v1.2.3 From 6f96532a59012aa1041aaf671c160396a7819167 Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 17:12:54 +0200 Subject: Update typescript-fr.html.markdown Translate functions block --- fr-fr/typescript-fr.html.markdown | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index e87bacac..718a5e9a 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -10,19 +10,19 @@ lang: fr-fr TypeScript est un langage visant à faciliter le developpement d'applications large et scalable écrite en JavaScript. TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript. -C'est une surcouche à JavaScript: tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le compilateur TypeScript émet du JavaScript. +C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript. ```js -// Il y a 3 types basiques en in TypeScript +// Il y a 3 types basiques en TypeScript var isDone: boolean = false; var lines: number = 42; var name: string = "Anders"; -// Quand c'est impossible de savoir, il ya le type `Any` +// Quand c'est impossible à déterminer, on utilise le type `Any` var notSure: any = 4; notSure = "maybe a string instead"; notSure = false; // ok, définitvement un booléen @@ -40,18 +40,18 @@ function bigHorribleAlert(): void { alert("I'm a little annoying box!"); } -// Functions are first class citizens, support the lambda "fat arrow" syntax and -// use type inference +// Les fontions sont des entités de première classe. Elles supportent les expressions lambda et +// utilisent l'inférence de types -// The following are equivalent, the same signature will be infered by the -// compiler, and same JavaScript will be emitted +// Les fonctions ci-dessous sont équivalentes, une signature identique sera inférée par le compilateur, +// et le même JavaScript sera généré var f1 = function(i: number): number { return i * i; } -// Return type inferred +// Retourne un type inféré var f2 = function(i: number) { return i * i; } var f3 = (i: number): number => { return i * i; } -// Return type inferred +// Retourne un type inféré var f4 = (i: number) => { return i * i; } -// Return type inferred, one-liner means no return keyword needed +// Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; // Interfaces are structural, anything that has the properties is compliant with -- cgit v1.2.3 From 0964b9e1edff08d0d4bc570a9fad135e2da45d62 Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 18:42:13 +0200 Subject: Update typescript-fr.html.markdown Add classe block --- fr-fr/typescript-fr.html.markdown | 59 +++++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 31 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 718a5e9a..9e6ee171 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -32,7 +32,7 @@ var list: number[] = [1, 2, 3]; // Un tableaux typé var list: Array = [1, 2, 3]; // un tableau générique // Pour les énumeration -enum Color {Red, Green, Blue}; +enum Color { Red, Green, Blue }; var c: Color = Color.Green; // Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien @@ -54,73 +54,70 @@ var f4 = (i: number) => { return i * i; } // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; -// Interfaces are structural, anything that has the properties is compliant with -// the interface +// Les interfaces sont structurés, tout ce qui a les propriétés est compatible avec +// l'interface interface Person { name: string; - // Optional properties, marked with a "?" + // Les propriétés optionnelles sont identifiées avec un "?" age?: number; - // And of course functions + // Et bien sûr, les fonctions move(): void; } -// Object that implements the "Person" interface -// Can be treated as a Person since it has the name and move properties +// Un objet implémentant l'interface "Person" peut être traité comme +// une Person car il a les propriétés "name" et "move" var p: Person = { name: "Bobby", move: () => {} }; -// Objects that have the optional property: -var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; -// Is not a person because age is not a number -var invalidPerson: Person = { name: "Bobby", age: true }; +// Des objets implémentants la propriété optionnelle : +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; // valide car "age" est un nombre +var invalidPerson: Person = { name: "Bobby", age: true }; // invalide car "age" n'est pas un nombre -// Interfaces can also describe a function type +// Les interfaces peuvent aussi décrire un type de fonction interface SearchFunc { (source: string, subString: string): boolean; } -// Only the parameters' types are important, names are not important. +// Seul les types des paramètres sont importants, les noms ne le sont pas var mySearch: SearchFunc; mySearch = function(src: string, sub: string) { return src.search(sub) != -1; } -// Classes - members are public by default +// Les membres des classes sont publiques par défaut class Point { - // Properties + // Propriétés x: number; - // Constructor - the public/private keywords in this context will generate - // the boiler plate code for the property and the initialization in the - // constructor. - // In this example, "y" will be defined just like "x" is, but with less code - // Default values are also supported - + // Constructeur - Les mots clés "public" et "private" dans ce contexte génèrent + // le code de la propriété et son initialisation dans le constructeur. + // Dans cet exemple, "y" sera défini de la même façon que "x", mais avec moins de code + // Les valeurs par défaut sont supportées constructor(x: number, public y: number = 0) { this.x = x; } - // Functions + // Fonctions dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } - // Static members + // Membres statiques static origin = new Point(0, 0); } var p1 = new Point(10 ,20); var p2 = new Point(25); //y will be 0 -// Inheritance +// Héritage class Point3D extends Point { constructor(x: number, y: number, public z: number = 0) { - super(x, y); // Explicit call to the super class constructor is mandatory + super(x, y); // Un appel explicite au constructeur de la super classe est obligatoire. } - // Overwrite + // Redéfinition dist() { var d = super.dist(); return Math.sqrt(d * d + this.z * this.z); } } -// Modules, "." can be used as separator for sub modules +// Modules, "." peut être utilisé comme un séparateur de sous modules. module Geometry { export class Square { constructor(public sideLength: number = 0) { @@ -133,12 +130,12 @@ module Geometry { var s1 = new Geometry.Square(5); -// Local alias for referencing a module +// Alias local pour référencer un module import G = Geometry; var s2 = new G.Square(10); -// Generics +// Génériques // Classes class Tuple { constructor(public item1: T1, public item2: T2) { @@ -151,14 +148,14 @@ interface Pair { item2: T; } -// And functions +// Et fonctions var pairToTuple = function(p: Pair) { return new Tuple(p.item1, p.item2); }; var tuple = pairToTuple({ item1:"hello", item2:"world"}); -// Including references to a definition file: +// Inclure des références à un fichier : /// ``` -- cgit v1.2.3 From f5fec6341b9a7ed280a5dbfd86d9cc5ee4fa82cf Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 18:47:21 +0200 Subject: Update typescript-fr.html.markdown Fix translation --- fr-fr/typescript-fr.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 9e6ee171..14caec7c 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -8,13 +8,13 @@ filename: learntypescript-fr.ts lang: fr-fr --- -TypeScript est un langage visant à faciliter le developpement d'applications large et scalable écrite en JavaScript. -TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript. -C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. +TypeScript est un langage visant à faciliter le développement d'applications large et scalable écrite en JavaScript. +TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript. +C'est une sur-couche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). -Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript. +Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et accéder directement au rendu JavaScript. ```js // Il y a 3 types basiques en TypeScript -- cgit v1.2.3 From abd5437b6d94a4635df8ade836ecde2206aa9625 Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 18:54:07 +0200 Subject: Update typescript-fr.html.markdown Adjust to 80 columns --- fr-fr/typescript-fr.html.markdown | 39 ++++++++++++++++++++++----------------- 1 file changed, 22 insertions(+), 17 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 14caec7c..63ed4c34 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -25,7 +25,7 @@ var name: string = "Anders"; // Quand c'est impossible à déterminer, on utilise le type `Any` var notSure: any = 4; notSure = "maybe a string instead"; -notSure = false; // ok, définitvement un booléen +notSure = false; // ok, définitivement un booléen // Pour les collections, il y a les tableaux typés et les tableaux génériques var list: number[] = [1, 2, 3]; // Un tableaux typé @@ -35,16 +35,17 @@ var list: Array = [1, 2, 3]; // un tableau générique enum Color { Red, Green, Blue }; var c: Color = Color.Green; -// Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien +// Enfin, `void` est utilisé dans le cas spécifique +// d'une fonction ne retournant rien function bigHorribleAlert(): void { alert("I'm a little annoying box!"); } -// Les fontions sont des entités de première classe. Elles supportent les expressions lambda et -// utilisent l'inférence de types +// Les fontions sont des entités de première classe. Elles supportent +// les expressions lambda et utilisent l'inférence de types -// Les fonctions ci-dessous sont équivalentes, une signature identique sera inférée par le compilateur, -// et le même JavaScript sera généré +// Les fonctions ci-dessous sont équivalentes, une signature identique +// sera inférée par le compilateur, et le même JavaScript sera généré var f1 = function(i: number): number { return i * i; } // Retourne un type inféré var f2 = function(i: number) { return i * i; } @@ -54,8 +55,8 @@ var f4 = (i: number) => { return i * i; } // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; -// Les interfaces sont structurés, tout ce qui a les propriétés est compatible avec -// l'interface +// Les interfaces sont structurés, tout ce qui a les propriétés est compatible +// avec l'interface interface Person { name: string; // Les propriétés optionnelles sont identifiées avec un "?" @@ -68,28 +69,30 @@ interface Person { // une Person car il a les propriétés "name" et "move" var p: Person = { name: "Bobby", move: () => {} }; // Des objets implémentants la propriété optionnelle : -var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; // valide car "age" est un nombre -var invalidPerson: Person = { name: "Bobby", age: true }; // invalide car "age" n'est pas un nombre +// valide car "age" est un nombre +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// invalide car "age" n'est pas un nombre +var invalidPerson: Person = { name: "Bobby", age: true }; // Les interfaces peuvent aussi décrire un type de fonction interface SearchFunc { (source: string, subString: string): boolean; } -// Seul les types des paramètres sont importants, les noms ne le sont pas +// Seul les types des paramètres sont importants, les noms ne le sont pas. var mySearch: SearchFunc; mySearch = function(src: string, sub: string) { return src.search(sub) != -1; } -// Les membres des classes sont publiques par défaut +// Les membres des classes sont publiques par défaut. class Point { // Propriétés x: number; - // Constructeur - Les mots clés "public" et "private" dans ce contexte génèrent - // le code de la propriété et son initialisation dans le constructeur. - // Dans cet exemple, "y" sera défini de la même façon que "x", mais avec moins de code - // Les valeurs par défaut sont supportées + // Constructeur - Les mots clés "public" et "private" dans ce contexte + // génèrent le code de la propriété et son initialisation dans le + // constructeur. Ici, "y" sera défini de la même façon que "x", + // mais avec moins de code. Les valeurs par défaut sont supportées. constructor(x: number, public y: number = 0) { this.x = x; } @@ -107,7 +110,9 @@ var p2 = new Point(25); //y will be 0 // Héritage class Point3D extends Point { constructor(x: number, y: number, public z: number = 0) { - super(x, y); // Un appel explicite au constructeur de la super classe est obligatoire. + // Un appel explicite au constructeur de la super classe + // est obligatoire. + super(x, y); } // Redéfinition -- cgit v1.2.3 From 288fcf7c2e03610400088381fae528294daa9f54 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 18:37:52 +0200 Subject: Create json-fr.html.markdown --- fr-fr/json-fr.html.markdown | 62 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 fr-fr/json-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown new file mode 100644 index 00000000..9664dd73 --- /dev/null +++ b/fr-fr/json-fr.html.markdown @@ -0,0 +1,62 @@ +--- +language: json +filename: learnjson-fr.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] + translators: + - ["Alois de Gouvello","https://github.com/aloisdg"] + lang: fr-fr +--- + +Comme JSON est un format d'échange de données êxtremement simple, ce Apprendre X en Y minutes +est susceptible d'être le plus simple jamais réalisé. + +JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons +les commentaires du langage C (//, /\* \*/). Pour les besoins de ce document, cependant, +tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. + + +```json +{ + "Clé": "valeur", + + "Clés": "devront toujours être entourées par des guillemets", + "nombres": 0, + "chaînes de caractères": "Hellø, wørld. Tous les caractères Unicode sont autorisés, accompagné d'un \"caractère d'échappement\".", + "a des booléens ?": true, + "rien": null, + + "grand nombre": 1.2e+100, + + "objets": { + "commentaire": "La majorité de votre strucutre sera des objets.", + + "tableau": [0, 1, 2, 3, "Les tableaux peuvent contenir n'importe quoi.", 5], + + "un autre objet": { + "commentaire": "Ces choses peuvent être imbriquées. C'est très utile." + } + }, + + "bêtises": [ + { + "sources de potassium": ["bananes"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "style alternatif": { + "commentaire": "regarde ça !" + , "position de la virgule": "n'a pas d'importance - aussi longtemps qu'elle est avant la valeur, alors elle est valide." + , "un autre commentaire": "comme c'est gentil" + }, + + "C'était court": "Et, vous avez terminé. Maintenant, vous savez tout ce que JSON a à offrir." +} +``` -- cgit v1.2.3 From c09e8af49e05cfba07a95e6cc471a874fe703563 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 18:49:19 +0200 Subject: Update json-fr.html.markdown Thank you @vendethiel for your comments --- fr-fr/json-fr.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown index 9664dd73..dc46e043 100644 --- a/fr-fr/json-fr.html.markdown +++ b/fr-fr/json-fr.html.markdown @@ -9,11 +9,11 @@ contributors: lang: fr-fr --- -Comme JSON est un format d'échange de données êxtremement simple, ce Apprendre X en Y minutes +Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes est susceptible d'être le plus simple jamais réalisé. JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons -les commentaires du langage C (//, /\* \*/). Pour les besoins de ce document, cependant, +les commentaires du langage C (`//`, `\* \*`). Pour les besoins de ce document, cependant, tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. -- cgit v1.2.3 From c0bfad80f0b9590081bf9e6a3cd9eea933632a29 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 20:43:17 +0200 Subject: Update typescript-fr.html.markdown Add modifications from @vendethiel's comments. See #1075 --- fr-fr/typescript-fr.html.markdown | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 63ed4c34..b8807104 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -8,9 +8,9 @@ filename: learntypescript-fr.ts lang: fr-fr --- -TypeScript est un langage visant à faciliter le développement d'applications large et scalable écrite en JavaScript. +TypeScript est un langage visant à faciliter le développement d'applications larges et scalables, écrites en JavaScript. TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript. -C'est une sur-couche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur +C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). @@ -22,7 +22,7 @@ var isDone: boolean = false; var lines: number = 42; var name: string = "Anders"; -// Quand c'est impossible à déterminer, on utilise le type `Any` +// Si nous ne pouvons pas déterminer le type, on utilise `Any` var notSure: any = 4; notSure = "maybe a string instead"; notSure = false; // ok, définitivement un booléen @@ -38,11 +38,11 @@ var c: Color = Color.Green; // Enfin, `void` est utilisé dans le cas spécifique // d'une fonction ne retournant rien function bigHorribleAlert(): void { - alert("I'm a little annoying box!"); + alert("Je suis une petite boîte ennuyeuse !"); } -// Les fontions sont des entités de première classe. Elles supportent -// les expressions lambda et utilisent l'inférence de types +// Les fonctions sont des entités de première classe. Le langage supporte +// les expressions lambda et utilise l'inférence de type // Les fonctions ci-dessous sont équivalentes, une signature identique // sera inférée par le compilateur, et le même JavaScript sera généré @@ -55,8 +55,8 @@ var f4 = (i: number) => { return i * i; } // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; -// Les interfaces sont structurés, tout ce qui a les propriétés est compatible -// avec l'interface +// Les interfaces sont structurées, tout les objets qui ont ces propriétés +// sont compatible avec l'interface interface Person { name: string; // Les propriétés optionnelles sont identifiées avec un "?" @@ -78,7 +78,8 @@ var invalidPerson: Person = { name: "Bobby", age: true }; interface SearchFunc { (source: string, subString: string): boolean; } -// Seul les types des paramètres sont importants, les noms ne le sont pas. + +// Seul les types des paramètres sont importants. Les noms ne le sont pas. var mySearch: SearchFunc; mySearch = function(src: string, sub: string) { return src.search(sub) != -1; @@ -86,7 +87,7 @@ mySearch = function(src: string, sub: string) { // Les membres des classes sont publiques par défaut. class Point { - // Propriétés + // Propriétés x: number; // Constructeur - Les mots clés "public" et "private" dans ce contexte @@ -105,7 +106,7 @@ class Point { } var p1 = new Point(10 ,20); -var p2 = new Point(25); //y will be 0 +var p2 = new Point(25); // y sera 0 // Héritage class Point3D extends Point { -- cgit v1.2.3 From 5042c531cc1ced74ae5e12dac225ba219ff713dc Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 20:58:03 +0200 Subject: Fix Markdown --- fr-fr/json-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown index dc46e043..41d79b18 100644 --- a/fr-fr/json-fr.html.markdown +++ b/fr-fr/json-fr.html.markdown @@ -13,7 +13,7 @@ Comme JSON est un format d'échange de données extrêmement simple, ce Apprendr est susceptible d'être le plus simple jamais réalisé. JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons -les commentaires du langage C (`//`, `\* \*`). Pour les besoins de ce document, cependant, +les commentaires du langage C (`//`, `/* */`). Pour les besoins de ce document, cependant, tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. -- cgit v1.2.3 From 86f406d99c829d0f3074f18346173387f1eb6064 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 20:59:27 +0200 Subject: Fix Header --- fr-fr/json-fr.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown index 41d79b18..49c95820 100644 --- a/fr-fr/json-fr.html.markdown +++ b/fr-fr/json-fr.html.markdown @@ -4,9 +4,9 @@ filename: learnjson-fr.json contributors: - ["Anna Harren", "https://github.com/iirelu"] - ["Marco Scannadinari", "https://github.com/marcoms"] - translators: +translators: - ["Alois de Gouvello","https://github.com/aloisdg"] - lang: fr-fr +lang: fr-fr --- Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes -- cgit v1.2.3 From afb44df97380cbfe037cdf5cf6bcb07355615552 Mon Sep 17 00:00:00 2001 From: chtiprog Date: Sun, 7 Dec 2014 01:47:25 +0100 Subject: Add French translation for R --- fr-fr/r-fr.html.markdown | 721 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 721 insertions(+) create mode 100644 fr-fr/r-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown new file mode 100644 index 00000000..8db78ef3 --- /dev/null +++ b/fr-fr/r-fr.html.markdown @@ -0,0 +1,721 @@ +--- +language: R +contributors: + - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] +translators: + - ["Anne-Catherine Dehier", "https://github.com/spellart"] +filename: learnr-fr.r +--- + +R est un langage de programmation statistique. Il dispose de nombreuses +librairies pour le téléchargement et le nettoyage des ensembles de données, +l'exécution de procédures statistiques, et pour faire des graphiques. +On peut également exécuter les commmandes R à l'aide d'un document LaTeX. + + +```r + +# Les commentaires commencent avec des symboles numériques. + +# Il n'est pas possible de faire des commentaires multilignes, +# mais on peut superposer plusieurs commentaires comme ceci. + +# Sur Windows ou Mac, taper COMMAND-ENTER pour exécuter une ligne + + + +############################################################################# +# Les choses que vous pouvez faire sans rien comprendre à la programmation +############################################################################# + +# In this section, we show off some of the cool stuff you can do in +# Dans cette section, nous vous montrons quelques trucs cools que vous +# pouvez faire avec R sans rien comprendre à la programmation. +# Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait. +# Profitez simplement ! + +data() # parcours les ensembles de données préchargées +data(rivers) # obtiens celui-ci: "Lengths of Major North American Rivers" +ls() # notez que "rivers" apparaît maintenant dans votre espace de travail +head(rivers) # Jetez un coup d'oeil à l'ensemble de données +# 735 320 325 392 524 450 + +length(rivers) # Combien de rivers ont été mesurées ? +# 141 +summary(rivers) # quelles sont les statistiques sommaires ? +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 + +# Fait un diagramme à tiges et à feuilles (visualisation de données de +types histogramme) +stem(rivers) + + +# Le point décimal est de 2 chiffres à droite du | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | +# 36 | 1 + +stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales ! +# Prenez-ça les fondamentalistes, la courbe en cloche + +# Le point décimal est à 1 chiffre à gauche du | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + +# Fais un histogramme : +hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces parenthèses +hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard + +# Ici d'autres données nettes qui viennent préchargées. R en a des tonnes. +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Year", + main="Number of important discoveries per year") +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", + main="Number of important discoveries per year") + +# Plutôt que de laisser l'ordre par défaut (par années) +# Nous pourrions aussi trier pour voir ce qu'il y a de typique +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 + +stem(discoveries, scale=2) +# +# Le point décimale est à la | +# +# 0 | 000000000 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 11 | +# 12 | 0 + +max(discoveries) +# 12 +summary(discoveries) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 + +# Lance un dès quelques fois +round(runif(7, min=.5, max=6.5)) +# 1 4 6 1 4 6 4 +# Vos numéros diffèreront des miens à moins que nous mettions le même random.seed(31337) + +# Dessine à partir d'une normale Gaussienne 9 fois +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + +################################################## +# les types de données et l'arithmétique de base +################################################## + +# Now for the programming-oriented part of the tutorial. +# In this section you will meet the important data types of R: +# integers, numerics, characters, logicals, and factors. +# There are others, but these are the bare minimum you need to +# get started. + +# Maintenant pour la partie orientée programmation du tutoriel. +# Dans cette section vous rencontrerez les types de données importants de R : +# les entiers, les numériques, les caractères, les logiques, et les facteurs. + +# LES ENTIERS +# Les entiers de mémoire longue sont écrit avec L +5L # 5 +class(5L) # "integer" +# (Essayez ?class pour plus d'information sur la fonction class().) +# Avec R, chaque valeur seule, comme 5L, est considéré comme un vecteur de longueur 1 +length(5L) # 1 +# On peut avoir un vecteur d'entiers avec une longueur > 1 aussi : +c(4L, 5L, 8L, 3L) # 4 5 8 3 +length(c(4L, 5L, 8L, 3L)) # 4 +class(c(4L, 5L, 8L, 3L)) # "integer" + +# LES NUMÉRIQUES +# Un "numeric" est un nombre à virgule flottante avec une double précision +5 # 5 +class(5) # "numeric" +# Encore une fois, tout dans R est un vecteur ; +# Vous pouvez faire un vecteur numérique avec plus d'un élément +c(3,3,3,2,2,1) # 3 3 3 2 2 1 +# Vous pouvez utiliser la notation scientifique aussi +5e4 # 50000 +6.02e23 # nombre d'Avogadro +1.6e-35 # longueur de Planck +# Vous pouvez également avoir des nombres infiniments grands ou petits +class(Inf) # "numeric" +class(-Inf) # "numeric" +# Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf); +# Ça permet d'éviter des tableaux Z-scores. + +# ARITHMÉTIQUES DE BASE +# Vous pouvez faire de l'arithmétique avec des nombres +# Faire des opérations arithmétiques en mixant des entiers et des numériques +# donne un autre numérique +10L + 66L # 76 # un entier plus un entier donne un entier +53.2 - 4 # 49.2 # un numérique moins un numérique donne un numérique +2.0 * 2L # 4 # un numérique multiplié par un entier donne un numérique +3L / 4 # 0.75 # un entier sur un numérique donne un numérique +3 %% 2 # 1 # le reste de deux numériques est un autre numérique +# Les opérations arithmétiques illégales rapportent un "Not A Number" : +0 / 0 # NaN +class(NaN) # "numeric" +# You can do arithmetic on two vectors with length greater than 1, +# Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une +# longueur plus grande que 1, à condition que la longueur du plus grand +# vecteur soit un multiple entier du plus petit +c(1,2,3) + c(1,2,3) # 2 4 6 + +# LES CARACTÈRES +# Il n'y a pas de différences entre les chaînes de caractères et les caractères en R +"Horatio" # "Horatio" +class("Horatio") # "character" +class('H') # "character" +# Ceux-ci sont tous les deux des vecteurs de longueur 1 +# Ici un plus long : +c('alef', 'bet', 'gimmel', 'dalet', 'he') +# => +# "alef" "bet" "gimmel" "dalet" "he" +length(c("Call","me","Ishmael")) # 3 +# Vous pouvez faire des expressions rationnelles sur les vecteurs de caractères : +substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " +gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." +# R possède plusieurs vecteurs de caractères préconstruits : +letters +# => +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" + +# LES TYPES LOGIQUES +# En R, un "logical" est un booléen +class(TRUE) # "logical" +class(FALSE) # "logical" +# Leur comportement est normal +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE +# Les données manquantes (NA) sont logiques également +class(NA) # "logical" +# Ici nous avons un vecteur de type logique avec plusieurs éléments : +c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE +c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE + +# LES FACTEURS +# The factor class is for categorical data +# La classe facteur sert aux données catégorielles +# les facteurs peuvent être ordonnés (comme les niveaux de catégorie d'enfants) +# ou non ordonnés (comme le sexe) +factor(c("female", "female", "male", NA, "female")) +# female female male female +# Les niveaux : female male +# Les "levels" sont les valeurs que les données catégorielles peuvent prendre +# Notez que cette donnée manquante n'entre pas dans le niveau +levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male" +# Si le vecteur de facteurs a une longueur 1, ses niveaux seront de longueur 1 également +length(factor("male")) # 1 +length(levels(factor("male"))) # 1 +# On rencontre communément des facteurs dans des trames de données, +# une structure de données que nous couvrirons plus tard +data(infert) # "Infertility after Spontaneous and Induced Abortion" +levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" + +# NULL +# "NULL" est bizarre ; on l'utilise pour effacer un vecteur +class(NULL) # NULL +parakeet +# => +# [1] "beak" "feathers" "wings" "eyes" +parakeet <- NULL +parakeet +# => +# NULL + +# LES CONTRAINTES DE TYPES +# Les contraintes de types servent à forcer une valeur à prendre un type différent +as.character(c(6, 8)) # "6" "8" +as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE +# Si vous mettez des éléments de différents types dans un vecteur, des coercitions bizarres se produisent : +c(TRUE, 4) # 1 4 +c("dog", TRUE, 4) # "dog" "TRUE" "4" +as.numeric("Bilbo") +# => +# [1] NA +# Message d'avertissement : +# NAs est introduit par coercition + +# Notez également : ce n'étaient que des types de données basiques +# Il y a beaucoup d'autres types de données, comme pour les dates, les séries de temps, etc ... + + + +################################################## +# Variables, boucles , if/else +################################################## + +# Une variable est comme une boîte où l'on garde une valeur pour l'utiliser plus tard. +# Nous appellons ça "assigner" une valeur à une variable. +# Avoir des variables nous permets d'écrire des boucles, des fonctions, et +# des instructions conditionnelles (if/else) + +# LES VARIABLES +# Beaucoup de façons d'assigner des choses : +x = 5 # c'est possible +y <- "1" # c'est préféré +TRUE -> z # ça marche mais c'est bizarre + +# LES BOUCLES +# Il y a les boucles for : +for (i in 1:4) { + print(i) +} +# Il y a les boucles while : +a <- 10 +while (a > 4) { + cat(a, "...", sep = "") + a <- a - 1 +} +# Gardez à l'esprit que les boucles for et while s'exécute lentement en R +# Des opérations sur des vecteurs entiers (ex un ligne entière, une colonne entière), +# ou la fonction apply()-type (nous en parlerons plus tard), sont préférés + +# IF/ELSE +# Encore une fois assez standard +if (4 > 3) { + print("4 is greater than 3") +} else { + print("4 is not greater than 3") +} +# => +# [1] "4 is greater than 3" + +# LES FONCTIONS +# se définissent comme ceci : +jiggle <- function(x) { + x = x + rnorm(1, sd=.1) #add in a bit of (controlled) noise + return(x) +} +# Appelée comme n'importe quelle autre fonction R : +jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043 + + + +########################################################################### +# Les structures de données : les vecteurs, les matrices, les trames de données et les tableaux +########################################################################### + +# À UNE DIMENSION + +# Commençons par le tout début, et avec quelque chose que vous connaissez déjà : les vecteurs. +vec <- c(8, 9, 10, 11) +vec # 8 9 10 11 +# Nous demandons des éléments spécifiques en les mettant entre crochets +# (Notez que R commence à compter par 1) +vec[1] # 8 +letters[18] # "r" +LETTERS[13] # "M" +month.name[9] # "September" +c(6, 8, 7, 5, 3, 0, 9)[3] # 7 +# Nous pouvons également rechercher des indices de composants spécifiques, +which(vec %% 2 == 0) # 1 3 +# Récupèrer seulement quelques premières ou dernières entrées du vecteur, +head(vec, 1) # 8 +tail(vec, 2) # 10 11 +# ou trouver si un certaine valeur est dans le vecteur +any(vec == 10) # TRUE +# Si un index "dépasse" vous obtiendrez NA : +vec[6] # NA +# Vous pouvez trouver la longueur de votre vecteur avec length() +length(vec) # 4 +# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des sous-ensembles de vecteurs +vec * 4 # 16 20 24 28 +vec[2:3] * 5 # 25 30 +any(vec[2:3] == 8) # FALSE +# Et R a beaucoup de fonctions préconstruites pour résumer les vecteurs +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 +# Quelques fonctions préconstruites sympas supplémentaires : +5:15 # 5 6 7 8 9 10 11 12 13 14 15 +seq(from=0, to=31337, by=1337) +# => +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 + +# À DEUX DIMENSIONS (TOUT DANS UNE CLASSE) + +# Vous pouvez faire une matrice de toutes les entrées du même type comme ceci : +mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Différemment du vecteur, la classe d'une matrice est "matrix",peut importe ce qu'elle contient +class(mat) # => "matrix" +# Demander la première ligne +mat[1,] # 1 4 +# Réaliser une opération sur la première colonne +3 * mat[,1] # 3 6 9 +# Ask for a specific cell +mat[3,2] # 6 + +# Transposer la matrice entière +t(mat) +# => +# [,1] [,2] [,3] +# [1,] 1 2 3 +# [2,] 4 5 6 + +# La multiplication de matrices +mat %*% t(mat) +# => +# [,1] [,2] [,3] +# [1,] 17 22 27 +# [2,] 22 29 36 +# [3,] 27 36 45 + +# cbind() colle des vecteurs ensemble en colonne pour faire une matrice +mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) +mat2 +# => +# [,1] [,2] +# [1,] "1" "dog" +# [2,] "2" "cat" +# [3,] "3" "bird" +# [4,] "4" "dog" +class(mat2) # matrix +# Encore une fois notez ce qui se passe ! +# Parce que les matrices peuvent contenir des entrées de toutes sortes de classes, +# tout sera converti en classe caractère +c(class(mat2[,1]), class(mat2[,2])) + +# rbind() colle des vecteurs ensemble par lignes pour faire une matrice +mat3 <- rbind(c(1,2,4,5), c(6,7,0,4)) +mat3 +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 2 4 5 +# [2,] 6 7 0 4 +# Ah, tout de la même classe. Pas de coercitions. Beaucoup mieux. + +# À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES) + +# Pour des colonnes de différents types, utiliser une trame de donnée +# Cette structure de données est si utile pour la programmation statistique, +# qu'une version a été ajoutée à Python dans le paquet "pandas". + +students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"), + c(3,2,2,1,0,-1), + c("H", "G", "G", "R", "S", "G")) +names(students) <- c("name", "year", "house") # name the columns +class(students) # "data.frame" +students +# => +# name year house +# 1 Cedric 3 H +# 2 Fred 2 G +# 3 George 2 G +# 4 Cho 1 R +# 5 Draco 0 S +# 6 Ginny -1 G +class(students$year) # "numeric" +class(students[,3]) # "factor" +# Trouver les dimensions +nrow(students) # 6 +ncol(students) # 3 +dim(students) # 6 3 +# La fonction data.frame() convertit les vecteurs caractères en vecteurs de facteurs +# par défaut; désactiver cette fonction en règlant stringsAsFactors = FALSE +# quand vous créer la data.frame +?data.frame + +# Il y a plusieurs façons tortueuses de subdiviser les trames de données +# toutes subtilement différentes +students$year # 3 2 2 1 0 -1 +students[,2] # 3 2 2 1 0 -1 +students[,"year"] # 3 2 2 1 0 -1 + +# Une version augmentée de la structure data.frame est data.table +# Si vous travaillez avec des données volumineuses ou des panels, ou avez +# besoin de fusionner quelques ensembles de données, data.table peut être +# un bon choix. Ici un tour éclair : +install.packages("data.table") # download the package from CRAN +require(data.table) # load it +students <- as.data.table(students) +students # note the slightly different print-out +# => +# name year house +# 1: Cedric 3 H +# 2: Fred 2 G +# 3: George 2 G +# 4: Cho 1 R +# 5: Draco 0 S +# 6: Ginny -1 G +students[name=="Ginny"] # get rows with name == "Ginny" +# => +# name year house +# 1: Ginny -1 G +students[year==2] # get rows with year == 2 +# => +# name year house +# 1: Fred 2 G +# 2: George 2 G +# data.table facilite la fusion entre deux ensembles de données +# Faisons un autre data.table pour fusionner students +founders <- data.table(house=c("G","H","R","S"), + founder=c("Godric","Helga","Rowena","Salazar")) +founders +# => +# house founder +# 1: G Godric +# 2: H Helga +# 3: R Rowena +# 4: S Salazar +setkey(students, house) +setkey(founders, house) +students <- founders[students] # merge the two data sets by matching "house" +setnames(students, c("house","houseFounderName","studentName","year")) +students[,order(c("name","year","house","houseFounderName")), with=F] +# => +# studentName year house houseFounderName +# 1: Fred 2 G Godric +# 2: George 2 G Godric +# 3: Ginny -1 G Godric +# 4: Cedric 3 H Helga +# 5: Cho 1 R Rowena +# 6: Draco 0 S Salazar + +# data.table facilite le sommaire des tableaux +students[,sum(year),by=house] +# => +# house V1 +# 1: G 3 +# 2: H 3 +# 3: R 1 +# 4: S 0 + +# Pour supprimer une colonne d'une data.frame ou data.table, +# assignez-lui la valeur NULL +students$houseFounderName <- NULL +students +# => +# studentName year house +# 1: Fred 2 G +# 2: George 2 G +# 3: Ginny -1 G +# 4: Cedric 3 H +# 5: Cho 1 R +# 6: Draco 0 S + +# Supprimer une ligne en subdivisant +# En utilisant data.table : +students[studentName != "Draco"] +# => +# house studentName year +# 1: G Fred 2 +# 2: G George 2 +# 3: G Ginny -1 +# 4: H Cedric 3 +# 5: R Cho 1 +# En utilisant data.frame : +students <- as.data.frame(students) +students[students$house != "G",] +# => +# house houseFounderName studentName year +# 4 H Helga Cedric 3 +# 5 R Rowena Cho 1 +# 6 S Salazar Draco 0 + +# MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE) + +# Les arrays créent des tableaux de n dimensions +# Tous les éléments doivent être du même type +# Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice) +array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 4 8 3 +# [2,] 2 5 9 6 +# Vous pouvez utiliser array pour faire des matrices à 3 dimensions aussi +array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) +# => +# , , 1 +# +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 +# +# , , 2 +# +# [,1] [,2] +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 + +# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, DE DIFFÉRENTS TYPES) + +# Enfin R a des listes (de vecteurs) +list1 <- list(time = 1:40) +list1$price = c(rnorm(40,.5*list1$time,4)) # random +list1 +# Vous pouvez obtenir des éléments de la liste comme ceci +list1$time # one way +list1[["time"]] # another way +list1[[1]] # yet another way +# => +# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 +# [34] 34 35 36 37 38 39 40 +# Vous pouvez subdiviser les éléments d'une liste comme n'importe quel vecteur +list1$price[4] + +# Les listes ne sont pas les structures de données les plus efficaces +# pour travailler en R; +# À moins d'avoir une très bonne raison, vous devriez appliquer data.frames +# Les listes sont souvent retournées par des fonctions qui effectuent des régressions linéaires + +################################################## +# La famille de fonction apply() +################################################## + +# Vous vous rappelez mat ? +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X +# sur les lignes (MAR = 1) ou les colonnes (MAR = 2) +# R fait FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement +# qu'une bouce for ou while le ferait +apply(mat, MAR = 2, jiggle) +# => +# [,1] [,2] +# [1,] 3 15 +# [2,] 7 19 +# [3,] 11 23 +# D'autres fonctions : ?lapply, ?sapply + +# Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant + +# Le paque plyr vise à remplacer (et améliorer !) la famille *apply(). +install.packages("plyr") +require(plyr) +?plyr + + + +######################### +# Charger des données +######################### + +# "pets.csv" est un fichier sur internet +# (mais il pourrait être tout aussi facilement sur votre ordinateur) +pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv") +pets +head(pets, 2) # first two rows +tail(pets, 1) # last row + +# Pour sauver une trame de donnée ou une matrice en fichier .csv +write.csv(pets, "pets2.csv") # to make a new .csv file +# définir le répertoire de travail avec setwd(), le récupérer avec getwd() + +# Essayez ?read.csv et ?write.csv pour plus d'informations + + + +######################### +# Les tracés +######################### + +# LES FONCTIONS DE TRACÉS PRÉCONSTRUITES +# Les diagrammes de dispersion ! +plot(list1$time, list1$price, main = "fake data") +# Les régressions ! +linearModel <- lm(price ~ time, data = list1) +linearModel # sort le résultat de la régression +# Tracer une ligne de regression sur une tracé existant +abline(linearModel, col = "red") +# Obtenir une variété de diagnostiques sympas +plot(linearModel) +# Les histogrammes ! +hist(rpois(n = 10000, lambda = 5), col = "thistle") +# Les diagrammes en bâtons ! +barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) + +# GGPLOT2 +# Mais ceux-ci ne sont même pas les plus jolis tracés de R +# Essayez le paquet ggplot2 pour d'avantages de graphiques meilleurs +install.packages("ggplot2") +require(ggplot2) +?ggplot2 +pp <- ggplot(students, aes(x=house)) +pp + geom_histogram() +ll <- as.data.table(list1) +pp <- ggplot(ll, aes(x=time,price)) +pp + geom_point() +# ggplot2 a une documentation excellente (disponible sur http://docs.ggplot2.org/current/) + + + +``` + +## How do I get R? + +* Get R and the R GUI from [http://www.r-project.org/](http://www.r-project.org/) +* [RStudio](http://www.rstudio.com/ide/) is another GUI -- cgit v1.2.3 From a6c01bf515c02522f3ff128a7d55806908ea3871 Mon Sep 17 00:00:00 2001 From: Chtiprog Date: Sun, 3 May 2015 21:44:23 -0300 Subject: add french translation of R --- fr-fr/r-fr.html.markdown | 286 +++++++++++++++++++++++++---------------------- 1 file changed, 154 insertions(+), 132 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown index 8db78ef3..d6879c1f 100644 --- a/fr-fr/r-fr.html.markdown +++ b/fr-fr/r-fr.html.markdown @@ -9,9 +9,9 @@ filename: learnr-fr.r --- R est un langage de programmation statistique. Il dispose de nombreuses -librairies pour le téléchargement et le nettoyage des ensembles de données, -l'exécution de procédures statistiques, et pour faire des graphiques. -On peut également exécuter les commmandes R à l'aide d'un document LaTeX. +librairies pour le téléchargement et le nettoyage d'ensembles de données, +l'exécution de procédures statistiques, et la réalisation de graphiques. +On peut également exécuter les commmandes `R` au sein d'un document LaTeX. ```r @@ -25,30 +25,30 @@ On peut également exécuter les commmandes R à l'aide d'un document LaTeX. -############################################################################# -# Les choses que vous pouvez faire sans rien comprendre à la programmation -############################################################################# +######################################################################## +# Les choses que vous pouvez faire sans rien comprendre +# à la programmation +######################################################################## -# In this section, we show off some of the cool stuff you can do in # Dans cette section, nous vous montrons quelques trucs cools que vous # pouvez faire avec R sans rien comprendre à la programmation. # Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait. # Profitez simplement ! -data() # parcours les ensembles de données préchargées -data(rivers) # obtiens celui-ci: "Lengths of Major North American Rivers" -ls() # notez que "rivers" apparaît maintenant dans votre espace de travail -head(rivers) # Jetez un coup d'oeil à l'ensemble de données +data() # parcours les ensembles de données préchargées +data(rivers) # récupère ceci : "Lengths of Major North American Rivers" +ls() # notez que "rivers" apparaît maintenant dans votre espace de travail +head(rivers) # donne un aperçu des données # 735 320 325 392 524 450 length(rivers) # Combien de rivers ont été mesurées ? # 141 -summary(rivers) # quelles sont les statistiques sommaires ? -# Min. 1st Qu. Median Mean 3rd Qu. Max. -# 135.0 310.0 425.0 591.2 680.0 3710.0 +summary(rivers) # Quels sont les principales données statistiques ? +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 # Fait un diagramme à tiges et à feuilles (visualisation de données de -types histogramme) +# types histogramme) stem(rivers) @@ -64,23 +64,24 @@ stem(rivers) # 14 | 56 # 16 | 7 # 18 | 9 -# 20 | +# 20 | # 22 | 25 # 24 | 3 -# 26 | -# 28 | -# 30 | -# 32 | -# 34 | +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | # 36 | 1 -stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales ! -# Prenez-ça les fondamentalistes, la courbe en cloche +stem(log(rivers)) # Notez que les données ne sont ni normales +# ni lognormales ! +# Prenez-ça, la courbe en cloche # Le point décimal est à 1 chiffre à gauche du | # # 48 | 1 -# 50 | +# 50 | # 52 | 15578 # 54 | 44571222466689 # 56 | 023334677000124455789 @@ -95,14 +96,14 @@ stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales ! # 74 | 84 # 76 | 56 # 78 | 4 -# 80 | +# 80 | # 82 | 2 # Fais un histogramme : -hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces parenthèses +hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard -# Ici d'autres données nettes qui viennent préchargées. R en a des tonnes. +# Ici d'autres données qui viennent préchargées. R en a des tonnes. data(discoveries) plot(discoveries, col="#333333", lwd=3, xlab="Year", main="Number of important discoveries per year") @@ -118,7 +119,7 @@ sort(discoveries) # [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 stem(discoveries, scale=2) -# +# # Le point décimale est à la | # # 0 | 000000000 @@ -132,19 +133,20 @@ stem(discoveries, scale=2) # 8 | 0 # 9 | 0 # 10 | 0 -# 11 | +# 11 | # 12 | 0 max(discoveries) # 12 summary(discoveries) -# Min. 1st Qu. Median Mean 3rd Qu. Max. -# 0.0 2.0 3.0 3.1 4.0 12.0 +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 -# Lance un dès quelques fois +# Lance un dès plusieurs fois round(runif(7, min=.5, max=6.5)) # 1 4 6 1 4 6 4 -# Vos numéros diffèreront des miens à moins que nous mettions le même random.seed(31337) +# Vos numéros diffèreront des miens à moins que nous mettions +# le même random.seed(31337) # Dessine à partir d'une normale Gaussienne 9 fois rnorm(9) @@ -153,15 +155,9 @@ rnorm(9) -################################################## +############################################################## # les types de données et l'arithmétique de base -################################################## - -# Now for the programming-oriented part of the tutorial. -# In this section you will meet the important data types of R: -# integers, numerics, characters, logicals, and factors. -# There are others, but these are the bare minimum you need to -# get started. +############################################################## # Maintenant pour la partie orientée programmation du tutoriel. # Dans cette section vous rencontrerez les types de données importants de R : @@ -171,22 +167,23 @@ rnorm(9) # Les entiers de mémoire longue sont écrit avec L 5L # 5 class(5L) # "integer" -# (Essayez ?class pour plus d'information sur la fonction class().) -# Avec R, chaque valeur seule, comme 5L, est considéré comme un vecteur de longueur 1 +# (Essayez ?class pour plus d'informations sur la fonction class().) +# Avec R, chaque valeur seule, comme 5L, est considéré comme +# un vecteur de longueur 1 length(5L) # 1 -# On peut avoir un vecteur d'entiers avec une longueur > 1 aussi : +# On peut avoir un vecteur d'entiers avec une longueur > 1 : c(4L, 5L, 8L, 3L) # 4 5 8 3 length(c(4L, 5L, 8L, 3L)) # 4 class(c(4L, 5L, 8L, 3L)) # "integer" # LES NUMÉRIQUES -# Un "numeric" est un nombre à virgule flottante avec une double précision +# Un "numeric" est un nombre à virgule flottante d'une précision double 5 # 5 class(5) # "numeric" # Encore une fois, tout dans R est un vecteur ; # Vous pouvez faire un vecteur numérique avec plus d'un élément c(3,3,3,2,2,1) # 3 3 3 2 2 1 -# Vous pouvez utiliser la notation scientifique aussi +# Vous pouvez aussi utiliser la notation scientifique 5e4 # 50000 6.02e23 # nombre d'Avogadro 1.6e-35 # longueur de Planck @@ -198,24 +195,25 @@ class(-Inf) # "numeric" # ARITHMÉTIQUES DE BASE # Vous pouvez faire de l'arithmétique avec des nombres -# Faire des opérations arithmétiques en mixant des entiers et des numériques +# Faire des opérations arithmétiques en mixant des entiers +# et des numériques # donne un autre numérique 10L + 66L # 76 # un entier plus un entier donne un entier 53.2 - 4 # 49.2 # un numérique moins un numérique donne un numérique 2.0 * 2L # 4 # un numérique multiplié par un entier donne un numérique 3L / 4 # 0.75 # un entier sur un numérique donne un numérique -3 %% 2 # 1 # le reste de deux numériques est un autre numérique -# Les opérations arithmétiques illégales rapportent un "Not A Number" : +3 %% 2 # 1 # le reste de deux numériques est un autre numérique +# Les opérations arithmétiques illégales donnent un "Not A Number" : 0 / 0 # NaN class(NaN) # "numeric" -# You can do arithmetic on two vectors with length greater than 1, # Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une # longueur plus grande que 1, à condition que la longueur du plus grand # vecteur soit un multiple entier du plus petit c(1,2,3) + c(1,2,3) # 2 4 6 # LES CARACTÈRES -# Il n'y a pas de différences entre les chaînes de caractères et les caractères en R +# Il n'y a pas de différences entre les chaînes de caractères et +# les caractères en R "Horatio" # "Horatio" class("Horatio") # "character" class('H') # "character" @@ -225,7 +223,7 @@ c('alef', 'bet', 'gimmel', 'dalet', 'he') # => # "alef" "bet" "gimmel" "dalet" "he" length(c("Call","me","Ishmael")) # 3 -# Vous pouvez faire des expressions rationnelles sur les vecteurs de caractères : +# Vous pouvez utiliser des expressions rationnelles sur les vecteurs de caractères : substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." # R possède plusieurs vecteurs de caractères préconstruits : @@ -246,45 +244,57 @@ FALSE != FALSE # FALSE FALSE != TRUE # TRUE # Les données manquantes (NA) sont logiques également class(NA) # "logical" +# On utilise | et & pour les operations logiques. +# OR +TRUE | FALSE # TRUE +# AND +TRUE & FALSE # FALSE +# Vous pouvez tester si x est TRUE +isTRUE(TRUE) # TRUE # Ici nous avons un vecteur de type logique avec plusieurs éléments : c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE # LES FACTEURS -# The factor class is for categorical data -# La classe facteur sert aux données catégorielles -# les facteurs peuvent être ordonnés (comme les niveaux de catégorie d'enfants) +# La classe facteur sert pour les données catégorielles +# les facteurs peuvent être ordonnés (comme les niveaux de +# catégorie d'enfants) # ou non ordonnés (comme le sexe) factor(c("female", "female", "male", NA, "female")) # female female male female # Les niveaux : female male -# Les "levels" sont les valeurs que les données catégorielles peuvent prendre -# Notez que cette donnée manquante n'entre pas dans le niveau +# Les "levels" sont les valeurs que les données catégorielles +# peuvent prendre +# Notez que les données manquantes n'entrent pas dans le niveau levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male" -# Si le vecteur de facteurs a une longueur 1, ses niveaux seront de longueur 1 également +# Si le vecteur de facteurs a une longueur 1, ses niveaux seront +# de longueur 1 également length(factor("male")) # 1 length(levels(factor("male"))) # 1 -# On rencontre communément des facteurs dans des trames de données, -# une structure de données que nous couvrirons plus tard +# On rencontre communément des facteurs dans des "data frame", +# un type de données que nous couvrirons plus tard data(infert) # "Infertility after Spontaneous and Induced Abortion" levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" # NULL # "NULL" est bizarre ; on l'utilise pour effacer un vecteur class(NULL) # NULL +parakeet = c("beak", "feathers", "wings", "eyes") parakeet # => -# [1] "beak" "feathers" "wings" "eyes" +# [1] "beak" "feathers" "wings" "eyes" parakeet <- NULL parakeet # => # NULL # LES CONTRAINTES DE TYPES -# Les contraintes de types servent à forcer une valeur à prendre un type différent +# Les contraintes de types servent à forcer une valeur à prendre +# un type différent as.character(c(6, 8)) # "6" "8" as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE -# Si vous mettez des éléments de différents types dans un vecteur, des coercitions bizarres se produisent : +# Si vous mettez des éléments de différents types dans un vecteur, +# des coercitions bizarres se produisent : c(TRUE, 4) # 1 4 c("dog", TRUE, 4) # "dog" "TRUE" "4" as.numeric("Bilbo") @@ -294,17 +304,19 @@ as.numeric("Bilbo") # NAs est introduit par coercition # Notez également : ce n'étaient que des types de données basiques -# Il y a beaucoup d'autres types de données, comme pour les dates, les séries de temps, etc ... +# Il y a beaucoup d'autres types de données, comme pour les dates, +# les séries temporelles, etc ... -################################################## +####################################### # Variables, boucles , if/else -################################################## +####################################### -# Une variable est comme une boîte où l'on garde une valeur pour l'utiliser plus tard. +# Une variable est comme une boîte dans laquelle on garde une valeur +# pour l'utiliser plus tard. # Nous appellons ça "assigner" une valeur à une variable. -# Avoir des variables nous permets d'écrire des boucles, des fonctions, et +# Avoir des variables nous permet d'écrire des boucles, des fonctions, et # des instructions conditionnelles (if/else) # LES VARIABLES @@ -321,19 +333,22 @@ for (i in 1:4) { # Il y a les boucles while : a <- 10 while (a > 4) { - cat(a, "...", sep = "") - a <- a - 1 + cat(a, "...", sep = "") + a <- a - 1 } -# Gardez à l'esprit que les boucles for et while s'exécute lentement en R -# Des opérations sur des vecteurs entiers (ex un ligne entière, une colonne entière), -# ou la fonction apply()-type (nous en parlerons plus tard), sont préférés +# Gardez à l'esprit que les boucles for et while s'exécutent lentement +# en R +# Des opérations sur des vecteurs entiers (ex une ligne entière, +# une colonne entière), +# ou les fonctions de type apply() (nous en parlerons plus tard), +# sont préférées # IF/ELSE # Encore une fois assez standard if (4 > 3) { - print("4 is greater than 3") + print("4 is greater than 3") } else { - print("4 is not greater than 3") + print("4 is not greater than 3") } # => # [1] "4 is greater than 3" @@ -341,25 +356,27 @@ if (4 > 3) { # LES FONCTIONS # se définissent comme ceci : jiggle <- function(x) { - x = x + rnorm(1, sd=.1) #add in a bit of (controlled) noise - return(x) + x = x + rnorm(1, sd=.1) #add in a bit of (controlled) noise + return(x) } -# Appelée comme n'importe quelle autre fonction R : +# Appelées comme n'importe quelles autres fonction R : jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043 -########################################################################### -# Les structures de données : les vecteurs, les matrices, les trames de données et les tableaux -########################################################################### +########################################################################## +# Les structures de données : les vecteurs, les matrices, +# les data frame et les tableaux +########################################################################## # À UNE DIMENSION -# Commençons par le tout début, et avec quelque chose que vous connaissez déjà : les vecteurs. +# Commençons par le tout début, et avec quelque chose que +# vous connaissez déjà : les vecteurs. vec <- c(8, 9, 10, 11) vec # 8 9 10 11 # Nous demandons des éléments spécifiques en les mettant entre crochets -# (Notez que R commence à compter par 1) +# (Notez que R commence à compter à partir de 1) vec[1] # 8 letters[18] # "r" LETTERS[13] # "M" @@ -367,7 +384,7 @@ month.name[9] # "September" c(6, 8, 7, 5, 3, 0, 9)[3] # 7 # Nous pouvons également rechercher des indices de composants spécifiques, which(vec %% 2 == 0) # 1 3 -# Récupèrer seulement quelques premières ou dernières entrées du vecteur, +# Récupèrer seulement les premières ou dernières entrées du vecteur, head(vec, 1) # 8 tail(vec, 2) # 10 11 # ou trouver si un certaine valeur est dans le vecteur @@ -376,7 +393,8 @@ any(vec == 10) # TRUE vec[6] # NA # Vous pouvez trouver la longueur de votre vecteur avec length() length(vec) # 4 -# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des sous-ensembles de vecteurs +# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des +# sous-ensembles de vecteurs vec * 4 # 16 20 24 28 vec[2:3] * 5 # 25 30 any(vec[2:3] == 8) # FALSE @@ -396,7 +414,7 @@ seq(from=0, to=31337, by=1337) # À DEUX DIMENSIONS (TOUT DANS UNE CLASSE) -# Vous pouvez faire une matrice de toutes les entrées du même type comme ceci : +# Vous pouvez créer une matrice à partir d'entrées du même type comme ceci : mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) mat # => @@ -404,13 +422,14 @@ mat # [1,] 1 4 # [2,] 2 5 # [3,] 3 6 -# Différemment du vecteur, la classe d'une matrice est "matrix",peut importe ce qu'elle contient +# Différemment du vecteur, la classe d'une matrice est "matrix", +# peut importe ce qu'elle contient class(mat) # => "matrix" # Demander la première ligne mat[1,] # 1 4 # Réaliser une opération sur la première colonne 3 * mat[,1] # 3 6 9 -# Ask for a specific cell +# Demander une cellule spécifique mat[3,2] # 6 # Transposer la matrice entière @@ -432,15 +451,15 @@ mat %*% t(mat) mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) mat2 # => -# [,1] [,2] -# [1,] "1" "dog" -# [2,] "2" "cat" -# [3,] "3" "bird" +# [,1] [,2] +# [1,] "1" "dog" +# [2,] "2" "cat" +# [3,] "3" "bird" # [4,] "4" "dog" class(mat2) # matrix -# Encore une fois notez ce qui se passe ! -# Parce que les matrices peuvent contenir des entrées de toutes sortes de classes, -# tout sera converti en classe caractère +# Encore une fois regardez ce qui se passe ! +# Parce que les matrices peuvent contenir des entrées de toutes sortes de +# classes, tout sera converti en classe caractère c(class(mat2[,1]), class(mat2[,2])) # rbind() colle des vecteurs ensemble par lignes pour faire une matrice @@ -454,7 +473,7 @@ mat3 # À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES) -# Pour des colonnes de différents types, utiliser une trame de donnée +# Pour des colonnes de différents types, utiliser une data frame # Cette structure de données est si utile pour la programmation statistique, # qu'une version a été ajoutée à Python dans le paquet "pandas". @@ -478,25 +497,25 @@ class(students[,3]) # "factor" nrow(students) # 6 ncol(students) # 3 dim(students) # 6 3 -# La fonction data.frame() convertit les vecteurs caractères en vecteurs de facteurs -# par défaut; désactiver cette fonction en règlant stringsAsFactors = FALSE -# quand vous créer la data.frame +# La fonction data.frame() convertit les vecteurs caractères en vecteurs de +# facteurs par défaut; désactiver cette fonction en règlant +# stringsAsFactors = FALSE quand vous créer la data.frame ?data.frame -# Il y a plusieurs façons tortueuses de subdiviser les trames de données +# Il y a plusieurs façons de subdiviser les trames de données # toutes subtilement différentes students$year # 3 2 2 1 0 -1 students[,2] # 3 2 2 1 0 -1 students[,"year"] # 3 2 2 1 0 -1 # Une version augmentée de la structure data.frame est data.table -# Si vous travaillez avec des données volumineuses ou des panels, ou avez +# Si vous travaillez avec des données volumineuses ou des panels, ou avez # besoin de fusionner quelques ensembles de données, data.table peut être # un bon choix. Ici un tour éclair : -install.packages("data.table") # download the package from CRAN -require(data.table) # load it +install.packages("data.table") # télécharge le paquet depuis CRAN +require(data.table) # le charge students <- as.data.table(students) -students # note the slightly different print-out +students # regardez la différence à l'impression # => # name year house # 1: Cedric 3 H @@ -505,17 +524,17 @@ students # note the slightly different print-out # 4: Cho 1 R # 5: Draco 0 S # 6: Ginny -1 G -students[name=="Ginny"] # get rows with name == "Ginny" +students[name=="Ginny"] # obtiens les lignes avec name == "Ginny" # => # name year house # 1: Ginny -1 G -students[year==2] # get rows with year == 2 +students[year==2] # obtiens les lignes avec year == 2 # => # name year house # 1: Fred 2 G # 2: George 2 G # data.table facilite la fusion entre deux ensembles de données -# Faisons un autre data.table pour fusionner students +# Faisons une autre data.table pour fusionner students founders <- data.table(house=c("G","H","R","S"), founder=c("Godric","Helga","Rowena","Salazar")) founders @@ -527,7 +546,7 @@ founders # 4: S Salazar setkey(students, house) setkey(founders, house) -students <- founders[students] # merge the two data sets by matching "house" +students <- founders[students] # merge les deux ensembles de données qui matchent "house" setnames(students, c("house","houseFounderName","studentName","year")) students[,order(c("name","year","house","houseFounderName")), with=F] # => @@ -539,7 +558,7 @@ students[,order(c("name","year","house","houseFounderName")), with=F] # 5: Cho 1 R Rowena # 6: Draco 0 S Salazar -# data.table facilite le sommaire des tableaux +# data.table facilite le résumé des tableaux students[,sum(year),by=house] # => # house V1 @@ -561,7 +580,7 @@ students # 5: Cho 1 R # 6: Draco 0 S -# Supprimer une ligne en subdivisant +# Supprimer une ligne en subdivisant # En utilisant data.table : students[studentName != "Draco"] # => @@ -607,16 +626,17 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) # [2,] 60 7 # [3,] 0 847 -# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, DE DIFFÉRENTS TYPES) +# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, +# DE DIFFÉRENTS TYPES) # Enfin R a des listes (de vecteurs) list1 <- list(time = 1:40) list1$price = c(rnorm(40,.5*list1$time,4)) # random list1 # Vous pouvez obtenir des éléments de la liste comme ceci -list1$time # one way -list1[["time"]] # another way -list1[[1]] # yet another way +list1$time # une façon +list1[["time"]] # une autre façon +list1[[1]] # encore une façon différente # => # [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 # [34] 34 35 36 37 38 39 40 @@ -624,13 +644,14 @@ list1[[1]] # yet another way list1$price[4] # Les listes ne sont pas les structures de données les plus efficaces -# pour travailler en R; -# À moins d'avoir une très bonne raison, vous devriez appliquer data.frames -# Les listes sont souvent retournées par des fonctions qui effectuent des régressions linéaires +# à utiliser avec R; +# À moins d'avoir une très bonne raison, vous devriez utiliser data.frames +# Les listes sont souvent retournées par des fonctions qui effectuent +# des régressions linéaires -################################################## +########################################## # La famille de fonction apply() -################################################## +########################################## # Vous vous rappelez mat ? mat @@ -641,8 +662,8 @@ mat # [3,] 3 6 # Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X # sur les lignes (MAR = 1) ou les colonnes (MAR = 2) -# R fait FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement -# qu'une bouce for ou while le ferait +# R exécute FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement +# que le ferait une boucle for ou while apply(mat, MAR = 2, jiggle) # => # [,1] [,2] @@ -650,7 +671,7 @@ apply(mat, MAR = 2, jiggle) # [2,] 7 19 # [3,] 11 23 # D'autres fonctions : ?lapply, ?sapply - + # Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant # Le paque plyr vise à remplacer (et améliorer !) la famille *apply(). @@ -660,9 +681,9 @@ require(plyr) -######################### +############################ # Charger des données -######################### +############################ # "pets.csv" est un fichier sur internet # (mais il pourrait être tout aussi facilement sur votre ordinateur) @@ -671,7 +692,7 @@ pets head(pets, 2) # first two rows tail(pets, 1) # last row -# Pour sauver une trame de donnée ou une matrice en fichier .csv +# Pour sauvegarder une data frame ou une matrice en fichier .csv write.csv(pets, "pets2.csv") # to make a new .csv file # définir le répertoire de travail avec setwd(), le récupérer avec getwd() @@ -679,9 +700,9 @@ write.csv(pets, "pets2.csv") # to make a new .csv file -######################### +################ # Les tracés -######################### +################ # LES FONCTIONS DE TRACÉS PRÉCONSTRUITES # Les diagrammes de dispersion ! @@ -700,7 +721,7 @@ barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) # GGPLOT2 # Mais ceux-ci ne sont même pas les plus jolis tracés de R -# Essayez le paquet ggplot2 pour d'avantages de graphiques meilleurs +# Essayez le paquet ggplot2 pour d'avantages de graphiques install.packages("ggplot2") require(ggplot2) ?ggplot2 @@ -709,13 +730,14 @@ pp + geom_histogram() ll <- as.data.table(list1) pp <- ggplot(ll, aes(x=time,price)) pp + geom_point() -# ggplot2 a une documentation excellente (disponible sur http://docs.ggplot2.org/current/) +# ggplot2 a une documentation excellente +#(disponible sur http://docs.ggplot2.org/current/) ``` -## How do I get R? +## Comment j'obtiens R ? -* Get R and the R GUI from [http://www.r-project.org/](http://www.r-project.org/) -* [RStudio](http://www.rstudio.com/ide/) is another GUI +* Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/) +* [RStudio](http://www.rstudio.com/ide/) est un autre GUI -- cgit v1.2.3 From a0ca5283d69be29bf7fa26ddd082ff927068883b Mon Sep 17 00:00:00 2001 From: Chtiprog Date: Mon, 18 May 2015 00:03:52 -0300 Subject: Refactor r french translation --- fr-fr/r-fr.html.markdown | 85 +++++++++++++++++++++++++----------------------- 1 file changed, 44 insertions(+), 41 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown index d6879c1f..3f225a0f 100644 --- a/fr-fr/r-fr.html.markdown +++ b/fr-fr/r-fr.html.markdown @@ -9,9 +9,9 @@ filename: learnr-fr.r --- R est un langage de programmation statistique. Il dispose de nombreuses -librairies pour le téléchargement et le nettoyage d'ensembles de données, +bibliothèques pour le téléchargement et le nettoyage d'ensembles de données, l'exécution de procédures statistiques, et la réalisation de graphiques. -On peut également exécuter les commmandes `R` au sein d'un document LaTeX. +On peut également exécuter des commmandes `R` au sein d'un document LaTeX. ```r @@ -19,9 +19,11 @@ On peut également exécuter les commmandes `R` au sein d'un document LaTeX. # Les commentaires commencent avec des symboles numériques. # Il n'est pas possible de faire des commentaires multilignes, -# mais on peut superposer plusieurs commentaires comme ceci. +# mais on peut placer plusieurs commentaires les uns en dessous +# des autres comme ceci. -# Sur Windows ou Mac, taper COMMAND-ENTER pour exécuter une ligne +# Sur Mac, taper COMMAND-ENTER pour exécuter une ligne +# et sur Windows taper CTRL-ENTER @@ -43,7 +45,7 @@ head(rivers) # donne un aperçu des données length(rivers) # Combien de rivers ont été mesurées ? # 141 -summary(rivers) # Quels sont les principales données statistiques ? +summary(rivers) # Quelles sont les principales données statistiques ? # Min. 1st Qu. Median Mean 3rd Qu. Max. # 135.0 310.0 425.0 591.2 680.0 3710.0 @@ -99,7 +101,7 @@ stem(log(rivers)) # Notez que les données ne sont ni normales # 80 | # 82 | 2 -# Fais un histogramme : +# Fait un histogramme : hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard @@ -110,7 +112,7 @@ plot(discoveries, col="#333333", lwd=3, xlab="Year", plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", main="Number of important discoveries per year") -# Plutôt que de laisser l'ordre par défaut (par années) +# Plutôt que de laisser l'ordre par défaut (par année) # Nous pourrions aussi trier pour voir ce qu'il y a de typique sort(discoveries) # [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 @@ -142,7 +144,7 @@ summary(discoveries) # Min. 1st Qu. Median Mean 3rd Qu. Max. # 0.0 2.0 3.0 3.1 4.0 12.0 -# Lance un dès plusieurs fois +# Lance un dé plusieurs fois round(runif(7, min=.5, max=6.5)) # 1 4 6 1 4 6 4 # Vos numéros diffèreront des miens à moins que nous mettions @@ -164,11 +166,11 @@ rnorm(9) # les entiers, les numériques, les caractères, les logiques, et les facteurs. # LES ENTIERS -# Les entiers de mémoire longue sont écrit avec L +# Les entiers de type long sont écrits avec L 5L # 5 class(5L) # "integer" # (Essayez ?class pour plus d'informations sur la fonction class().) -# Avec R, chaque valeur seule, comme 5L, est considéré comme +# Avec R, chaque valeur seule, comme 5L, est considérée comme # un vecteur de longueur 1 length(5L) # 1 # On peut avoir un vecteur d'entiers avec une longueur > 1 : @@ -191,7 +193,7 @@ c(3,3,3,2,2,1) # 3 3 3 2 2 1 class(Inf) # "numeric" class(-Inf) # "numeric" # Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf); -# Ça permet d'éviter des tableaux Z-scores. +# Ça permet d'éviter de réaliser une table de la loi normale. # ARITHMÉTIQUES DE BASE # Vous pouvez faire de l'arithmétique avec des nombres @@ -233,7 +235,7 @@ letters # [20] "t" "u" "v" "w" "x" "y" "z" month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" -# LES TYPES LOGIQUES +# LES TYPES BOOLÉENS # En R, un "logical" est un booléen class(TRUE) # "logical" class(FALSE) # "logical" @@ -256,15 +258,16 @@ c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE # LES FACTEURS -# La classe facteur sert pour les données catégorielles -# les facteurs peuvent être ordonnés (comme les niveaux de -# catégorie d'enfants) -# ou non ordonnés (comme le sexe) +# Les facteurs sont généralement utilisés pour y stocker des +# variables qualitatives (catégorielles). +# Les facteurs peuvent être ordonnés (comme le niveau scolaire +# des enfants) ou non ordonnés (comme le sexe) factor(c("female", "female", "male", NA, "female")) # female female male female # Les niveaux : female male -# Les "levels" sont les valeurs que les données catégorielles -# peuvent prendre +# Les facteurs possèdent un attribut appelé niveau ("level"). +# Les niveaux sont des vecteurs contenant toutes les valeurs +# que peuvent prendre les données catégorielles. # Notez que les données manquantes n'entrent pas dans le niveau levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male" # Si le vecteur de facteurs a une longueur 1, ses niveaux seront @@ -288,8 +291,8 @@ parakeet # => # NULL -# LES CONTRAINTES DE TYPES -# Les contraintes de types servent à forcer une valeur à prendre +# LES CONVERSIONS DE TYPES +# Les conversions de types servent à forcer une valeur à prendre # un type différent as.character(c(6, 8)) # "6" "8" as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE @@ -304,7 +307,7 @@ as.numeric("Bilbo") # NAs est introduit par coercition # Notez également : ce n'étaient que des types de données basiques -# Il y a beaucoup d'autres types de données, comme pour les dates, +# Il y a beaucoup d'autres types de données, comme les dates, # les séries temporelles, etc ... @@ -321,7 +324,7 @@ as.numeric("Bilbo") # LES VARIABLES # Beaucoup de façons d'assigner des choses : -x = 5 # c'est possible +x = 5 # c'est correct y <- "1" # c'est préféré TRUE -> z # ça marche mais c'est bizarre @@ -337,11 +340,11 @@ while (a > 4) { a <- a - 1 } # Gardez à l'esprit que les boucles for et while s'exécutent lentement -# en R -# Des opérations sur des vecteurs entiers (ex une ligne entière, +# en R. +# Des opérations sur la totalité d'un vecteur (ex une ligne entière, # une colonne entière), # ou les fonctions de type apply() (nous en parlerons plus tard), -# sont préférées +# sont préférées. # IF/ELSE # Encore une fois assez standard @@ -356,7 +359,7 @@ if (4 > 3) { # LES FONCTIONS # se définissent comme ceci : jiggle <- function(x) { - x = x + rnorm(1, sd=.1) #add in a bit of (controlled) noise + x = x + rnorm(1, sd=.1) # ajoute un peu de bruit (contrôlé) return(x) } # Appelées comme n'importe quelles autres fonction R : @@ -366,7 +369,7 @@ jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043 ########################################################################## # Les structures de données : les vecteurs, les matrices, -# les data frame et les tableaux +# les data frames et les tableaux ########################################################################## # À UNE DIMENSION @@ -387,7 +390,7 @@ which(vec %% 2 == 0) # 1 3 # Récupèrer seulement les premières ou dernières entrées du vecteur, head(vec, 1) # 8 tail(vec, 2) # 10 11 -# ou trouver si un certaine valeur est dans le vecteur +# ou vérifier si un certaine valeur est dans le vecteur any(vec == 10) # TRUE # Si un index "dépasse" vous obtiendrez NA : vec[6] # NA @@ -398,7 +401,7 @@ length(vec) # 4 vec * 4 # 16 20 24 28 vec[2:3] * 5 # 25 30 any(vec[2:3] == 8) # FALSE -# Et R a beaucoup de fonctions préconstruites pour résumer les vecteurs +# Et R a beaucoup de méthodes statistiques pré-construites pour les vecteurs : mean(vec) # 9.5 var(vec) # 1.666667 sd(vec) # 1.290994 @@ -425,7 +428,7 @@ mat # Différemment du vecteur, la classe d'une matrice est "matrix", # peut importe ce qu'elle contient class(mat) # => "matrix" -# Demander la première ligne +# Récupérer la première ligne mat[1,] # 1 4 # Réaliser une opération sur la première colonne 3 * mat[,1] # 3 6 9 @@ -502,13 +505,13 @@ dim(students) # 6 3 # stringsAsFactors = FALSE quand vous créer la data.frame ?data.frame -# Il y a plusieurs façons de subdiviser les trames de données +# Il y a plusieurs façons de subdiviser les data frames, # toutes subtilement différentes students$year # 3 2 2 1 0 -1 students[,2] # 3 2 2 1 0 -1 students[,"year"] # 3 2 2 1 0 -1 -# Une version augmentée de la structure data.frame est data.table +# Une version améliorée de la structure data.frame est data.table. # Si vous travaillez avec des données volumineuses ou des panels, ou avez # besoin de fusionner quelques ensembles de données, data.table peut être # un bon choix. Ici un tour éclair : @@ -601,15 +604,15 @@ students[students$house != "G",] # MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE) -# Les arrays créent des tableaux de n dimensions -# Tous les éléments doivent être du même type +# Les arrays créent des tableaux de n dimensions. +# Tous les éléments doivent être du même type. # Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice) array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) # => # [,1] [,2] [,3] [,4] # [1,] 1 4 8 3 # [2,] 2 5 9 6 -# Vous pouvez utiliser array pour faire des matrices à 3 dimensions aussi +# Vous pouvez aussi utiliser array pour faire des matrices à 3 dimensions : array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) # => # , , 1 @@ -629,7 +632,7 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) # LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, # DE DIFFÉRENTS TYPES) -# Enfin R a des listes (de vecteurs) +# Enfin, R a des listes (de vecteurs) list1 <- list(time = 1:40) list1$price = c(rnorm(40,.5*list1$time,4)) # random list1 @@ -644,10 +647,10 @@ list1[[1]] # encore une façon différente list1$price[4] # Les listes ne sont pas les structures de données les plus efficaces -# à utiliser avec R; +# à utiliser avec R ; # À moins d'avoir une très bonne raison, vous devriez utiliser data.frames # Les listes sont souvent retournées par des fonctions qui effectuent -# des régressions linéaires +# des régressions linéaires. ########################################## # La famille de fonction apply() @@ -674,7 +677,7 @@ apply(mat, MAR = 2, jiggle) # Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant -# Le paque plyr vise à remplacer (et améliorer !) la famille *apply(). +# Le paquet plyr vise à remplacer (et améliorer !) la famille *apply(). install.packages("plyr") require(plyr) ?plyr @@ -704,7 +707,7 @@ write.csv(pets, "pets2.csv") # to make a new .csv file # Les tracés ################ -# LES FONCTIONS DE TRACÉS PRÉCONSTRUITES +# LES FONCTIONS DE TRACÉ PRÉCONSTRUITES # Les diagrammes de dispersion ! plot(list1$time, list1$price, main = "fake data") # Les régressions ! @@ -737,7 +740,7 @@ pp + geom_point() ``` -## Comment j'obtiens R ? +## Comment obtenir R ? * Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/) * [RStudio](http://www.rstudio.com/ide/) est un autre GUI -- cgit v1.2.3 From 1aa91a6420b17d6d982fb3361ba938511355fc7c Mon Sep 17 00:00:00 2001 From: Julien Cretel Date: Thu, 28 May 2015 20:40:39 +0200 Subject: [erlang/fr] Add french translation --- fr-fr/erlang-fr.html.markdown | 325 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 325 insertions(+) create mode 100644 fr-fr/erlang-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown new file mode 100644 index 00000000..564e176f --- /dev/null +++ b/fr-fr/erlang-fr.html.markdown @@ -0,0 +1,325 @@ +--- +language: erlang +contributors: + - ["Giovanni Cappellotto", "http://www.focustheweb.com/"] +translators: + - ["Julien Cretel", "https://github.com/Jubobs"] +filename: learnerlang-fr.erl +lang: fr-fr +--- + +```erlang +% Un signe pour cent marque le début d'un commentaire de fin de ligne. + +%% Deux signes pour cent sont utilisés pour commenter les fonctions. + +%%% Trois signes pour cent sont utilisés pour commenter les modules. + +% Trois types de ponctuation sont utilisés en Erlang. +% Les virgules (`,`) servent à séparer les paramètres dans les appels de +% fonctions, les contructeurs, et les motifs. +% Les points (`.`) (suivis par des caractères blancs) servent à séparer +% les fonctions et les expressions dans l'interpréteur. +% Les points-virgules (`;`) servent à séparer les clauses. Ces dernières +% apparaissent dans différent cas de figure : définitions de fonctions et +% expressions `case`, `if`, `try..catch`, et `receive`. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 1. Variables et filtrage par motif. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +Nb = 42. % Chaque nom de variable doit commencer par une lettre majuscule. + +% Les variables Erlang ne peuvent être affectées qu'une seule fois ; si vous +% essayez d'affecter une autre valeur à la variable `Nb`, vous obtiendrez +% une erreur. +Nb = 43. % ** exception error: no match of right hand side value 43 + +% Dans la plupart des languages, `=` indique une affectation. En Erlang, +% cependant, `=` indique un filtrage par motif. En fait, `Gauche = Droit` +% signifie ce qui suit : évalue le côté droit (`Droit`), et ensuite filtre le +% résultat à l'aide du motif du côté gauche (`Gauche`). +Nb = 7 * 6. + +% Nombre en virgule flottante. +Pi = 3.14159. + +% Les atomes représentent des valeurs constantes non-numériques. Un atome +% commence par une lettre minuscule, suivie d'une séquence composée de +% caractères alphanumériques, de tirets bas (`_`), ou d'arobases (`@`). +Bonjour = bonjour. +AutreNoeud = exemple@noeud. + +% Les atomes de valeur autre qu'alphanumérique peuvent être délimités par +% des guillemets droits simples. +AtomeAvecEspace = 'un atome contenant des espaces'. + +% Les tuples sont similaires aux enregistrements du language C. +Point = {point, 10, 45}. + +% Pour extraire des valeurs d'un tuple, on filtre par motif avec +% l'opérateur `=`. +{point, X, Y} = Point. % X = 10, Y = 45 + +% On peut utiliser `_` comme caractère joker pour les variables qui ne nous +% intéressent pas. Le symbol `_` est appelé variable muette. Contrairement +% aux variables normales, de multiples apparitions de `_` dans un même motif +% ne lient pas nécessairement à la même valeur. +Personne = {personne, {nom, {prenom, joe}, {famille, armstrong}}, + {pointure, 42}}. +{_, {_, {_, Qui}, _}, _} = Personne. % Qui = joe + +% Pour créer une liste, on écrit les éléments de la liste entre crochets, en +% les séparant par des virgules. +% Les éléments d'une liste peuvent avoir n'importe quel type. +% Le premier élément d'une liste est appelé la tête de la liste. Si on retire +% la tête d'une liste, ce qui reste est appelée la queue de la liste. +Articles = [{pommes, 10}, {poires, 6}, {lait, 3}]. + +% Si `Q` est une liste, alors `[T|Q]` est aussi une liste dont la tête est `T` +% et dont la queue est `Q`. La barre verticale (`|`) sépare la tête d'une +% liste de sa queue. +% `[]` est la liste vide. +% On peut extraire des éléments d'une liste par filtrage de motif. Si `L` est +% une liste non vide, alors l'expression `[X|Y] = L`, où `X` et `Y` sont des +% variables non affectées, va extraire la tête de la liste dans `X` et la +% queue de la liste dans `Y`. +[PremierArticle|AutresArticles] = Articles. +% PremierArticle = {pommmes, 10} +% AutresArticles = [{poires, 6}, {lait, 3}] + +% Il n'y a pas de chaînes de caractères en Erlang. Les chaînes de caractères +% ne sont rien de plus que des listes d'entiers. +% Les chaînes de caractères sont délimitées par des guillemets droits doubles +% (`"`). +Nom = "Bonjour". +[66, 111, 110, 106, 111, 117, 114] = "Bonjour". + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 2. Programmation séquentielle. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Les modules constituent l'unité de base d'un programme Erlang. Toutes les +% fonctions que l'on écrit sont sauvées dans des modules. Les modules sont +% enregistrés dans des fichiers avec une extension `.erl`. +% Les modules doivent être compilés afin d'éxecuter le programme. +% Un module compilé a une extension `.beam`. +-module(geometrie). +-export([aire/1]). % la liste des fonctions exportées par le module. + +% La fonction `aire` est composée de deux clauses. Les clauses sont séparées +% par un point-virgule, et la dernière clause est suivie d'un point et un +% espace blanc. Chaque clause a une en-tête et un corps ; l'en-tête consiste +% en un nom de fonction suivi d'un motif (entre parenthèses), et le corps +% consiste en une séquence d'expressions, qui sont évaluées si le motif de +% l'en-tête est cohérent par rapport à la valeur des paramètres d'appel. +% L'expression est filtrée séquentiellement par les différents motifs, dans +% l'ordre dans lequel ils apparaissent dans la définition de la fonction. +aire({rectangle, Largeur, Hauteur}) -> Largeur * Hauteur; +aire({cercle, R}) -> 3.14159 * R * R. + +% Compilation du code du fichier geometrie.erl. +c(geometrie). % {ok,geometrie} + +% Le nom du module doit être inclus avec le nom de la fonction afin +% d'identifier précisément quelle fonction on souhaite appeler. +geometrie:aire({rectangle, 10, 5}). % 50 +geometrie:area({cercle, 1.4}). % 6.15752 + +% En Erlang, deux fonctions portant le même nom mais ayant des arités +% différentes (c'est à dire ne prenant pas le même nombre de paramètres) +% au sein d'un même module représentent des fonctions complètement +% différentes. +-module(lib_divers). +-export([somme/1]). % exporte la fonction `somme` d'arité 1 + % acceptant un paramètre : une liste d'entiers. +somme(L) -> somme(L, 0). +somme([], N) -> N; +somme([T|Q], N) -> somme(Q, T+N). + +% Les funs sont des fonctions "anonymes" ; elles sont appelées ainsi parce +% qu'elles n'ont pas de noms. Cependant, elles peuvent être affectées à des +% variables. +Doubler = fun(X) -> 2 * X end. % `Doubler` pointe vers une fonction anonyme + % dont le handle est : #Fun +Doubler(2). % 4 + +% Les fonctions peuvent prendre des funs comme paramètres et peuvent renvoyer +% des funs. +Mult = fun(Fois) -> ( fun(X) -> X * Fois end ) end. +Tripler = Mult(3). +Tripler(5). % 15 + +% Les listes en compréhension sont des expressions qui créent des listes sans +% requérir ni funs, ni maps, ni filters. +% La notation `[F(X) || X <- L]` signifie "la liste des `F(X)` où `X` est +% extrait de la liste `L`." +L = [1,2,3,4,5]. +[2 * X || X <- L]. % [2,4,6,8,10] +% Une liste en compréhension peut avoir des générateurs, ainsi que des gardes, +% qui sélectionnent un sous-ensemble des valeurs générées. +NombresPairs = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] + +% La garde est un élément syntaxique qui rend le filtrage par motif encore +% plus puissant. Les gardes permettent de d'effectuer de simple tests et +% comparaisons sur les variables d'un motif. Les gardes peuvent être +% utilisées dans les en-têtes de fonctions, au sein desquelles elles sont +% introduites par le mot-clé `when`, ou encore à n'importe quel endroit où +% une expression est autorisée. +max(X, Y) when X > Y -> X; +max(X, Y) -> Y. + +% Une garde est une série d'expressions gardes, séparées par des virgules (`,`). +% La garde `ExprGarde1, ExprGarde2, ..., ExprGardeN` est vraie si toutes les +% expressions gardes `ExprGarde1`, `ExprGarde2, ..., `ExprGardeN` ont pour +% valeur `true`. +est_chat(A) when is_atom(A), A =:= chat -> true; +est_chat(A) -> false. +est_chien(A) when is_atom(A), A =:= chien -> true; +est_chien(A) -> false. + +% Une séquence de gardes est composée soit d'une seule garde ou bien d'une +% série de gardes, séparées par des points-virgules (`;`). La séquence de +% gardes `G1; G2; ...; Gn` est vraie si au moins l'une des gardes `G1`, `G2`, +% ..., `Gn` a pour valeur `true`. +est_animal(A) when is_atom(A), (A =:= chien) or (A =:= chat) -> true; +est_animal(A) -> false. + +% Attention : les expressions Erlang valides ne peuvent pas toutes être +% utilisées comme expressions gardes ; en particulier, nos fonctions +% `est_chat` et `est_chien` ne sont pas autorisées au sein de la séquence de +% gardes dans la définition de `est_animal`. Pour plus de détails sur les +% expressions autorisées ands les séquences de gardes, voir cette +% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912) +% du manuel Erlang. + +% Les enregistrements permettent d'associer un nom à un certain élément dans +% un tuple. +% Les enregistrements peuvent être définis dans des fichiers sources Erlang +% ou bien dans des fichiers avec une extension `.hrl`, qui sont ensuite inclus +% dans des fichiers sources Erlang. +-record(afaire, { + statut = rappel, % Valeur par défaut + qui = joe, + texte +}). + +% Les définitions d'enregistrements doivent être lues dans l'interpreteur +% pour qu'on puisse définir un enregistrement. On utilise la fonction `rr` +% (abbréviation de *read records* en anglais, ou *lire enregistrements* en +% français) pour ça. +rr("enregistrements.hrl"). % [afaire] + +% Création et mise à jour d'enregistrements : +X = #afaire{}. +% #afaire{statut = rappel, qui = joe, texte = undefined} +X1 = #afaire{statut = urgent, texte = "Corriger erreurs dans livre"}. +% #afaire{statut = urgent, qui = joe, texte = "Corriger erreurs dans livre"} +X2 = X1#afaire{statut = fini}. +% #afaire{statut = fini, qui = joe, texte = "Corriger erreurs dans livre"} + +% Expressions `case`. +% `filter` renvoie une liste de tous les éléments `X` d'une liste `L` pour +% lesquels `P(X)` est vrai. +filter(P, [H|T]) -> + case P(H) of + true -> [H|filter(P, T)]; + false -> filter(P, T) + end; +filter(P, []) -> []. +filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4] + +% Expressions `if`. +max(X, Y) -> + if + X > Y -> X; + X < Y -> Y; + true -> nil + end. + +% Attention : au moins l'une des gardes dans l'expression `if` doit avoir pour +% valeur `true` ; autrement, une exception sera lancée. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 3. Exceptions. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Des exceptions sont lancées par le système quand des erreurs internes +% surviennent, ou de manière explicite dans le programme en appelant +% `throw(Exception)`, `exit(Exception)`, ou `erlang:error(Exception)`. +generer_exception(1) -> a; +generer_exception(2) -> throw(a); +generer_exception(3) -> exit(a); +generer_exception(4) -> {'EXIT', a}; +generer_exception(5) -> erlang:error(a). + +% Erlang dispose de deux méthodes pour capturer une exception. La première +% consiste à inclure l'appel de de la fonction qui lance l'exception dans une +% expression `try...catch`. +catcher(N) -> + try generer_exception(N) of + Val -> {N, normal, Val} + catch + throw:X -> {N, caught, thrown, X}; + exit:X -> {N, caught, exited, X}; + error:X -> {N, caught, error, X} + end. + +% L'autre méthode consiste à inclure l'appel dans une expression `catch`. +% Quand une exception est capturée, elle est convertie en un tuple qui décrit +% l'erreur. +catcher(N) -> catch generer_exception(N). + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 4. Concurrence +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Erlang est basé sur le modèle d'acteur pour la concurrence. Seulement trois +% opérations sont requises pour écrire des programmes concurrents en Erlang : +% la création de processus, l'envoi de messages, et la réception de messages. + +% Pour démarrer un nouveau processus, on utilise la fonction `spawn`, qui +% prend une fonction comme paramètre. + +F = fun() -> 2 + 2 end. % #Fun +spawn(F). % <0.44.0> + +% `spawn` renvoie un pid (*process identifier* en anglais, ou *identifiant de +% processus* en français), qui peut être utilisé pour envoyer des messages au +% processus en question. Pour passer des messages, on utilise l'opérateur `!`. +% Pour que cela soit utile, on doit aussi être en mesure de recevoir des +% messages, ce qui est accompli grâce à une clause `receive` : + +-module(calculerGeometrie). +-compile(export_all). +calculerAire() -> + receive + {rectangle, W, H} -> + W * H; + {cercle, R} -> + 3.14 * R * R; + _ -> + io:format("Seule l'aire d'un rectangle / cercle peut etre calculee.") + end. + +% Compilation du module and création d'un processus qui évalue `calculerAire` +% dans l'interpréteur. +c(calculerGeometrie). +CalculerAire = spawn(calculerGeometrie, calculerAire, []). +CalculerAire ! {cercle, 2}. % 12.56000000000000049738 + +% L'interpréteur est lui-même un processus ; on peut utiliser `self` pour +% obtenir le pid actuel. +self(). % <0.41.0> + +``` + +## Références + +* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) +* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang) +* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/) +* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml) -- cgit v1.2.3 From e191446b333856afff0456349edb71da9634f6aa Mon Sep 17 00:00:00 2001 From: Geoff Liu Date: Thu, 11 Jun 2015 17:35:20 -0600 Subject: Add language marking for R --- fr-fr/r-fr.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'fr-fr') diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown index 3f225a0f..7d30a48d 100644 --- a/fr-fr/r-fr.html.markdown +++ b/fr-fr/r-fr.html.markdown @@ -6,6 +6,7 @@ contributors: translators: - ["Anne-Catherine Dehier", "https://github.com/spellart"] filename: learnr-fr.r +lang: fr-fr --- R est un langage de programmation statistique. Il dispose de nombreuses -- cgit v1.2.3 From 9c6aec3ceb41a207e77a36b3b22b8bcab99fa86d Mon Sep 17 00:00:00 2001 From: Julien Cretel Date: Sun, 14 Jun 2015 13:24:24 +0100 Subject: [erlang/fr] Integrate feedback on PR --- fr-fr/erlang-fr.html.markdown | 32 +++++++++++++++++--------------- 1 file changed, 17 insertions(+), 15 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown index 564e176f..55453c56 100644 --- a/fr-fr/erlang-fr.html.markdown +++ b/fr-fr/erlang-fr.html.markdown @@ -15,19 +15,21 @@ lang: fr-fr %%% Trois signes pour cent sont utilisés pour commenter les modules. -% Trois types de ponctuation sont utilisés en Erlang. +% Trois symboles de ponctuation sont utilisés en Erlang. % Les virgules (`,`) servent à séparer les paramètres dans les appels de % fonctions, les contructeurs, et les motifs. -% Les points (`.`) (suivis par des caractères blancs) servent à séparer -% les fonctions et les expressions dans l'interpréteur. +% Les points (`.`) (suivis par des blancs) servent à séparer les fonctions et +% les expressions dans l'interpréteur. % Les points-virgules (`;`) servent à séparer les clauses. Ces dernières % apparaissent dans différent cas de figure : définitions de fonctions et -% expressions `case`, `if`, `try..catch`, et `receive`. +% expressions `case`, `if`, `try..catch`, `receive`. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -%% 1. Variables et filtrage par motif. +%% 1. Variables et filtrage par motif %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +(L'équivalent anglais de *filtrage par motif* est *pattern patching*.) + Nb = 42. % Chaque nom de variable doit commencer par une lettre majuscule. % Les variables Erlang ne peuvent être affectées qu'une seule fois ; si vous @@ -101,7 +103,7 @@ Nom = "Bonjour". %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Les modules constituent l'unité de base d'un programme Erlang. Toutes les -% fonctions que l'on écrit sont sauvées dans des modules. Les modules sont +% fonctions que l'on écrit sont enregistrées dans des modules. Les modules sont % enregistrés dans des fichiers avec une extension `.erl`. % Les modules doivent être compilés afin d'éxecuter le programme. % Un module compilé a une extension `.beam`. @@ -138,27 +140,27 @@ somme(L) -> somme(L, 0). somme([], N) -> N; somme([T|Q], N) -> somme(Q, T+N). -% Les funs sont des fonctions "anonymes" ; elles sont appelées ainsi parce -% qu'elles n'ont pas de noms. Cependant, elles peuvent être affectées à des +% Les `fun`s sont des fonctions "anonymes" ; elles sont appelées ainsi parce +% qu'elles n'ont pas de nom. Cependant, elles peuvent être affectées à des % variables. Doubler = fun(X) -> 2 * X end. % `Doubler` pointe vers une fonction anonyme % dont le handle est : #Fun Doubler(2). % 4 -% Les fonctions peuvent prendre des funs comme paramètres et peuvent renvoyer -% des funs. +% Les fonctions peuvent prendre des `fun`s comme paramètres et peuvent renvoyer +% des `fun`s. Mult = fun(Fois) -> ( fun(X) -> X * Fois end ) end. Tripler = Mult(3). Tripler(5). % 15 % Les listes en compréhension sont des expressions qui créent des listes sans -% requérir ni funs, ni maps, ni filters. +% requérir ni `fun`s, ni maps, ni filters. % La notation `[F(X) || X <- L]` signifie "la liste des `F(X)` où `X` est % extrait de la liste `L`." L = [1,2,3,4,5]. [2 * X || X <- L]. % [2,4,6,8,10] -% Une liste en compréhension peut avoir des générateurs, ainsi que des gardes, -% qui sélectionnent un sous-ensemble des valeurs générées. +% Une liste en compréhension peut être constituée de générateurs, ainsi que de +% gardes, qui sélectionnent un sous-ensemble des valeurs générées. NombresPairs = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] % La garde est un élément syntaxique qui rend le filtrage par motif encore @@ -186,7 +188,7 @@ est_chien(A) -> false. est_animal(A) when is_atom(A), (A =:= chien) or (A =:= chat) -> true; est_animal(A) -> false. -% Attention : les expressions Erlang valides ne peuvent pas toutes être +% Attention : toutes les expressions Erlang valides ne peuvent pas être % utilisées comme expressions gardes ; en particulier, nos fonctions % `est_chat` et `est_chien` ne sont pas autorisées au sein de la séquence de % gardes dans la définition de `est_animal`. Pour plus de détails sur les @@ -317,7 +319,7 @@ self(). % <0.41.0> ``` -## Références +## Ressources (en anglais) * ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) * ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang) -- cgit v1.2.3