--- 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/)