Pourquoi utiliser le langage Kotlin pour vos futurs developpements

C’est la grande annonce du Google I/O 2017 , le langage Kotlin est maintenant officiellement supporté pour le développement d’applications Android. Ce choix est en parti plébiscité par la communauté des développeurs Android mais c’est aussi un choix stratégique de Google . En effet à cause de la série de procès sur l’utilisation du langage Java pour Android, Google cherche un moyen de contournement et il est possible que ce merveilleux langage soit une bonne initiative.

A l’origine , se langage a été développé par JetBrains . C’est à cette société que nous devons notamment IntelliJ, l’environnement qui sert de base dans sa version community à Android Studio.  De plus  il  était déjà utilisé par certains développeurs de grandes entreprises depuis plusieurs années, malgré l’absence de support officiel. Il peut être compilé en Javascript ou en code machine , il est compatible avec la JVM .

Je vais essayer au travers de cet article de vous expliquer les raisons pour lesquels  Kotlin est un langage de premier choix pour le développement d’application :

1# Interopérabilité avec Java 

Kotlin est 100% interopérable avec Java. Il est possible de mixer dans vos projets du code Java et de l’utiliser avec Kotlin. Tout vos frameworks  Java favoris  sont encore disponibles. Votre temps d’apprentissage de Kotlin en sera d’autant plus rapide.

2# Une syntaxe familière et concise

Kotlin n’est pas un langue née dans le monde universitaire. Sa syntaxe est familière à n’importe quel programmeur Java qui connait les base de la programmation orientée Objet. il peut être appris rapidement . Il y a bien sûre quelques différences avec Java comme les constructeurs retravaillés et la décalaration des variables.

( val et var ). Voici un classique “Hello World” pour vous expliquer les bases :

class Foo {                   // déclaration d une classe
                              
    val b: String = "b"       // val signifie non modifiable 
    var i: Int = 0            // var signifie modifiable
  
    fun hello() {             // déclaration d’une fonction avec fun
        val str = "Hello"
        print("$str World")   // on retrouve la fonction print
    }

    fun sum(x: Int, y: Int): Int {
        return x + y
    }

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

}

3# String Interpolation

Il est comme une version plus intelligente et plus lisible de  la fonction Java :String.format() Cette fonction est directement intégrée dans le langage :

val x = 4
val y = 7
print("sum of $x and $y is ${x + y}")  // la somme de 4 et 7 est 11

4# Inférence de Type

val a = "abc"                         // ce type correspond a une String
val b = 4                             // ce type correspond à un  Int

val c: Double = 0.7                   // ce type est déclaré de façon  explicite avec :
val d: List = ArrayList()     // ce type est déclaré de façon  explicite

5# Smart Casts

Le compilateur Kotlin suit à la trace votre logique et auto-cast les types , ce qui signifie plus de :instanceof Voici un cast explicit :

if (obj is String) {
    print(obj.toUpperCase())     // obj est maintenant connu comme une String
}

6# Equals intuitif

Vous pouvez arrêter d’utiliser : equals() Explicitement car l’opérateur ==, vérifie maintenant l’égalité de structure :

val tom1 = Person("Tom")
val tom2 = Person("Tom")
tom1 == tom2    // true  (égalité de structure)
tom1 === tom2   // false (égalité de référence)

7# Arguments par défaut

Aucun besoin de définir plusieurs méthodes semblables avec une multitude d’arguments :

fun build(title: String, width: Int = 800, height: Int = 600) {
    Frame(title, width, height)
}

8# Named Arguments

Combiné avec des arguments(disputes) par défaut,  des arguments nommés éliminent le besoin de constructeurs:

build("PacMan", 400, 300)                           // equivalent
build(title = "PacMan", width = 400, height = 300)  // equivalent
build(width = 400, height = 300, title = "PacMan")  // equivalent

9# Utilisation de l’expression When

Le switch case est remplacé par une expression plus lisible :

when (x) {
    1 -> print("x is 1")
    2 -> print("x is 2")
    3, 4 -> print("x is 3 or 4")
    in 5..10 -> print("x is 5, 6, 7, 8, 9, or 10")
    else -> print("x is out of range")
}

il fonctionne à la fois comme une expression ou un état et avec ou sans arguments :

val res: Boolean = when {
    obj == null -> false
    obj is String -> true
    else -> throw IllegalStateException()
}

10 # Les Proprietes

Des accesseurs (get et set ) peuvent être ajouté aux attributs publiques ce qui signifie moins de code redondant ( boiler plates ) .

class Frame {
    var width: Int = 800
    var height: Int = 600

    val pixels: Int
        get() = width * height
}

11# Les Data Classes

C’est un POJO complet avec  toString() , equals() , hashCode() et copy(), et contrairement à Java il n’aura pas 100 lignes de code :

data class Person(val name: String,
                  var email: String,
                  var age: Int)

val john = Person("John", "john@gmail.com", 112)

12# L’Operateur Overloading

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 + v.x, y + v.y)
}

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

13# Destructuring Declarations

Quelques objets peuvent être destructurés, qui est par exemple utile pour itérer sur des maps:

for ((key, value) in map) {
    print("Key: $key")
    print("Value: $value")
}

