Les “scopes functions” en Kotlin

Les scope functions en Kotlin sont des fonctions de niveau supérieur qui permettent de simplifier le code en utilisant des fonctions de type “extension“.
Ces fonctions permettent de définir la visibilité des variables et des fonctions dans un programme. Il en existe plusieurs types, chacun ayant des règles différentes pour l’accès aux variables et aux fonctions.
Les principaux types de scope functions sont : la portée globale, la portée de classe, la portée de fonction.

Les scope functions les plus couramment utilisés sont : apply, with, let, also et run. Ces fonctions sont particulièrement utiles pour les opérations de manipulation de données, telles que la configuration d’objets, la modification de propriétés et l’exécution de tâches complexes.
En utilisant ces fonctions, nous pouvons écrire du code plus clair et plus concis qui est plus facile à lire et à maintenir.

Fonction apply

L’opérateur “apply” en Kotlin est utilisé pour appeler une fonction sur un objet, et retourner cet objet.
Il est souvent utilisé pour configurer les propriétés d’un objet, car il permet d’écrire du code plus clair et plus concis, en évitant la répétition de références à l’objet en cours de configuration.

Voici un exemple simple d’utilisation de l’opérateur “apply” pour configurer les propriétés d’un objet :

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

val person = Person("John", 25).apply {
    name = "Jane"
    age = 30
}

println(person)  // output : "Person(name=Jane, age=30)"

Dans cet exemple, nous avons créé une classe de données “Person” qui a deux propriétés: “name” et “age“. Nous avons ensuite créé une instance de cette classe en spécifiant les valeurs initiales pour “name” et “age“.
Enfin, nous avons utilisé l’opérateur “apply” pour appeler une fonction qui modifie les propriétés de “name” et “age” pour les mettre à jour avec de nouvelles valeurs.

L’opérateur “apply” est très utile pour configurer les propriétés d’un objet, car il permet de regrouper toutes les modifications de propriétés dans une seule fonction, ce qui rend le code plus lisible et plus facile à maintenir. Il est également utile pour éviter les erreurs de code en vérifiant les objets pour la nullité avant de les utiliser et en fournissant un contexte clair pour les opérations de manipulation de données.

Fonction with

L’opérateur “with” en Kotlin est utilisé pour appeler des méthodes sur un objet sans avoir besoin de référencer cet objet à chaque fois.
Il est similaire à l’opérateur “apply” mais il permet d’appeler des méthodes sur un objet plutôt que de configurer des propriétés d’un objet.

Voici un exemple simple d’utilisation de l’opérateur “with” pour ajouter des éléments à une liste :

val list = mutableListOf(1, 2, 3)

with(list) {
    add(4)
    add(5)
}

println(list)  // Affiche "[1, 2, 3, 4, 5]"

Dans cet exemple, nous avons créé une liste mutable de nombres entiers. Ensuite nous avons utilisé l’opérateur “with” pour appeler les fonctions add sur la liste sans avoir à référencer la liste à chaque fois.

L’opérateur “with” est très utile pour appeler des méthodes sur un objet, car il permet de regrouper toutes les méthodes dans une seule fonction.

Voici un exemple plus complexe d’utilisation de l’opérateur “with” pour appeler des méthodes sur un objet :

class MyClass {
    fun method1() { println("method1 called") }
    fun method2() { println("method2 called") }
}

val myObject = MyClass()
with(myObject) {
    method1()
    method2()
}

Dans cet exemple, nous avons créé une classe “MyClass” qui a deux méthodes: “method1” et “method2“. Nous avons ensuite créé une instance de cette classe et utilisé l’opérateur “with” pour appeler les méthodes “method1” et “method2” sur cette instance sans avoir à référencer l’objet à chaque fois.

Il est important de noter que l’opérateur “with” ne modifie pas l’objet sur lequel il est appelé.
Il retourne simplement le résultat de la dernière expression évaluée dans la fonction passée en paramètre.
Donc si vous avez besoin de retourner l’objet modifié, il est préférable d’utiliser l’opérateur “apply” à la place.

En résumé, l’opérateur “with” en Kotlin est un outil pratique qui permet d’appeler des méthodes sur un objet sans avoir à référencer cet objet à chaque fois.
Il permet de regrouper toutes les méthodes dans une seule fonction. Il est particulièrement utile pour les opérations de manipulation de données, telles que l’ajout ou la suppression d’éléments dans une liste ou un tableau.

Fonction let

L’opérateur “let” en Kotlin est utilisé pour exécuter une fonction sur un objet s’il n’est pas null. Il retourne également l’objet modifié ou null.
Il permet de vérifier si un objet est null avant de l’utiliser et d’éviter ainsi les erreurs de NullPointerException.

Voici un exemple simple d’utilisation de l’opérateur “let” pour récupérer la longueur d’une chaîne de caractères :

val str: String? = "Hello"
val length = str?.let {
    it.length
}

