0Pricing
Scala for Backend Engineering & Functional Programming · Leçon

Correspondance des types et des valeurs

Motifs de types

Correspondance des types et des valeurs est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 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.

Motifs de type

Au-delà de la mise en correspondance de valeurs littérales, match peut effectuer un branchement selon le type d’une valeur. On appelle cela un motif de type.

Vous écrivez case x: Type => ; la branche s’exécute lorsque la valeur est de ce type et la lie à x.

Mettre en correspondance selon le type

Lorsqu’une valeur possède un type général comme Any, vous pouvez découvrir son type concret avec un motif de type.

Chaque case x: T vérifie le type lors de l’exécution.

object Main {
  def describe(x: Any): String = x match {
    case i: Int    => "an Int"
    case s: String => "a String"
    case _         => "something else"
  }
  def main(args: Array[String]): Unit = {
    println(describe(5))
    println(describe("hi"))
    println(describe(3.14))
  }
}

Utiliser la valeur liée

Le nom lié possède le type correspondant ; vous pouvez donc appeler ses méthodes en toute sécurité dans cette branche.

Aucune conversion de type n’est nécessaire : le compilateur connaît le type à l’intérieur du cas.

object Main {
  def shout(x: Any): String = x match {
    case s: String => s.toUpperCase
    case i: Int    => (i * 2).toString
    case _         => "?"
  }
  def main(args: Array[String]): Unit = {
    println(shout("hello"))
    println(shout(21))
  }
}

Type et valeur ensemble

Vous pouvez mélanger des motifs de valeur et des motifs de type dans le même match. Les motifs de valeur sont généralement plus spécifiques ; placez-les donc en premier.

object Main {
  def check(x: Any): String = x match {
    case 0       => "zero int"
    case i: Int  => s"nonzero int $i"
    case _       => "not an int"
  }
  def main(args: Array[String]): Unit = {
    println(check(0))
    println(check(7))
    println(check("x"))
  }
}

Faire correspondre Double et Boolean

Les motifs de type fonctionnent avec n’importe quel type, notamment Double, Boolean et Char.

object Main {
  def kind(x: Any): String = x match {
    case d: Double  => s"double $d"
    case b: Boolean => s"bool $b"
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(kind(2.5))
    println(kind(true))
  }
}

Faire correspondre les collections par type

Vous pouvez également faire correspondre des types conteneurs comme List. Ici, nous distinguons une liste des autres valeurs.

object Main {
  def info(x: Any): String = x match {
    case l: List[_] => s"a list of size ${l.size}"
    case _          => "not a list"
  }
  def main(args: Array[String]): Unit = {
    println(info(List(1, 2, 3)))
    println(info("nope"))
  }
}

Un cas d’utilisation courant : gérer Any

Les motifs de type sont particulièrement utiles lorsqu’une fonction reçoit Any et doit réagir différemment selon le type, par exemple pour la journalisation ou la sérialisation.

object Main {
  def render(x: Any): String = x match {
    case i: Int    => s"int=$i"
    case d: Double => s"dbl=$d"
    case s: String => s"str=$s"
    case _         => "unknown"
  }
  def main(args: Array[String]): Unit = {
    List(1, 2.0, "three").foreach(v => println(render(v)))
  }
}

L’ordre reste important

Comme pour toutes les correspondances, les motifs de type sont vérifiés de haut en bas. Un type plus général placé en premier peut masquer un type plus précis situé plus bas.

Ordonnez-les toujours du plus spécifique au plus général.

object Main {
  def label(x: Any): String = x match {
    case s: String => "string first"
    case _: Any    => "anything"
  }
  def main(args: Array[String]): Unit = {
    println(label("hi"))
    println(label(99))
  }
}

Attention à l’effacement des types

À l’exécution, les paramètres de type génériques sont effacés. Ainsi, List[Int] et List[String] paraissent identiques. Faire correspondre List[Int] vérifie seulement qu’il s’agit d’une List.

Utilisez List[_] pour être explicite et éviter les avertissements.

Pourquoi utiliser les motifs de type ?

Les motifs de type vous permettent de :

  • Restreindre en toute sécurité un type général sans conversion explicite
  • Gérer proprement des valeurs hétérogènes
  • Les combiner avec des motifs de valeur et des gardes

Ils constituent une étape vers la correspondance avec des classes case et des ADT.

Mettre tout ensemble

Combinez des motifs de valeur et de type pour classifier une entrée mixte.

object Main {
  def classify(x: Any): String = x match {
    case 0          => "zero"
    case i: Int     => "int"
    case s: String  => "text of length " + s.length
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(classify(0))
    println(classify(5))
    println(classify("hey"))
  }
}

Vérification rapide

Vérifiez vos connaissances sur les motifs de type.

Récapitulatif

Vous avez appris à faire correspondre des types :

  • case x: Type fait correspondre le type à l’exécution et lie x
  • La valeur liée possède le type correspondant, aucune conversion n’est donc nécessaire
  • Combinez les motifs de valeur et de type, en plaçant les plus spécifiques en premier
  • Les paramètres génériques sont effacés ; utilisez donc List[_]

Questions Fréquemment Posées

La leçon « Correspondance des types et des valeurs » est-elle gratuite ?

Oui — le texte complet de « Correspondance des types et des valeurs » 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 « Correspondance des types et des valeurs » ?

Motifs de 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 2 sur 4.

Combien de temps prend la leçon « Correspondance des types et des valeurs » ?

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

  1. Expressions match
  2. Correspondance des types et des valeurs
  3. Gardes et liaison
  4. Déconstruction
← Retour à Scala for Backend Engineering & Functional Programming