Scala for Backend Engineering & Functional Programming · Pelajaran

Pencocokan Menyeluruh

Kelengkapan yang diperiksa compiler.

Pelajaran 4 dari 413 langkah

Pencocokan Menyeluruh adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa Itu Pencocokan Lengkap?

Match bersifat lengkap jika menangani setiap nilai yang mungkin dari tipe yang dicocokkan.

Untuk trait sealed, kompiler mengetahui semua varian dan dapat memeriksa apakah match Anda mencakup semuanya.

Pencocokan Lengkap

Saat Anda menangani setiap varian dari trait sealed, kompiler tidak menemukan masalah dan tidak menampilkan peringatan.

sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color
object Main {
  def name(c: Color): String = c match {
    case Red   => "red"
    case Green => "green"
    case Blue  => "blue"
  }
  def main(args: Array[String]): Unit = {
    println(name(Blue))
  }
}

Kompiler Melindungi Anda

Jika Anda tidak menyertakan suatu varian, kompiler mengeluarkan peringatan pencocokan tidak lengkap saat kompilasi.

Ini menjadi jaring pengaman: Anda mengetahui kekurangannya sebelum menjalankan program.

Menambahkan Varian Kemudian

Manfaat sebenarnya terlihat saat Anda menambahkan varian baru. Setiap pencocokan yang tidak lengkap di seluruh basis kode Anda akan memunculkan peringatan, mengingatkan Anda untuk menangani kasus baru tersebut.

Hal ini membuat refaktor menjadi aman dan dapat diprediksi.

Mengapa Menghindari Wildcard

Menambahkan case _ => membungkam peringatan kelengkapan. Hal itu dapat menyembunyikan bug saat Anda menambahkan varian di kemudian hari.

Untuk ADT sealed, sebaiknya cantumkan setiap varian secara eksplisit agar kompiler terus melindungi Anda.

sealed trait Status
case object Active extends Status
case object Inactive extends Status
object Main {
  def label(s: Status): String = s match {
    case Active   => "on"
    case Inactive => "off"
  }
  def main(args: Array[String]): Unit = {
    println(label(Active))
  }
}

Kelengkapan dengan Data

Kelengkapan juga berlaku untuk varian yang membawa data. Anda mengikat field-field tersebut dan tetap harus mencakup setiap varian.

sealed trait Shape
case class Circle(r: Double) extends Shape
case class Square(s: Double) extends Shape
object Main {
  def area(sh: Shape): Double = sh match {
    case Circle(r) => 3.14159 * r * r
    case Square(s) => s * s
  }
  def main(args: Array[String]): Unit = {
    println(area(Circle(2)))
    println(area(Square(3)))
  }
}

Menggabungkan dengan Guard

Berhati-hatilah: guard dapat membuat pencocokan tidak lengkap karena kompiler tidak dapat membuktikan bahwa guard mencakup semua nilai.

Sediakan kasus akhir tanpa guard untuk varian yang sama agar pencocokan tetap lengkap.

sealed trait Temp
case class Celsius(v: Int) extends Temp
object Main {
  def feel(t: Temp): String = t match {
    case Celsius(v) if v >= 30 => "hot"
    case Celsius(v)            => "not hot"
  }
  def main(args: Array[String]): Unit = {
    println(feel(Celsius(35)))
    println(feel(Celsius(10)))
  }
}

Kelengkapan dengan Option

Option dari pustaka standar adalah ADT sealed dengan Some dan None. Mencocokkan keduanya membuatnya lengkap.

object Main {
  def show(o: Option[Int]): String = o match {
    case Some(v) => s"value $v"
    case None    => "nothing"
  }
  def main(args: Array[String]): Unit = {
    println(show(Some(7)))
    println(show(None))
  }
}

Kelengkapan Bertingkat

Kelengkapan juga membantu pada ADT bertingkat. Kompiler menalar setiap tingkat yang Anda uraikan.

sealed trait Tree
case object Leaf extends Tree
case class Node(v: Int, l: Tree, r: Tree) extends Tree
object Main {
  def depth(t: Tree): Int = t match {
    case Leaf          => 0
    case Node(_, l, r) => 1 + math.max(depth(l), depth(r))
  }
  def main(args: Array[String]): Unit = {
    println(depth(Node(1, Leaf, Node(2, Leaf, Leaf))))
  }
}

Mengapa Ini Penting

Kelengkapan yang diperiksa kompiler memberi Anda:

Keyakinan bahwa setiap kasus telah ditangani
Pengingat otomatis saat ADT bertambah
Lebih sedikit MatchErrors saat runtime
Refaktor berskala besar yang lebih aman

Menggabungkan Semuanya

ADT sealed dengan cakupan lengkap. Menambahkan varian baru akan memicu peringatan kompiler di sini.

sealed trait Command
case object Start extends Command
case object Stop extends Command
case class SetSpeed(v: Int) extends Command
object Main {
  def run(c: Command): String = c match {
    case Start       => "starting"
    case Stop        => "stopping"
    case SetSpeed(v) => s"speed $v"
  }
  def main(args: Array[String]): Unit = {
    List(Start, SetSpeed(5), Stop).foreach(c => println(run(c)))
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang pencocokan lengkap.

Jawab di pelajaran interaktif

Rangkuman

Anda telah mempelajari pencocokan lengkap:

Match lengkap jika mencakup setiap varian
Untuk trait sealed, kompiler memeriksanya dan memperingatkan jika ada yang terlewat
Menambahkan varian akan menampilkan setiap pencocokan yang belum lengkap
Hindari case _ pada ADT sealed agar perlindungan tersebut tetap ada
Guard dapat merusak kelengkapan; tambahkan fallback tanpa guard

Gratis untuk memulai

Belajar Scala dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 143

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pencocokan Menyeluruh” gratis?

Ya — teks lengkap “Pencocokan Menyeluruh” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pencocokan Menyeluruh”?

Kelengkapan yang diperiksa compiler. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pencocokan Menyeluruh” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming