0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Mencocokkan Tipe dan Nilai

Pola tipe.

Mencocokkan Tipe dan Nilai adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 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.

Pola Tipe

Selain mencocokkan nilai literal, match dapat bercabang berdasarkan tipe suatu nilai. Ini disebut pola tipe.

Anda menulis case x: Type =>, dan cabang tersebut dijalankan ketika nilainya bertipe itu, dengan mengikatnya ke x.

Mencocokkan Berdasarkan Tipe

Ketika sebuah nilai memiliki tipe umum seperti Any, Anda dapat mengetahui tipe konkretnya menggunakan pola tipe.

Setiap case x: T memeriksa tipe saat runtime.

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))
  }
}

Menggunakan Nilai yang Diikat

Nama yang diikat memiliki tipe yang cocok, sehingga Anda dapat memanggil metodenya dengan aman di cabang tersebut.

Tidak diperlukan casting: kompiler mengetahui tipenya di dalam kasus tersebut.

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))
  }
}

Tipe dan Nilai Bersamaan

Anda dapat mencampur pola nilai dan pola tipe dalam match yang sama. Pola nilai biasanya lebih spesifik, jadi letakkan pola tersebut terlebih dahulu.

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"))
  }
}

Mencocokkan Double dan Boolean

Pola tipe berlaku untuk tipe apa pun, termasuk Double, Boolean, dan 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))
  }
}

Mencocokkan Koleksi Berdasarkan Tipe

Anda juga dapat mencocokkan tipe wadah seperti List. Di sini kita membedakan list dari nilai lainnya.

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"))
  }
}

Penggunaan Umum: Menangani Any

Pola tipe sangat berguna ketika sebuah fungsi menerima Any dan harus memberikan respons berbeda untuk setiap tipe, misalnya untuk pencatatan atau serialisasi.

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)))
  }
}

Urutan Tetap Penting

Seperti semua pencocokan, pola tipe diperiksa dari atas ke bawah. Tipe yang lebih umum jika diletakkan lebih awal dapat menyembunyikan tipe yang lebih khusus di bawahnya.

Selalu urutkan dari yang paling spesifik ke yang paling umum.

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))
  }
}

Keterbatasan Penghapusan Tipe

Saat runtime, parameter tipe generik akan dihapus. Jadi, List[Int] dan List[String] terlihat sama. Pencocokan pada List[Int] hanya memeriksa bahwa nilainya adalah sebuah List.

Gunakan List[_] agar lebih jelas dan terhindar dari peringatan.

Mengapa Pola Tipe?

Pola tipe memungkinkan Anda:

  • Mempersempit tipe umum dengan aman tanpa casting
  • Menangani nilai heterogen dengan rapi
  • Menggabungkannya dengan pola nilai dan penjaga

Pola ini menjadi langkah awal menuju pencocokan pada case class dan ADT.

Menggabungkan Semuanya

Gabungkan pola nilai dan pola tipe untuk mengklasifikasikan input campuran.

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"))
  }
}

Pemeriksaan Singkat

Uji pengetahuan Anda tentang pola tipe.

Rangkuman

Anda telah belajar mencocokkan berdasarkan tipe:

  • case x: Type mencocokkan berdasarkan tipe runtime dan mengikatnya ke x
  • Nilai yang diikat memiliki tipe yang cocok, sehingga tidak diperlukan cast
  • Campurkan pola nilai dan pola tipe, dengan yang paling spesifik terlebih dahulu
  • Parameter generik dihapus, jadi gunakan List[_]

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mencocokkan Tipe dan Nilai” gratis?

Ya — teks lengkap “Mencocokkan Tipe dan Nilai” 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 “Mencocokkan Tipe dan Nilai”?

Pola tipe. 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 2 dari 4.

Berapa lama pelajaran “Mencocokkan Tipe dan Nilai” 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

  1. Ekspresi match
  2. Mencocokkan Tipe dan Nilai
  3. Guard dan Binding
  4. Dekonstruksi
← Kembali ke Scala for Backend Engineering & Functional Programming