println(length)  // Affiche "5"

Dans cet exemple, nous avons déclaré une variable “str” qui peut être null. Nous avons ensuite utilisé l’opérateur “let” pour vérifier si “str” est null et si ce n’est pas le cas, nous avons utilisé la fonction “length” pour récupérer la longueur de la chaîne.
En utilisant cette fonction, nous pouvons éviter les erreurs de NullPointerException qui peuvent survenir lorsque nous tentons d’utiliser une variable null.

Fonction also

L’opérateur “also” en Kotlin est similaire à “let“, mais il retourne l’objet d’origine plutôt que l’objet modifié.
Il est souvent utilisé pour effectuer des opérations de journalisation ou de débogage. Il permet de faire des opérations sur un objet sans avoir à changer l’objet lui-même.

Voici un exemple simple d’utilisation de l’opérateur “also” pour afficher une liste avant de la filtrer :

val list = listOf(1, 2, 3)

val result = list.also {
    println(it)  // Affiche "[1, 2, 3]"
}.filter {
    it > 1
}

println(result)  // Affiche "[2, 3]"

Dans cet exemple, nous avons créé une liste de nombres entiers. Nous avons ensuite utilisé l’opérateur “also” pour afficher la liste avant de la filtrer. La fonction n’a pas modifié la liste d’origine, elle a simplement affiché la liste avant de la filtrer.

Voici un exemple plus complexe d’utilisation de l’opérateur “also” pour effectuer des opérations supplémentaires sur un objet :

class MyClass {
    var prop1: String = ""
    var prop2: Int = 0
}

val myObject = MyClass().apply {
    prop1 = "hello"
    prop2 = 42
}.also {
    println("prop1 = ${it.prop1}, prop2 = ${it.prop2}")
}

Dans cet exemple, nous avons créé une classe “MyClass” qui a deux propriétés: “prop1” et “prop2“. Nous avons ensuite créé une instance de cette classe en utilisant l’opérateur “apply” pour configurer les propriétés “prop1” et “prop2” avec des valeurs spécifiques.
Ensuite, nous avons utilisé l’opérateur “also” pour afficher les valeurs de ces propriétés sans les modifier.

En résumé, l’opérateur “also” en Kotlin est un outil pratique qui permet d’effectuer des opérations supplémentaires sur un objet sans avoir à changer l’objet lui-même. Il est souvent utilisé pour les opérations de journalisation ou de débogage, ou pour exécuter des opérations supplémentaires après une opération sur un objet.

Fonction run

L’opérateur “run” en Kotlin est un autre opérateur de niveau supérieur qui permet d’exécuter une fonction sur un objet. Il est similaire à “let” et “also” mais il permet également de définir une variable locale pour accéder à l’objet dans la fonction. Il retourne également le résultat de la dernière expression évaluée dans la fonction passée en paramètre.

Voici un exemple simple d’utilisation de l’opérateur “run” pour récupérer la longueur d’une chaîne de caractères :

val str: String? = "Hello"

val length = str?.run {
    length
}

println(length)  // Affiche "5"

Dans cet exemple, nous avons déclaré une variable “str” qui peut être null. Nous avons ensuite utilisé l’opérateur “run” pour vérifier si “str” est null et si ce n’est pas le cas, nous avons utilisé la fonction “length” pour récupérer la longueur de notre “string”.

L’opérateur “run” est également utile pour effectuer des opérations de transformation sur un objet. Par exemple, vous pouvez utiliser “run” pour convertir un objet en une autre forme ou pour exécuter des calculs sur un objet.

Voici un exemple plus complexe d’utilisation de l’opérateur “run” pour effectuer des opérations de transformation sur un objet :

class MyClass {
    var prop1: String = ""
    var prop2: Int = 0
}

val myObject = MyClass().apply {
    prop1 = "hello"
    prop2 = 42
}.run {
    val newProp1 = prop1.toUpperCase()
    val newProp2 = prop2 * 2
    prop1 = newProp1
    prop2 = newProp2
    this
}

println(myObject.prop1) // Affiche "HELLO"
println(myObject.prop2) // Affiche "84"

Dans cet exemple, nous avons créé une classe “MyClass” qui a deux propriétés: “prop1” et “prop2“. Nous avons ensuite créé une instance de cette classe en utilisant l’opérateur “apply” pour configurer les propriétés “prop1” et “prop2” avec des valeurs spécifiques. Ensuite, nous avons utilisé l’opérateur “run” pour effectuer des opérations de transformation sur ces propriétés en les convertissant en majuscules et en les multipliant par 2, puis nous avons défini les propriétés de l’objet avec ces nouvelles valeurs.

En résumé, l’opérateur “run” en Kotlin est un outil pratique qui permet d’exécuter une fonction sur un objet. Il permet également de définir une variable locale pour accéder à l’objet dans la fonction. Il est souvent utilisé pour les opérations de transformation ou de calcul sur un objet.