From c36fc10ef56e945b59c30a067e3437244e3e9c4e Mon Sep 17 00:00:00 2001 From: Boris Verkhovskiy Date: Sat, 18 May 2024 10:48:18 -0600 Subject: [kotlin/fr] fix filename --- fr-fr/kotlin-fr.html.markdown | 457 ++++++++++++++++++++++++++++++++++++++++++ fr-fr/kotlin.html-fr.markdown | 457 ------------------------------------------ 2 files changed, 457 insertions(+), 457 deletions(-) create mode 100644 fr-fr/kotlin-fr.html.markdown delete mode 100644 fr-fr/kotlin.html-fr.markdown (limited to 'fr-fr') diff --git a/fr-fr/kotlin-fr.html.markdown b/fr-fr/kotlin-fr.html.markdown new file mode 100644 index 00000000..10f67fc4 --- /dev/null +++ b/fr-fr/kotlin-fr.html.markdown @@ -0,0 +1,457 @@ +--- +language: kotlin +filename: LearnKotlin-fr.kt +lang: fr-fr +contributors: + - ["S Webber", "https://github.com/s-webber"] +translators: + - ["Eric Ampire", "https://github.com/eric-ampire"] +--- + +Kotlin est un langage de programmation à typage statique pour la JVM, Android et le +navigateur. Il est 100% interopérable avec Java. +[Pour en savoir plus, cliquez ici](https://kotlinlang.org/) + +```kotlin +// Les commentaires d'une seule ligne commencent par // +/* +Les commentaires de plusieurs lignes ressemblent à ceci. +*/ + +// Le mot-clé "package" fonctionne de la même manière qu'en Java. + package com.learnxinyminutes.kotlin + +/* +Le point d'entrée d'un programme Kotlin est une fonction appelée "main". +La fonction reçoit un tableau contenant tous les arguments de la ligne de commande. +Depuis Kotlin 1.3, la fonction "main" peut également être définie sans +tout paramètre. +*/ +fun main(args: Array) { + /* + La déclaration des valeurs se fait en utilisant soit "var" soit "val". + Les déclarations "val" ne peuvent pas être réaffectées, alors que les déclarations "vars" le peuvent. + */ + val fooVal = 10 // nous ne pouvons pas plus tard réaffecter fooVal à autre chose + var fooVar = 10 + fooVar = 20 // fooVar peut être réaffecté + + /* + Dans la plupart des cas, Kotlin peut déterminer quel est le type de variable, + afin de ne pas avoir à le préciser explicitement à chaque fois. + Nous pouvons déclarer explicitement le type d'une variable de cette manière : + */ + val foo: Int = 7 + + /* + Les chaînes de caractères peuvent être représentées de la même manière qu'en Java. + L'échappement se fait avec une barre oblique inversée. + */ + val fooString = "Ma chaine est là !" + val barString = "Imprimer sur une nouvelle ligne ? \nPas de problème !" + val bazString = "Vous voulez ajouter une tabulation ? \tPas de problème !" + println(fooString) + println(barString) + println(bazString) + + /* + Une chaîne brute est délimitée par une triple citation ("""). + Les chaînes de caractères brutes peuvent contenir des nouvelles lignes et tout autre caractère. + */ + val fooRawString = """ +fun helloWorld(val name : String) { + println("Bonjour, le monde !") +} +""" + println(fooRawString) + + /* + Les chaînes de caractères peuvent contenir des expressions modèles. + Une expression modèle commence par le signe du dollar ($). + */ + val fooTemplateString = "$fooString as ${fooString.length} caractères" + println(fooTemplateString) // => Ma chaine est là ! comporte 18 caractères + + /* + Pour qu'une variable soit considérée comme nulle, elle doit être explicitement spécifiée comme nulable. + Une variable peut être spécifiée comme nulle en ajoutant un ? à son type. + On peut accéder à une variable nulable en utilisant l'opérateur ? + Nous pouvons utiliser l'opérateur ?: pour spécifier une valeur alternative à utiliser + si une variable est nulle. + */ + var fooNullable: String? = "abc" + println(fooNullable?.length) // => 3 + println(fooNullable?.length ?: -1) // => 3 + fooNullable = null + println(fooNullable?.length) // => null + println(fooNullable?.length ?: -1) // => -1 + + /* + Les fonctions peuvent être déclarées en utilisant le mot-clé "fun". + Les arguments des fonctions sont spécifiés entre parenthèses après le nom de la fonction. + Les arguments de fonction peuvent éventuellement avoir une valeur par défaut. + Le type de retour de la fonction, si nécessaire, est spécifié après les arguments. + */ + fun hello(name: String = "world"): String { + return "Bonjour, $name!" + } + println(hello("foo")) // => Bonjour, foo! + println(hello(name = "bar")) // => Bonjour, bar! + println(hello()) // => Bonjour, le monde! + + /* + Un paramètre de fonction peut être marqué avec le mot-clé "vararg + pour permettre de passer un nombre variable d'arguments à la fonction. + */ + fun varargExample(vararg names: Int) { + println("L'argument comporte ${names.size} éléments.") + } + varargExample() // => L'argument a 0 éléments + varargExample(1) // => L'argument a 1 éléments + varargExample(1, 2, 3) // => L'argument comporte 3 éléments + + /* + Lorsqu'une fonction est constituée d'une seule expression, les parenthèses bouclées peuvent + être omis. Le corps est spécifié après le symbole =. + */ + fun odd(x: Int): Boolean = x % 2 == 1 + println(odd(6)) // => false + println(odd(7)) // => true + + // Si le type de retour peut être déduit, alors nous n'avons pas besoin de le préciser. + fun even(x: Int) = x % 2 == 0 + println(even(6)) // => true + println(even(7)) // => false + + // Les fonctions peuvent prendre des fonctions d'arguments et des fonctions de retour. + fun not(f: (Int) -> Boolean): (Int) -> Boolean { + return {n -> !f.invoke(n)} + } + // Les fonctions nommées peuvent être spécifiées comme arguments en utilisant l'opérateur :: . + val notOdd = not(::odd) + val notEven = not(::even) + // Les expressions lambda peuvent être spécifiées en tant qu'arguments. + val notZero = not {n -> n == 0} + /* + Si un lambda n'a qu'un seul paramètre + alors sa déclaration peut être omise (ainsi que le ->). + Le nom du paramètre unique sera "it". + */ + val notPositive = not {it > 0} + for (i in 0..4) { + println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}") + } + + // Le mot-clé "class" est utilisé pour déclarer les classes. + class ExampleClass(val x: Int) { + fun memberFunction(y: Int): Int { + return x + y + } + + infix fun infixMemberFunction(y: Int): Int { + return x * y + } + } + /* + Pour créer une nouvelle instance, nous appelons le constructeur. + Notez que Kotlin n'a pas de mot-clé "new" . + */ + val fooExampleClass = ExampleClass(7) + // Les fonctions des membres peuvent être appelées en utilisant la notation par points. + println(fooExampleClass.memberFunction(4)) // => 11 + /* + Si une fonction a été marquée avec le mot-clé "infix", elle peut être + appelé en utilisant la notation infixe. + */ + println(fooExampleClass infixMemberFunction 4) // => 28 + + /* + Les classes de données sont une façon concise de créer des classes qui ne contiennent que des données. + Les méthodes "hashCode"/"equals" et "toString" sont générées automatiquement. + */ + data class DataClassExample (val x: Int, val y: Int, val z: Int) + val fooData = DataClassExample(1, 2, 4) + println(fooData) // => DataClassExample(x=1, y=2, z=4) + + // Les classes de données ont une methode "copy". + val fooCopy = fooData.copy(y = 100) + println(fooCopy) // => DataClassExample(x=1, y=100, z=4) + + // Les objets peuvent être déstructurés en plusieurs variables. + val (a, b, c) = fooCopy + println("$a $b $c") // => 1 100 4 + + // La déstructuration en boucle "for" + for ((a, b, c) in listOf(fooData)) { + println("$a $b $c") // => 1 100 4 + } + + val mapData = mapOf("a" to 1, "b" to 2) + // Map.Entry est également déstructurable + for ((key, value) in mapData) { + println("$key -> $value") + } + + // La fonction "with" est similaire à la déclaration "with" de JavaScript. + data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) + val fooMutableData = MutableDataClassExample(7, 4, 9) + with (fooMutableData) { + x -= 2 + y += 2 + z-- + } + println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8) + + /* + Nous pouvons créer une liste en utilisant la fonction "listOf". + La liste sera immuable - les éléments ne peuvent être ajoutés ou supprimés. + */ + val fooList = listOf("a", "b", "c") + println(fooList.size) // => 3 + println(fooList.first()) // => a + println(fooList.last()) // => c + // Les éléments d'une liste sont accessibles par leur index. + println(fooList[1]) // => b + + // Une liste mutable peut être créée en utilisant la fonction "mutableListOf". + val fooMutableList = mutableListOf("a", "b", "c") + fooMutableList.add("d") + println(fooMutableList.last()) // => d + println(fooMutableList.size) // => 4 + + // Nous pouvons créer un ensemble en utilisant la fonction "setOf". + val fooSet = setOf("a", "b", "c") + println(fooSet.contains("a")) // => true + println(fooSet.contains("z")) // => false + + // Nous pouvons créer un map en utilisant la fonction "mapOf". + val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9) + // Map values can be accessed by their key. + println(fooMap["a"]) // => 8 + + /* + Les séquences représentent des collections évaluées paresseusement. + Nous pouvons créer une séquence en utilisant la fonction "generateSequence". + */ + val fooSequence = generateSequence(1, { it + 1 }) + val x = fooSequence.take(10).toList() + println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + + // Un exemple d'utilisation d'une séquence pour générer des nombres de Fibonacci : + fun fibonacciSequence(): Sequence { + var a = 0L + var b = 1L + + fun next(): Long { + val result = a + b + a = b + b = result + return a + } + + return generateSequence(::next) + } + val y = fibonacciSequence().take(10).toList() + println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] + + // Kotlin offre des fonctions d'ordre supérieur pour le travail avec les collections. + val z = (1..9).map {it * 3} + .filter {it < 20} + .groupBy {it % 2 == 0} + .mapKeys {if (it.key) "even" else "odd"} + println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]} + + // Une boucle "for" peut être utilisée avec tout ce qui fournit un itérateur. + for (c in "hello") { + println(c) + } + + // Les boucles "while" fonctionnent de la même manière que les autres langues. + var ctr = 0 + while (ctr < 5) { + println(ctr) + ctr++ + } + do { + println(ctr) + ctr++ + } while (ctr < 10) + + /* + "if" peut être utilisé comme une expression qui renvoie une valeur. + Pour cette raison, l'opérateur ternaire ?: n'est pas nécessaire dans Kotlin. + */ + val num = 5 + val message = if (num % 2 == 0) "even" else "odd" + println("$num is $message") // => 5 is odd + + // Le terme "when" peut être utilisé comme alternative aux chaînes "if-else if". + val i = 10 + when { + i < 7 -> println("first block") + fooString.startsWith("hello") -> println("second block") + else -> println("else block") + } + + // "when" peut être utilisé avec un argument. + when (i) { + 0, 21 -> println("0 or 21") + in 1..20 -> println("in the range 1 to 20") + else -> println("none of the above") + } + + // "when" peut être utilisé comme une fonction qui renvoie une valeur. + var result = when (i) { + 0, 21 -> "0 or 21" + in 1..20 -> "in the range 1 to 20" + else -> "none of the above" + } + println(result) + + /* + Nous pouvons vérifier si un objet est d'un type particulier en utilisant l'opérateur "is". + Si un objet passe avec succès une vérification de type, il peut être utilisé comme ce type sans + en le diffusant explicitement. + */ + fun smartCastExample(x: Any) : Boolean { + if (x is Boolean) { + // x est automatiquement converti en booléen + return x + } else if (x is Int) { + // x est automatiquement converti en Int + return x > 0 + } else if (x is String) { + // x est automatiquement converti en String + return x.isNotEmpty() + } else { + return false + } + } + println(smartCastExample("Bonjour, le monde !")) // => true + println(smartCastExample("")) // => false + println(smartCastExample(5)) // => true + println(smartCastExample(0)) // => false + println(smartCastExample(true)) // => true + + // Le Smartcast fonctionne également avec le bloc when + fun smartCastWhenExample(x: Any) = when (x) { + is Boolean -> x + is Int -> x > 0 + is String -> x.isNotEmpty() + else -> false + } + + /* + Les extensions sont un moyen d'ajouter de nouvelles fonctionnalités à une classe. + C'est similaire aux méthodes d'extension C#. + */ + fun String.remove(c: Char): String { + return this.filter {it != c} + } + println("Hello, world!".remove('l')) // => Heo, word! +} + +// Les classes Enum sont similaires aux types Java enum. +enum class EnumExample { + A, B, C // Les constantes Enum sont séparées par des virgules. +} +fun printEnum() = println(EnumExample.A) // => A + +// Puisque chaque enum est une instance de la classe enum, ils peuvent être initialisés comme : +enum class EnumExample(val value: Int) { + A(value = 1), + B(value = 2), + C(value = 3) +} +fun printProperty() = println(EnumExample.A.value) // => 1 + +// Chaque énum a des propriétés pour obtenir son nom et son ordinal (position) dans la déclaration de classe de l'énum : +fun printName() = println(EnumExample.A.name) // => A +fun printPosition() = println(EnumExample.A.ordinal) // => 0 + +/* +Le mot-clé "objet" peut être utilisé pour créer des objets singleton. +On ne peut pas l'instancier mais on peut se référer à son instance unique par son nom. +Cela est similaire aux objets singleton de Scala. +*/ +object ObjectExample { + fun hello(): String { + return "Bonjour" + } + + override fun toString(): String { + return "Bonjour, c'est moi, ${ObjectExample::class.simpleName}" + } +} + + +fun useSingletonObject() { + println(ObjectExample.hello()) // => hello + // Dans Kotlin, "Any" est la racine de la hiérarchie des classes, tout comme "Object" l'est dans Java + val someRef: Any = ObjectExample + println(someRef) // => Bonjour, c'est moi, ObjectExample +} + + +/* L'opérateur d'assertion non nulle ( !!) convertit toute valeur en un type non nul et + lance une exception si la valeur est nulle. +*/ +var b: String? = "abc" +val l = b!!.length + +data class Counter(var value: Int) { + // surcharge Counter += Int + operator fun plusAssign(increment: Int) { + this.value += increment + } + + // surcharge Counter++ et ++Counter + operator fun inc() = Counter(value + 1) + + // surcharge Counter + Counter + operator fun plus(other: Counter) = Counter(this.value + other.value) + + // surcharge Counter * Counter + operator fun times(other: Counter) = Counter(this.value * other.value) + + // surcharge Counter * Int + operator fun times(value: Int) = Counter(this.value * value) + + // surcharge Counter dans Counter + operator fun contains(other: Counter) = other.value == this.value + + // surcharge Counter[Int] = Int + operator fun set(index: Int, value: Int) { + this.value = index + value + } + + // surcharge Counter instance invocation + operator fun invoke() = println("The value of the counter is $value") + +} +/* Vous pouvez également surcharger les opérateurs par des méthodes d'extension */ +// surcharge -Counter +operator fun Counter.unaryMinus() = Counter(-this.value) + +fun operatorOverloadingDemo() { + var counter1 = Counter(0) + var counter2 = Counter(5) + counter1 += 7 + println(counter1) // => Counter(value=7) + println(counter1 + counter2) // => Counter(value=12) + println(counter1 * counter2) // => Counter(value=35) + println(counter2 * 2) // => Counter(value=10) + println(counter1 in Counter(5)) // => false + println(counter1 in Counter(7)) // => true + counter1[26] = 10 + println(counter1) // => Counter(value=36) + counter1() // => La valeur est 36 + println(-counter2) // => Counter(value=-5) +} +``` + +### Lectures complémentaires + +* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/) +* [Try Kotlin in your browser](https://play.kotlinlang.org/) +* [A list of Kotlin resources](http://kotlin.link/) diff --git a/fr-fr/kotlin.html-fr.markdown b/fr-fr/kotlin.html-fr.markdown deleted file mode 100644 index 10f67fc4..00000000 --- a/fr-fr/kotlin.html-fr.markdown +++ /dev/null @@ -1,457 +0,0 @@ ---- -language: kotlin -filename: LearnKotlin-fr.kt -lang: fr-fr -contributors: - - ["S Webber", "https://github.com/s-webber"] -translators: - - ["Eric Ampire", "https://github.com/eric-ampire"] ---- - -Kotlin est un langage de programmation à typage statique pour la JVM, Android et le -navigateur. Il est 100% interopérable avec Java. -[Pour en savoir plus, cliquez ici](https://kotlinlang.org/) - -```kotlin -// Les commentaires d'une seule ligne commencent par // -/* -Les commentaires de plusieurs lignes ressemblent à ceci. -*/ - -// Le mot-clé "package" fonctionne de la même manière qu'en Java. - package com.learnxinyminutes.kotlin - -/* -Le point d'entrée d'un programme Kotlin est une fonction appelée "main". -La fonction reçoit un tableau contenant tous les arguments de la ligne de commande. -Depuis Kotlin 1.3, la fonction "main" peut également être définie sans -tout paramètre. -*/ -fun main(args: Array) { - /* - La déclaration des valeurs se fait en utilisant soit "var" soit "val". - Les déclarations "val" ne peuvent pas être réaffectées, alors que les déclarations "vars" le peuvent. - */ - val fooVal = 10 // nous ne pouvons pas plus tard réaffecter fooVal à autre chose - var fooVar = 10 - fooVar = 20 // fooVar peut être réaffecté - - /* - Dans la plupart des cas, Kotlin peut déterminer quel est le type de variable, - afin de ne pas avoir à le préciser explicitement à chaque fois. - Nous pouvons déclarer explicitement le type d'une variable de cette manière : - */ - val foo: Int = 7 - - /* - Les chaînes de caractères peuvent être représentées de la même manière qu'en Java. - L'échappement se fait avec une barre oblique inversée. - */ - val fooString = "Ma chaine est là !" - val barString = "Imprimer sur une nouvelle ligne ? \nPas de problème !" - val bazString = "Vous voulez ajouter une tabulation ? \tPas de problème !" - println(fooString) - println(barString) - println(bazString) - - /* - Une chaîne brute est délimitée par une triple citation ("""). - Les chaînes de caractères brutes peuvent contenir des nouvelles lignes et tout autre caractère. - */ - val fooRawString = """ -fun helloWorld(val name : String) { - println("Bonjour, le monde !") -} -""" - println(fooRawString) - - /* - Les chaînes de caractères peuvent contenir des expressions modèles. - Une expression modèle commence par le signe du dollar ($). - */ - val fooTemplateString = "$fooString as ${fooString.length} caractères" - println(fooTemplateString) // => Ma chaine est là ! comporte 18 caractères - - /* - Pour qu'une variable soit considérée comme nulle, elle doit être explicitement spécifiée comme nulable. - Une variable peut être spécifiée comme nulle en ajoutant un ? à son type. - On peut accéder à une variable nulable en utilisant l'opérateur ? - Nous pouvons utiliser l'opérateur ?: pour spécifier une valeur alternative à utiliser - si une variable est nulle. - */ - var fooNullable: String? = "abc" - println(fooNullable?.length) // => 3 - println(fooNullable?.length ?: -1) // => 3 - fooNullable = null - println(fooNullable?.length) // => null - println(fooNullable?.length ?: -1) // => -1 - - /* - Les fonctions peuvent être déclarées en utilisant le mot-clé "fun". - Les arguments des fonctions sont spécifiés entre parenthèses après le nom de la fonction. - Les arguments de fonction peuvent éventuellement avoir une valeur par défaut. - Le type de retour de la fonction, si nécessaire, est spécifié après les arguments. - */ - fun hello(name: String = "world"): String { - return "Bonjour, $name!" - } - println(hello("foo")) // => Bonjour, foo! - println(hello(name = "bar")) // => Bonjour, bar! - println(hello()) // => Bonjour, le monde! - - /* - Un paramètre de fonction peut être marqué avec le mot-clé "vararg - pour permettre de passer un nombre variable d'arguments à la fonction. - */ - fun varargExample(vararg names: Int) { - println("L'argument comporte ${names.size} éléments.") - } - varargExample() // => L'argument a 0 éléments - varargExample(1) // => L'argument a 1 éléments - varargExample(1, 2, 3) // => L'argument comporte 3 éléments - - /* - Lorsqu'une fonction est constituée d'une seule expression, les parenthèses bouclées peuvent - être omis. Le corps est spécifié après le symbole =. - */ - fun odd(x: Int): Boolean = x % 2 == 1 - println(odd(6)) // => false - println(odd(7)) // => true - - // Si le type de retour peut être déduit, alors nous n'avons pas besoin de le préciser. - fun even(x: Int) = x % 2 == 0 - println(even(6)) // => true - println(even(7)) // => false - - // Les fonctions peuvent prendre des fonctions d'arguments et des fonctions de retour. - fun not(f: (Int) -> Boolean): (Int) -> Boolean { - return {n -> !f.invoke(n)} - } - // Les fonctions nommées peuvent être spécifiées comme arguments en utilisant l'opérateur :: . - val notOdd = not(::odd) - val notEven = not(::even) - // Les expressions lambda peuvent être spécifiées en tant qu'arguments. - val notZero = not {n -> n == 0} - /* - Si un lambda n'a qu'un seul paramètre - alors sa déclaration peut être omise (ainsi que le ->). - Le nom du paramètre unique sera "it". - */ - val notPositive = not {it > 0} - for (i in 0..4) { - println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}") - } - - // Le mot-clé "class" est utilisé pour déclarer les classes. - class ExampleClass(val x: Int) { - fun memberFunction(y: Int): Int { - return x + y - } - - infix fun infixMemberFunction(y: Int): Int { - return x * y - } - } - /* - Pour créer une nouvelle instance, nous appelons le constructeur. - Notez que Kotlin n'a pas de mot-clé "new" . - */ - val fooExampleClass = ExampleClass(7) - // Les fonctions des membres peuvent être appelées en utilisant la notation par points. - println(fooExampleClass.memberFunction(4)) // => 11 - /* - Si une fonction a été marquée avec le mot-clé "infix", elle peut être - appelé en utilisant la notation infixe. - */ - println(fooExampleClass infixMemberFunction 4) // => 28 - - /* - Les classes de données sont une façon concise de créer des classes qui ne contiennent que des données. - Les méthodes "hashCode"/"equals" et "toString" sont générées automatiquement. - */ - data class DataClassExample (val x: Int, val y: Int, val z: Int) - val fooData = DataClassExample(1, 2, 4) - println(fooData) // => DataClassExample(x=1, y=2, z=4) - - // Les classes de données ont une methode "copy". - val fooCopy = fooData.copy(y = 100) - println(fooCopy) // => DataClassExample(x=1, y=100, z=4) - - // Les objets peuvent être déstructurés en plusieurs variables. - val (a, b, c) = fooCopy - println("$a $b $c") // => 1 100 4 - - // La déstructuration en boucle "for" - for ((a, b, c) in listOf(fooData)) { - println("$a $b $c") // => 1 100 4 - } - - val mapData = mapOf("a" to 1, "b" to 2) - // Map.Entry est également déstructurable - for ((key, value) in mapData) { - println("$key -> $value") - } - - // La fonction "with" est similaire à la déclaration "with" de JavaScript. - data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) - val fooMutableData = MutableDataClassExample(7, 4, 9) - with (fooMutableData) { - x -= 2 - y += 2 - z-- - } - println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8) - - /* - Nous pouvons créer une liste en utilisant la fonction "listOf". - La liste sera immuable - les éléments ne peuvent être ajoutés ou supprimés. - */ - val fooList = listOf("a", "b", "c") - println(fooList.size) // => 3 - println(fooList.first()) // => a - println(fooList.last()) // => c - // Les éléments d'une liste sont accessibles par leur index. - println(fooList[1]) // => b - - // Une liste mutable peut être créée en utilisant la fonction "mutableListOf". - val fooMutableList = mutableListOf("a", "b", "c") - fooMutableList.add("d") - println(fooMutableList.last()) // => d - println(fooMutableList.size) // => 4 - - // Nous pouvons créer un ensemble en utilisant la fonction "setOf". - val fooSet = setOf("a", "b", "c") - println(fooSet.contains("a")) // => true - println(fooSet.contains("z")) // => false - - // Nous pouvons créer un map en utilisant la fonction "mapOf". - val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9) - // Map values can be accessed by their key. - println(fooMap["a"]) // => 8 - - /* - Les séquences représentent des collections évaluées paresseusement. - Nous pouvons créer une séquence en utilisant la fonction "generateSequence". - */ - val fooSequence = generateSequence(1, { it + 1 }) - val x = fooSequence.take(10).toList() - println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] - - // Un exemple d'utilisation d'une séquence pour générer des nombres de Fibonacci : - fun fibonacciSequence(): Sequence { - var a = 0L - var b = 1L - - fun next(): Long { - val result = a + b - a = b - b = result - return a - } - - return generateSequence(::next) - } - val y = fibonacciSequence().take(10).toList() - println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] - - // Kotlin offre des fonctions d'ordre supérieur pour le travail avec les collections. - val z = (1..9).map {it * 3} - .filter {it < 20} - .groupBy {it % 2 == 0} - .mapKeys {if (it.key) "even" else "odd"} - println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]} - - // Une boucle "for" peut être utilisée avec tout ce qui fournit un itérateur. - for (c in "hello") { - println(c) - } - - // Les boucles "while" fonctionnent de la même manière que les autres langues. - var ctr = 0 - while (ctr < 5) { - println(ctr) - ctr++ - } - do { - println(ctr) - ctr++ - } while (ctr < 10) - - /* - "if" peut être utilisé comme une expression qui renvoie une valeur. - Pour cette raison, l'opérateur ternaire ?: n'est pas nécessaire dans Kotlin. - */ - val num = 5 - val message = if (num % 2 == 0) "even" else "odd" - println("$num is $message") // => 5 is odd - - // Le terme "when" peut être utilisé comme alternative aux chaînes "if-else if". - val i = 10 - when { - i < 7 -> println("first block") - fooString.startsWith("hello") -> println("second block") - else -> println("else block") - } - - // "when" peut être utilisé avec un argument. - when (i) { - 0, 21 -> println("0 or 21") - in 1..20 -> println("in the range 1 to 20") - else -> println("none of the above") - } - - // "when" peut être utilisé comme une fonction qui renvoie une valeur. - var result = when (i) { - 0, 21 -> "0 or 21" - in 1..20 -> "in the range 1 to 20" - else -> "none of the above" - } - println(result) - - /* - Nous pouvons vérifier si un objet est d'un type particulier en utilisant l'opérateur "is". - Si un objet passe avec succès une vérification de type, il peut être utilisé comme ce type sans - en le diffusant explicitement. - */ - fun smartCastExample(x: Any) : Boolean { - if (x is Boolean) { - // x est automatiquement converti en booléen - return x - } else if (x is Int) { - // x est automatiquement converti en Int - return x > 0 - } else if (x is String) { - // x est automatiquement converti en String - return x.isNotEmpty() - } else { - return false - } - } - println(smartCastExample("Bonjour, le monde !")) // => true - println(smartCastExample("")) // => false - println(smartCastExample(5)) // => true - println(smartCastExample(0)) // => false - println(smartCastExample(true)) // => true - - // Le Smartcast fonctionne également avec le bloc when - fun smartCastWhenExample(x: Any) = when (x) { - is Boolean -> x - is Int -> x > 0 - is String -> x.isNotEmpty() - else -> false - } - - /* - Les extensions sont un moyen d'ajouter de nouvelles fonctionnalités à une classe. - C'est similaire aux méthodes d'extension C#. - */ - fun String.remove(c: Char): String { - return this.filter {it != c} - } - println("Hello, world!".remove('l')) // => Heo, word! -} - -// Les classes Enum sont similaires aux types Java enum. -enum class EnumExample { - A, B, C // Les constantes Enum sont séparées par des virgules. -} -fun printEnum() = println(EnumExample.A) // => A - -// Puisque chaque enum est une instance de la classe enum, ils peuvent être initialisés comme : -enum class EnumExample(val value: Int) { - A(value = 1), - B(value = 2), - C(value = 3) -} -fun printProperty() = println(EnumExample.A.value) // => 1 - -// Chaque énum a des propriétés pour obtenir son nom et son ordinal (position) dans la déclaration de classe de l'énum : -fun printName() = println(EnumExample.A.name) // => A -fun printPosition() = println(EnumExample.A.ordinal) // => 0 - -/* -Le mot-clé "objet" peut être utilisé pour créer des objets singleton. -On ne peut pas l'instancier mais on peut se référer à son instance unique par son nom. -Cela est similaire aux objets singleton de Scala. -*/ -object ObjectExample { - fun hello(): String { - return "Bonjour" - } - - override fun toString(): String { - return "Bonjour, c'est moi, ${ObjectExample::class.simpleName}" - } -} - - -fun useSingletonObject() { - println(ObjectExample.hello()) // => hello - // Dans Kotlin, "Any" est la racine de la hiérarchie des classes, tout comme "Object" l'est dans Java - val someRef: Any = ObjectExample - println(someRef) // => Bonjour, c'est moi, ObjectExample -} - - -/* L'opérateur d'assertion non nulle ( !!) convertit toute valeur en un type non nul et - lance une exception si la valeur est nulle. -*/ -var b: String? = "abc" -val l = b!!.length - -data class Counter(var value: Int) { - // surcharge Counter += Int - operator fun plusAssign(increment: Int) { - this.value += increment - } - - // surcharge Counter++ et ++Counter - operator fun inc() = Counter(value + 1) - - // surcharge Counter + Counter - operator fun plus(other: Counter) = Counter(this.value + other.value) - - // surcharge Counter * Counter - operator fun times(other: Counter) = Counter(this.value * other.value) - - // surcharge Counter * Int - operator fun times(value: Int) = Counter(this.value * value) - - // surcharge Counter dans Counter - operator fun contains(other: Counter) = other.value == this.value - - // surcharge Counter[Int] = Int - operator fun set(index: Int, value: Int) { - this.value = index + value - } - - // surcharge Counter instance invocation - operator fun invoke() = println("The value of the counter is $value") - -} -/* Vous pouvez également surcharger les opérateurs par des méthodes d'extension */ -// surcharge -Counter -operator fun Counter.unaryMinus() = Counter(-this.value) - -fun operatorOverloadingDemo() { - var counter1 = Counter(0) - var counter2 = Counter(5) - counter1 += 7 - println(counter1) // => Counter(value=7) - println(counter1 + counter2) // => Counter(value=12) - println(counter1 * counter2) // => Counter(value=35) - println(counter2 * 2) // => Counter(value=10) - println(counter1 in Counter(5)) // => false - println(counter1 in Counter(7)) // => true - counter1[26] = 10 - println(counter1) // => Counter(value=36) - counter1() // => La valeur est 36 - println(-counter2) // => Counter(value=-5) -} -``` - -### Lectures complémentaires - -* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/) -* [Try Kotlin in your browser](https://play.kotlinlang.org/) -* [A list of Kotlin resources](http://kotlin.link/) -- cgit v1.2.3