Kotlin Academy · Leçon

Quand utiliser chaque approche

Compromis à prendre en compte

Quand utiliser chaque approche est une leçon Kotlin 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Deux outils, deux rôles

Les fonctions infixes concernent la lisibilité ; les fonctions tailrec concernent une récursion sûre et efficace. Elles répondent à des problèmes sans rapport.

infix fun Int.add(o: Int) = this + o

tailrec fun sum(n: Int, acc: Int = 0): Int =
    if (n == 0) acc else sum(n - 1, acc + n)

fun main() {
    println(2 add 3)
    println(sum(10))
}

Choisir l'infixe pour les API fluides

Utilisez l'infixe lorsqu'un appel se lit mieux sans points ni parenthèses, en particulier dans les DSL et la construction de paires.

fun main() {
    val pair = "id" to 100
    println(pair)
}

Choisir tailrec pour les récursions profondes

Utilisez tailrec lorsqu'un algorithme récursif pourrait atteindre une profondeur suffisante pour provoquer un dépassement de la pile.

tailrec fun count(n: Int, acc: Int = 0): Int =
    if (n == 0) acc else count(n - 1, acc + 1)

fun main() {
    println(count(50000))
}

Compromis de l'infixe

L'infixe supprime la ponctuation, ce qui peut réduire la clarté pour les lecteurs qui ne le connaissent pas et compliquer la priorité. Utilisez-le uniquement lorsqu'il apporte clairement un avantage.

infix fun Int.scaledBy(f: Int) = this * f

fun main() {
    println(5 scaledBy 3)
}

Compromis de tailrec

Rendre un code récursif terminal nécessite souvent un accumulateur, ce qui peut sembler moins direct qu'une boucle ordinaire. Évaluez le caractère expressif par rapport à la simplicité.

tailrec fun product(n: Int, acc: Long = 1): Long =
    if (n <= 1) acc else product(n - 1, acc * n)

fun main() {
    println(product(6))
}

Quand une boucle est plus simple

Si une simple boucle for ou while est plus claire que la récursion terminale, préférez-la. La récursion est un outil, pas une obligation.

fun sumLoop(n: Int): Int {
    var total = 0
    for (i in 1..n) total += i
    return total
}

fun main() {
    println(sumLoop(10))
}

Quand un appel nommé est plus clair

Si un nom infixe ne représente pas clairement une relation binaire, un appel de méthode normal exprime mieux l'intention.

data class Temp(val c: Int) {
    fun isWarmerThan(o: Temp) = c > o.c
}

fun main() {
    println(Temp(30).isWarmerThan(Temp(20)))
}

Combiner les deux

Ces deux fonctionnalités sont indépendantes ; un même programme peut utiliser l'infixe pour des appels lisibles et tailrec pour une récursion sûre.

infix fun Int.upto(n: Int) = (this..n).toList()

tailrec fun last(list: List<Int>): Int =
    if (list.size == 1) list[0] else last(list.drop(1))

fun main() {
    println(last(1 upto 5))
}

Liste de contrôle de la lisibilité

Demandez-vous : l'infixe rend-il l'appel plus clair pour une personne débutante ? tailrec évite-t-il un véritable risque de dépassement de la pile ? Si ce n'est pas le cas, préférez les fonctions et les boucles ordinaires.

fun main() {
    val r = (1..5).sum()
    println(r)
}

Remarque sur les performances

tailrec offre des performances comparables à celles d'une boucle, avec un espace de pile constant. L'infixe n'a aucun coût à l'exécution : il est purement syntaxique.

tailrec fun pow(base: Int, exp: Int, acc: Long = 1): Long =
    if (exp == 0) acc else pow(base, exp - 1, acc * base)

fun main() {
    println(pow(2, 10))
}

Résumé de la décision

Infixe : appels fluides à un argument, de style binaire. Tailrec : récursion qui doit évoluer sans risque. Aucune des deux fonctionnalités n'est un choix par défaut ; toutes deux doivent être utilisées délibérément.

infix fun String.joinWith(o: String) = "$this-$o"

fun main() {
    println("a" joinWith "b")
}

Vérification rapide

Vérifiez votre compréhension des situations où chacune de ces fonctionnalités doit être utilisée.

Récapitulatif

Vous avez appris quand utiliser chacune de ces fonctionnalités :

Utilisez infix pour les appels fluides et lisibles de style binaire et pour les DSL.
Utilisez tailrec pour les récursions qui doivent évoluer sans provoquer de dépassement de la pile.
Préférez les boucles ordinaires ou les fonctions nommées lorsqu'elles sont plus claires.
Ces deux fonctionnalités sont indépendantes et peuvent être combinées.

infix fun Int.by(o: Int) = this * o
tailrec fun dec(n: Int): Int = if (n == 0) 0 else dec(n - 1)

fun main() {
    println(3 by 4)
    println(dec(1000))
}

Questions Fréquemment Posées

La leçon « Quand utiliser chaque approche » est-elle gratuite ?

Oui — le texte complet de « Quand utiliser chaque approche » 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Quand utiliser chaque approche » ?

Compromis à prendre en compte Tu pratiques Kotlin 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 Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin 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 « Quand utiliser chaque approche » ?

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 Kotlin Academy ?

Oui. Chaque leçon Kotlin 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

← Retour à Kotlin Academy