0Pricing
Android Academy · Leçon

Fonctions d’extension et fonctions d’ordre supérieur

Ajoutez des comportements à des types existants avec des fonctions d’extension et utilisez des fonctions d’ordre supérieur et des fonctions de portée (let, apply, also, run, with) pour écrire du code Kotlin expressif.

Fonctions d’extension et fonctions d’ordre supérieur est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Fonctions d'extension

Une fonction d'extension vous permet d'ajouter de nouvelles fonctions à des classes existantes sans les modifier ni utiliser l'héritage. Vous pouvez étendre String, Int, vos propres classes ou même la classe View d'Android.

Syntaxe : fun TypeName.functionName() { }

Écrire des fonctions d'extension

Dans une fonction d'extension, this fait référence à l'objet récepteur :

fun String.isPalindrome(): Boolean {
    val cleaned = this.lowercase().filter { it.isLetter() }
    return cleaned == cleaned.reversed()
}

fun Int.isEven() = this % 2 == 0

fun main() {
    println("racecar".isPalindrome())  // true
    println("hello".isPalindrome())    // false
    println(4.isEven())                // true
    println(7.isEven())                // false
}

Fonctions d'extension sur les vues Android

Modèle Android courant : masquez ou affichez les vues avec une extension au lieu de répéter du code répétitif :

import android.view.View

fun View.show() { visibility = View.VISIBLE }
fun View.hide() { visibility = View.GONE }
fun View.invisible() { visibility = View.INVISIBLE }

// Usage in Activity:
// binding.progressBar.show()
// binding.recyclerView.hide()

Fonctions d'ordre supérieur

Une fonction d'ordre supérieur prend une fonction en paramètre ou en renvoie une. Vous les avez déjà utilisées : filter, map et forEach sont toutes des fonctions d'ordre supérieur.

Syntaxe du type fonction : (ParamType) -> ReturnType

Transmettre des fonctions en paramètres

Définissez une fonction qui accepte une autre fonction :

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum  = operate(3, 4) { x, y -> x + y }
    val prod = operate(3, 4) { x, y -> x * y }
    val max  = operate(3, 4, ::maxOf)   // method reference

    println(sum)   // 7
    println(prod)  // 12
    println(max)   // 4
}

Renvoyer des fonctions

Les fonctions peuvent également renvoyer d'autres fonctions, ce qui est utile pour créer des comportements configurables :

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { number -> number * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)

    println(double(5))   // 10
    println(triple(5))   // 15

    val numbers = listOf(1, 2, 3, 4)
    println(numbers.map(double))  // [2, 4, 6, 8]
}

Fonctions de portée : let

Les fonctions de portée de Kotlin exécutent un bloc sur un objet et renvoient un résultat. let est utilisé pour les vérifications de nullité et les transformations :

fun main() {
    val name: String? = "Alice"

    // Only runs if name is not null
    name?.let {
        println("Name length: ${it.length}")
        println("Upper: ${it.uppercase()}")
    }

    // Transform a value
    val length = name?.let { it.length } ?: 0
    println("Length: $length")  // 5
}

Fonctions de portée : apply et also

apply configure un objet et renvoie l'objet. also effectue un effet secondaire et renvoie l'objet :

data class Config(var host: String = "", var port: Int = 0, var timeout: Int = 0)

fun main() {
    // apply: configure an object (this = receiver)
    val config = Config().apply {
        host = "api.example.com"
        port = 443
        timeout = 30
    }
    println(config)  // Config(host=api.example.com, port=443, timeout=30)

    // also: log or debug (it = receiver)
    val result = listOf(1, 2, 3)
        .also { println("Original: $it") }
        .map { it * 2 }
        .also { println("Doubled: $it") }
}

Fonctions de portée : run et with

run exécute un bloc sur un objet et renvoie le résultat du bloc. with est similaire, mais ce n'est pas une extension :

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Bob", 30)

    // run: compute something using the object
    val greeting = user.run {
        if (age >= 18) "Hello, $name!" else "Hi, $name!"
    }
    println(greeting)  // Hello, Bob!

    // with: group operations on an object
    val info = with(user) {
        "Name: $name, Age: $age"
    }
    println(info)  // Name: Bob, Age: 30
}

Aide-mémoire des fonctions de portée

Référence rapide pour choisir la fonction de portée appropriée :

  • let — bloc sûr vis-à-vis de la nullité, transforme l'objet, renvoie le résultat de la lambda
  • apply — configure l'objet, renvoie l'objet (this)
  • also — effets secondaires (journalisation), renvoie l'objet (it)
  • run — calcule un résultat à partir de l'objet, renvoie le résultat de la lambda
  • with — regroupe les appels sur un objet, ce n'est pas une extension

Fonctions inline et reified

Marquez une fonction d'ordre supérieur avec inline pour éviter l'allocation d'un objet lambda lors de l'exécution. reified vous permet d'utiliser le type générique T lors de l'exécution (normalement effacé) :

inline fun <reified T> Any.isOfType(): Boolean = this is T

fun main() {
    println("hello".isOfType<String>())   // true
    println(42.isOfType<String>())         // false
    println(3.14.isOfType<Double>())       // true
}

Vérification rapide

Quelle fonction de portée convient le mieux pour configurer un objet nouvellement créé et renvoyer ce même objet ?

Récapitulatif&nbsp;: extensions et fonctions d'ordre supérieur

La boîte à outils fonctionnelle de Kotlin est désormais à votre disposition :

  • Fonctions d'extension — ajoutent un comportement à n'importe quel type sans héritage
  • Fonctions d'ordre supérieur — transmettent et renvoient des fonctions pour des API flexibles
  • Fonctions de portée : let (vérification de nullité), apply (configuration), also (effet secondaire), run/with (calcul)
  • inline + reified — lambdas sans coût supplémentaire avec informations de type à l'exécution

Ensuite : créez des applications à plusieurs écrans avec des fragments.

Questions Fréquemment Posées

La leçon « Fonctions d’extension et fonctions d’ordre supérieur » est-elle gratuite ?

Oui — le texte complet de « Fonctions d’extension et fonctions d’ordre supérieur » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions d’extension et fonctions d’ordre supérieur » ?

Ajoutez des comportements à des types existants avec des fonctions d’extension et utilisez des fonctions d’ordre supérieur et des fonctions de portée (let, apply, also, run, with) pour écrire du code… Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Fonctions d’extension et fonctions d’ordre supérieur » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Sécurité vis-à-vis des valeurs nulles
  2. Classes et objets
  3. Classes de données et classes scellées
  4. Fonctions d’extension et fonctions d’ordre supérieur
← Retour à Android Academy