Scala for Backend Engineering & Functional Programming · Leçon

Méthodes d’extension

Ajoutez des méthodes aux types

Méthodes d’extension est une leçon Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Ajouter des méthodes aux types existants

Les méthodes d'extension permettent d'ajouter de nouvelles méthodes à un type que vous ne possédez pas, comme Int ou String, sans modifier son code source. Scala 3 propose pour cela une syntaxe claire.

object Main:
  extension (x: Int)
    def squared: Int = x * x
  def main(args: Array[String]): Unit =
    println(5.squared)

La syntaxe des extensions

Écrivez extension (param: Type), suivi d'une ou plusieurs définitions de méthodes. Dans chaque méthode, le paramètre désigne la valeur réceptrice.

object Main:
  extension (s: String)
    def shout: String = s.toUpperCase + "!"
  def main(args: Array[String]): Unit =
    println("hello".shout)

Plusieurs méthodes dans un même bloc

Une seule clause extension peut définir plusieurs méthodes qui opèrent toutes sur le même type récepteur.

object Main:
  extension (x: Int)
    def squared: Int = x * x
    def cubed: Int = x * x * x
    def isEven: Boolean = x % 2 == 0
  def main(args: Array[String]): Unit =
    println(4.squared)
    println(3.cubed)
    println(6.isEven)

Méthodes d'extension avec paramètres

Les méthodes d'extension peuvent accepter leurs propres paramètres en plus du récepteur.

object Main:
  extension (x: Int)
    def times(s: String): String = s * x
  def main(args: Array[String]): Unit =
    println(3.times("ab"))

Méthodes d'extension génériques

Les extensions peuvent être génériques et ajouter des méthodes à toute une famille de types, comme List[A].

object Main:
  extension [A](xs: List[A])
    def second: A = xs(1)
  def main(args: Array[String]): Unit =
    println(List(10, 20, 30).second)
    println(List("a", "b").second)

Pourquoi les extensions sont préférables aux conversions implicites

Les méthodes d'extension atteignent plus sûrement l'objectif ancien du modèle « pimp-my-library » : elles ajoutent uniquement les méthodes nommées, sans risque de conversions de types silencieuses ailleurs.

object Main:
  extension (d: Double)
    def percentOf(total: Double): Double = d / total * 100
  def main(args: Array[String]): Unit =
    println(25.0.percentOf(200.0))

Extensions et classes de types

Les méthodes d'extension s'associent parfaitement aux classes de types : définissez le comportement via une instance given et exposez-le sous forme de méthode avec using.

trait Show[A]:
  def show(a: A): String

object Main:
  given Show[Int] with
    def show(a: Int): String = s"<$a>"

  extension [A](a: A)
    def display(using s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit =
    println(42.display)

Définir des opérateurs

Comme les opérateurs ne sont que des méthodes, les extensions peuvent également ajouter des opérateurs symboliques aux types existants.

object Main:
  extension (x: Int)
    def **(exp: Int): Int = math.pow(x, exp).toInt
  def main(args: Array[String]): Unit =
    println(2 ** 10)

Portée et imports

Les méthodes d'extension ne sont disponibles que là où elles se trouvent dans la portée. Définissez-les dans un objet et importez celui-ci pour les utiliser, afin de contrôler leur portée.

object StringOps:
  extension (s: String)
    def reversedWords: String = s.split(" ").reverse.mkString(" ")

object Main:
  import StringOps._
  def main(args: Array[String]): Unit =
    println("hello there world".reversedWords)

Enchaîner les méthodes d'extension

Les méthodes d'extension renvoient des valeurs ordinaires. Vous pouvez donc les enchaîner avec des méthodes intégrées pour former des enchaînements fluides.

object Main:
  extension (s: String)
    def emphasize: String = s"*$s*"
  def main(args: Array[String]): Unit =
    println("scala".toUpperCase.emphasize)

Un utilitaire pratique

Les méthodes d'extension sont parfaites pour de petits utilitaires métier qui rendent le code appelant naturel à lire.

object Main:
  extension (n: Int)
    def isPrime: Boolean =
      n > 1 && (2 until n).forall(d => n % d != 0)
  def main(args: Array[String]): Unit =
    println((2 to 12).filter(_.isPrime).toList)

Vérification rapide

Quel est le principal avantage des méthodes d'extension de Scala 3 par rapport aux conversions implicites pour ajouter des méthodes ?

Récapitulatif

Vous avez découvert les méthodes d'extension :

extension (x: Type) def ... ajoute des méthodes aux types existants
Un bloc peut définir plusieurs méthodes, y compris des opérateurs
Elles peuvent être génériques et accepter des paramètres
Elles s'associent naturellement aux classes de types via using
Elles sont plus sûres que les conversions implicites et doivent être importées dans la portée

Questions Fréquemment Posées

La leçon « Méthodes d’extension » est-elle gratuite ?

Oui — le texte complet de « Méthodes d’extension » 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 Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Méthodes d’extension » ?

Ajoutez des méthodes aux types Tu pratiques Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming 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 « Méthodes d’extension » ?

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 Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming 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 à Scala for Backend Engineering & Functional Programming