Scala for Backend Engineering & Functional Programming · Pelajaran

Ekspresi match

Buat percabangan berdasarkan bentuk.

Pelajaran 1 dari 413 langkah

Ekspresi match adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 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 match?

match adalah konstruksi percabangan Scala yang canggih. Anda memberikan sebuah nilai dan serangkaian pola case, lalu konstruksi ini menjalankan cabang pertama yang cocok.

Anggaplah ini sebagai versi pernyataan switch yang lebih mumpuni dan berbasis ekspresi.

Sintaks Dasar

Anda menulis value match { case pattern => result }. Setiap case menentukan pola dan kode yang dijalankan ketika pola tersebut cocok.

Karena match adalah sebuah ekspresi, keseluruhan konstruksi ini menghasilkan sebuah nilai.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 2
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case 3 => "three"
    }
    println(word)
  }
}

Kasus Wildcard

Garis bawah _ adalah wildcard yang cocok dengan apa pun. Gunakan ini sebagai bawaan yang menangani semua kemungkinan di bagian akhir.

Tanpanya, nilai yang tidak cocok akan menimbulkan MatchError saat runtime.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 9
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
    }
    println(word)
  }
}

Mencocokkan String

Pola tidak terbatas pada angka. Anda dapat langsung mencocokkan literal string.

object Main {
  def main(args: Array[String]): Unit = {
    val cmd = "start"
    val msg = cmd match {
      case "start" => "Starting up"
      case "stop"  => "Shutting down"
      case _       => "Unknown command"
    }
    println(msg)
  }
}

match Menghasilkan Nilai

Karena setiap cabang menghasilkan nilai, Anda dapat menetapkan hasil match ke sebuah val atau menggunakannya secara langsung.

Hal ini membuat kode tetap rapi dan menghindari variabel yang dapat diubah.

object Main {
  def main(args: Array[String]): Unit = {
    val light = "red"
    println(s"Action: " + (light match {
      case "red"   => "stop"
      case "green" => "go"
      case _       => "caution"
    }))
  }
}

Menggabungkan Kasus

Anda dapat mencocokkan beberapa nilai dalam satu kasus menggunakan | (pipa). Semua nilai yang dicantumkan akan menuju cabang yang sama.

object Main {
  def main(args: Array[String]): Unit = {
    val day = "Sat"
    val kind = day match {
      case "Sat" | "Sun" => "weekend"
      case _             => "weekday"
    }
    println(kind)
  }
}

match dalam Fungsi

Pola yang umum adalah menjadikan seluruh isi fungsi sebagai satu ekspresi match. Hasil pencocokan menjadi nilai yang dikembalikan.

object Main {
  def describe(n: Int): String = n match {
    case 0 => "zero"
    case 1 => "one"
    case _ => "other"
  }
  def main(args: Array[String]): Unit = {
    println(describe(0))
    println(describe(5))
  }
}

Mengikat Seluruh Nilai

Anda dapat mengikat nilai yang cocok ke sebuah nama dalam kasus wildcard menggunakan case other =>. Kemudian, Anda dapat menggunakan other di cabang tersebut.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 42
    val result = n match {
      case 0     => "nothing"
      case other => s"got $other"
    }
    println(result)
  }
}

Urutan Itu Penting

Kasus diuji dari atas ke bawah, dan kecocokan first yang ditemukan akan menang. Letakkan pola yang lebih spesifik sebelum pola yang umum.

Wildcard yang diletakkan terlalu awal akan menutupi kasus-kasus di bawahnya.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 1
    val msg = n match {
      case 1 => "specific one"
      case _ => "anything else"
    }
    println(msg)
  }
}

Mengapa Menggunakan match?

Pencocokan pola merupakan bagian penting Scala karena:

Mudah dibaca untuk percabangan multiarah
Menghasilkan nilai sebagai sebuah ekspresi
Dapat diperluas untuk tipe, struktur data, dan penjaga
Dapat diperiksa kelengkapannya oleh kompiler

Menggabungkan Semuanya

Berikut classifier kecil yang menggunakan literal, kasus gabungan, dan bawaan.

object Main {
  def grade(score: Int): String = score match {
    case 10 | 9 => "excellent"
    case 8 | 7  => "good"
    case _      => "keep trying"
  }
  def main(args: Array[String]): Unit = {
    println(grade(9))
    println(grade(7))
    println(grade(3))
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang ekspresi match.

Jawab di pelajaran interaktif

Rangkuman

Anda telah mempelajari dasar-dasar match:

Sintaksnya adalah value match { case pattern => result }
_ adalah wildcard yang menangani semua kemungkinan
Gabungkan nilai dengan |
match adalah ekspresi yang menghasilkan nilai
Kasus dicoba dari atas ke bawah; kecocokan first akan menang

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 “Ekspresi match” gratis?

Ya — teks lengkap “Ekspresi match” 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 “Ekspresi match”?

Buat percabangan berdasarkan bentuk. 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 1 dari 4.

Berapa lama pelajaran “Ekspresi match” 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