14# Les  Ranges

Pour encore plus de lisibilité:

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) { ... }

15# Extension Functions

Rappelez-vous la première fois que vous avez dû trier une List en Java ? Vous ne pouviez pas trouvé  une fonction sort()  vous avez chercher un tutorial sur Google pour apprendre : Collections.sort()Et plus tard quand vous avez dû capitaliser une String, Vous avez fini par écrire votre propre fonction d’aide parce que vous n’avez pas connu :StringUtils.capitalize()Si seulement il y avait une façon d’ajouter de nouvelles fonctions à de vieilles classes; de cette façon votre IDE pourrait vous aider à trouver la fonction  dans la continuité de votre code. Dans Kotlin vous pouvez faire exactement cela:

fun String.format(): String {
    return this.replace(' ', '_')
}

val formatted = str.format()

La bibliothèque standard prolonge la fonctionnalité des types originaux de Java, qui a été particulièrement utile pour les String:

str.removeSuffix(".txt")
str.capitalize()
str.substringAfterLast("/")
str.replaceAfter(":", "classified")

16# Null Safety

Java est ce que nous devrions appeler un langage presque statiquement typé. Dans ce sens, on ne peut garantir qu’une variable de type  String réfère bien à une Strin – elle pourrait aussi se référer à :

null

Bien que nous y soyons obligé, il nie la sécurité de vérification des types statiques et en conséquence les développeurs Java   doivent vivre dans la crainte constante des NullPointerExceptions.

 

Kotlin résout ce problème en faisant une distinction entre des types non-nuls et les types possiblement null (nullable).  Les types sont non-nuls par défaut et peuvent être faits nullable en ajoutant :

?Comme par exemple :

var a: String = "abc"
a = null                // compile error

var b: String? = "xyz"
b = null                // no problemo

Kotlin vous force de prémunir contre les NullPointerExceptions quand vous avez accès à un type  nullable :

val x = b.length        // compile error: b might be null

Et tandis que ceci pourrait sembler encombrant, c’est vraiment une bonne d’avoir quelques-unes de ses caractéristiques. Nous avons toujours des coups intelligents(chic), qui cast  des types de nullable en non-nul dans la mesure du possible :

 

if (b == null) return
val x = b.length        // no problem

Nous pourrions aussi utiliser un appel sûr : ?., Qui évalue au nul au lieu de jeter un NullPointerExceptions :

val x = b?.length       // type of x is nullable Int

Des appels sûrs peuvent être enchaînés ensemble pour éviter une redondance de tests : “si pas le nul” nous écrivons parfois dans d’autres langues et si nous voulons une valeur par défaut autre que le nul nous pouvons utiliser l’opérateur elvis :

 

?:Comme par exemple :

val name = ship?.captain?.name ?: "unknown"

Si aucune de ces amélioration ne vous satisfait et vous avez absolument besoin d’un NullPointerException , vous devrez le demander explicitement:

val x = b?.length ?: throw NullPointerException()  // same as below
val x = b!!.length                                 // same as above

17# De meilleurs Lambdas

Est-ce que ceci est un bon système de lambda ? Parfaitement équilibré entre lisibilité et fait d’être laconique, merci à quelques choix de conception intelligents. La syntaxe est vraiment  d’une grande simplicité :

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

Et viennent ici les parties intelligentes:

  1. 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.
  2. Si nous choisissons ne pas déclarer l’argument d’un lambda d’argument seul il sera implicitement déclaré sous le nom “it”.

Voici trois lignes équivalentes :

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

Et ceci nous permet d’écrire du code fonctionnel concis ? – Regardez juste cette beauté:

persons
    .filter { it.age >= 18 }
    .sortedBy { it.name }
    .map { it.email }
    .forEach { print(it) }

Le système de lambda de Kotlin combiné avec des fonctions d’extension en fait un outil idéal pour la création de DSL. Regarder rapidement Anko pour un exemple d’un DSL qui a pour but d’améliorer le développement sur Android:

verticalLayout {
    padding = dip(30)
    editText {
        hint = “Name”
        textSize = 24f
    }
    editText {
        hint = “Password”
        textSize = 24f
    }
    button(“Login”) {
        textSize = 26f
    }
}

18# IDE Support

Vous avez un certain nombre d’options si vous avez l’intention de commencer avec Kotlin, mais je recommande fortement d’utiliser IntelliJ  qui vient groupé avec Kotlin préinstallé. Ce sont les mêmes personne qui ont conçues le langage et l’IDE.

 

Juste pour vous donner un exemple mineur mais intelligent, cette fenêtre  a surgi quand j’ai d’abord essayé de copier un certain code Java

de Stack Overflow:

 

 

IntelliJ vous proposera de convertir le code Java directement en Kotlin.

 

Et c’est tout pour le moment. Merci pour votre  lecture! Ceci est mon premier poste sur Kotlin. Je vais essayer de rédiger régulièrement des articles sur ce merveilleux langage qui mérite vraiment le détour.

0 responses on "Pourquoi utiliser le langage Kotlin pour vos futurs developpements"

Leave a Message

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

© WayofCode. All rights reserved.

Setup Menus in Admin Panel