Sélectionner une page

 Il est temps de commencer à utiliser un langage de programmation dans l’ère du temps

 

kotlin langage

J’aimerais vous parler d’un langage de programmation nommé Kotlin et pourquoi vous devriez l’utiliser dans votre prochain projet. Avant je choisissais systématiquement Java quand je démarrais des nouveaux projets, mais ces dernières années (depuis 2018), je me suis retrouvé à développer en Kotlin chaque fois que je pouvais, et pour l’instant, je n’ai toujours pas trouvé une situation dans laquelle Java serait un meilleur choix.

Ce langage a été développé par JetBrains, et le fait qu’ils soient à l’origine de plusieurs IDE (tels que IntelliJ et ReSharper) se ressent quand on code en Kotlin. Ce langage est pragmatique et concis. L’utiliser dans la vie de tout les jours vous donnera une grande satisfaction çar il vous permettra de développer des fonctionnalités très rapidement.

Bien que Kotlin puisse être compilé à la fois en JavaScript et bientôt en code machine , je vais me concentrer sur son environnement principal, la JVM .

Voici donc deux raisons pour lesquelles vous devriez totalement passer à Kotlin (sans ordre particulier):

L’interopérabilité Java (#1)

Kotlin est 100% interopérable avec Java . Vous pouvez totalement continuer à travailler sur vos anciens projets Java avec Kotlin. Tous vos frameworks Java préférés sont toujours disponibles (Spring Boot et tutti quanti)

Une syntaxe intuitive (#2)

Kotlin n’est pas un étrange langage né dans le monde universitaire. Sa syntaxe est familière à tout programmeur issu du domaine de la programmation orientée objet et peut être plus ou moins comprise dès le départ. Il existe bien sûr des différences avec Java, telles que les constructeurs retravaillés ou les déclarations de variables (val var). L’extrait ci-dessous présente la plupart des bases:

class Foo {

    val b: String = “b”      // val signifie non modifiable

    var i: Int = 0           // var signifie modifiable

    fun hello () {

        val str = “Hello”

        print (“$ str World”)

    }

    fun sum ( x: Int, y: Int): Int {

        return x + y

    }

    fun maxOf (a: Float, b: Float) = if (a> b) a else b

}

L’interpolation de chaîne (#3)

C’est comme si une version plus intelligente et plus lisible de la fonction Java String.format() était intégrée au langage:

val x = 4

val y = 7

print (“la somme de $ x et $ y est $ {x + y}”) // la somme de 4 et 7 est 11


L’inférence de type (#4)

Kotlin déduira les types partout où ce sera nécessaire lisibilité:

val a = “abc” // type inféré -> String

val b = 4 // type inféré -> Int

val c: Double = 0,7 // type déclaré explicitement

val d: List<String> = ArrayList() // type déclaré explicitement

Smart Cast (#5)

Le compilateur Kotlin suit votre logique, et si possible, caste intelligemment les objets. Cela signifie qu’aucune vérification instanceof n’est effectuée, suivie de cast  explicites :

if (obj is String) {

    print(obj.toUpperCase()) // // obj est maintenant reconnu entant que chaîne de caractères

}

Des egalités intuitives (#6)

Vous pouvez arrêter d’appeler equals() explicitement, car l’ opérateur == vérifie maintenant l’égalité structurelle:

val john1 = Person (“John”)

val john2 = Person (“John”)

john1 == john2  // true (égalité des structures)

john1 === john2  // false (égalité de la référence)

Arguments par défaut (#7)

Pas besoin de définir plusieurs méthodes similaires avec des arguments différents:

fun construire(ville: String, largeur: Int = 800, hauteur: Int = 600, profondeur: Int = 600 ) {

    Maison(ville, largeur, hauteur, profondeur)

}

Arguments nommés (#8)

Combinés aux arguments par défaut, les arguments nommés éliminent le besoin de générateurs :

construire( “Paris”, 400, 300, 200)               // equivalent

construire(ville = “Paris”, largeur = 400, hauteur = 300, profondeur = 200)  // equivalent

construire(largeur = 400, profondeur = 200, hauteur = 300, ville = “Paris”)  // equivalent

L’expression “when” (#9)

Le switch est remplacé par le – beaucoup plus lisible et flexible –  « when » :

when (x) {

    1 -> print (“x égal 1”)

    2 -> print (“x égal 2”)

    3, 4 -> print (“x égal 3 ou 4 ») in 5..10 -> print (“x égal 5, 6, 7, 8, 9 ou 10”) else -> print (“x est en dehors de l’intervalle”) }

Cela fonctionne à la fois comme une expression ou une déclaration et avec ou sans un argument:

val res: Boolean = when {

    obj == null -> false

    obj is String -> true

    else -> throw IllegalStateException ()

}

Les propriétés Kotlin (#10)

Des accesseurs peuvent être ajoutés parmi les champs publics, ce qui signifie qu’on peut arrêter d’écrire des tonnes et des tonnes de code avec des getters et des setters insensés.

class Image {

    var largeur: Int = 800

    var hauteur: Int = 600

    val pixels: Int

        get() = largeur * hauteur

}

Les Data class (#11)

La data class est un POJO avec toutes les fonctions toString()equals()hashCode()et copy(). Contrairement à Java , il ne prendra pas 100 lignes de code:

data class user( val nom: String,

                  var email: String,

                  var age: int)

val john = user( “John”, “john@gmail.com”, 112)

La surcharge d’opérateur (#12)

Un ensemble prédéfini d’opérateurs peut être surchargé pour améliorer la lisibilité:

data class Vec ( val x: Float, val y: Float) {

    operator fun plus (v: Vec) = Vec (x + vx, y + vy)

}

val v = Vec (2f, 3f) + Vec (4f, 1f )

Destructuration des objets (#13)

Certains objets peuvent être déstructurés, ce qui est par exemple utile pour itérer des map:

for ((key, value) in map) {

    print(“Key: $key”)

    print(“Value: $value”)

}


La notion de range (#14)

Par souci de lisibilité, les ranges peuvent s’écrire de différentes manières, très intuitives :

for (i in 1..100) { … }

for (i in 0 until 100) { … }

for (i in 2..10 step 2) { … }

for (i in 10 downTo 1) { … }

if (x in 1..10) { … }

Les extensions (#15)

Vous rappelez-vous la première fois que vous avez dû trier un objet List en Java ? Vous ne trouviez pas la bonne fonction sort() à utiliser, et votre prof (ou Google) vous a dit d’utiliser Collections.sort(). Et plus tard, lorsque vous avez dû mettre en majuscule une String, vous avez fini par écrire votre propre fonction car vous ne connaissiez pas Utils.capitalize().

Si seulement il y avait moyen d’ajouter de nouvelles fonctions aux classes de base… Comme ça votre IDE pourrait vous aider à trouver la bonne fonction dans la complétion de code. Ça tombe bien, en Kotlin vous permet de faire exactement ça :

fun String.enleverLesEspaces(): String {

    return this.replace(‘ ‘, ”)

}

val result = str.enleverLesEspaces()

La librairie standard de Kotlin étend les fonctionnalités des types de base de Java, ce qui était particulièrement nécessaire pour String:

str.removeSuffix(“.txt”)

str.capitalize()

str.substringAfterLast(“/”)

str.replaceAfter(“:”, “classified”)

Le null check (#16)

Java est ce que nous devrions appeler un langage typé de manière quasi statique. Avec lui, une variable de type String n’est pas garanti d’être un objet de type String – il pourrait très bien être null. Même si on est habitués à ça, la sécurité de la vérification de type statique est compromise, de sorte que les développeurs Java vivent dans la peur constante des NPE .

Kotlin résout ce problème faisant la distinction entre les types non nuls et types nullables .
Les types ne sont pas nuls par défaut, mais peuvent être rendus nuls en ajoutant le  
? :

var a: String = “abc”

a = null                 // erreur de compilation


var
b: String? = “xyz”

b = null                 // pas de problème

Kotlin vous oblige à vous protéger des NPE lorsque vous accédez à un type nullable:

val x = b.length // erreur de compilation: b peut être nul

Et même si cela peut sembler fastidieux, c’est vraiment un jeu d’enfant grâce à quelques-unes de ses fonctionnalités. Nous avons toujours les smart cast, qui convertissent les types nullable en non-null chaque fois que possible:

if (b == null ) return

val x = b.length // pas de problème

On pourrait également utiliser l’appel sécurisé  ?., qui retournera la valeur null au lieu de lancer un NPE:

val x = b?.length // le type de x est un Int nullable

Les appels sécurisés peuvent être chaînés pour éviter les boucles if-not-null imbriquées que nous écrivons parfois dans d’autres langages. Si nous voulons une valeur par défaut autre que null nous pouvons utiliser l’opérateur elvis  ?: :

val name = vaisseau?.capitaine?.nom?:”inconnu”

Si rien de tout cela ne convient à votre situtation et que vous avez absolument besoin d’un NPE, vous avez juste à le demander explicitement:

val x = b?.length?: throw NullPointerException () // équivaut au code ci-dessous

val x = b !!.length // équivaut au code ci-dessus

Des lambdas ameliorées (#17)

Kotlin permet une utilisation des lambdas EXCELLENTE, parfaitement équilibrée et lisible grâce à de petits « tricks » très sympas.
Tout d’abord, la syntaxe est simple comme bonjour :

val sum = {x: Int, y: Int -> x + y} // type: (Int, Int) -> Int

val res = sum(4,7) // res == 11

Et voici les tricks:

  • Les parenthèses de méthode peuvent être déplacées ou omises si la lambda est le dernier ou le seul argument d’une méthode.
  • Si nous choisissons de ne pas déclarer l’argument d’une lambda « mono argument », il sera implicitement déclaré sous le nom it.

Tout cela combiné rend les trois lignes suivantes équivalentes:

numbers.filter ({x -> x.isPrime()})

numbers.filter {x -> x.isPrime()}

numbers.filter {it.isPrime()}

Et cela nous permet d’écrire un code fonctionnel concis. Regardez moi ce code de toute beauté :

personnes

    .filter {it.age> = 18}

    .sortedBy {it.nom}

    .map {it.email}

    .forEach {print (it)}

Les lambdas de Kotlin, associées à des fonctions « extension », le rend idéal pour la création DSL . Vous pouvez  regarder Anko par exemple pour un DSL orienté développement Android:

verticalLayout {

    padding = dip (30)

    editText {

        hint = “Nom”

        textSize = 24f

    }

    editText {

        hint = “Mot de passe”

        textSize = 24f

    }

    bouton (“Connexion”) {

        textSize = 26f

    }

}

Support IDE pour Koltin (#18)

Vous avez pas mal de possibilités si vous avez l’ intention de commencer à développer en Kotlin, mais je vous recommande fortement d’utiliser IntelliJ qui embarque lui même Kotlin. Vous bénéficierez alors d’un avantage certain puisque ce sont les mêmes personnes qui conçoivent le langage et l’IDE.

Juste pour vous donner un exemple mineur mais plutôt sympa, voilà ce qui est apparu lorsque j’ai essayé de copier-coller du code Java de Stack Overflow vers un de mes fichiers Kotlin dans IntelliJ:

conversion java vers kotlin avec intellij

IntelliJ vous proposera une conversion Java vers Kotlin si vous collez du code Java dans un fichier

Credits : magnus.chatt on Medium

 

Le guide pour devenir Freelance

Doubler votre salaire, voyager et... être votre propre boss ?

Le guide pour devenir Freelance

Doubler votre salaire, voyager et... être votre propre boss ?

Les 11 avantages que ne connaissent pas les développeurs en CDI

RAPIDEMENT ET SANS PAPERASSE

Merci de votre confiance