Scala for Backend Engineering & Functional Programming · Pelajaran

Guard dan Binding

Kondisi dalam pencocokan.

Guard dan Binding adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 3 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 Penjaga?

Penjaga menambahkan kondisi boolean ke sebuah kasus menggunakan if. Kasus hanya cocok ketika polanya sesuai dan penjaganya bernilai true.

Penjaga memungkinkan satu pola dibagi menjadi kasus-kasus yang lebih terperinci berdasarkan nilainya.

Menambahkan Penjaga if

Tulis penjaga setelah pola: case n if n > 0 =>. Jika kondisinya false, pencocokan dilanjutkan ke kasus berikutnya.

object Main {
  def sign(n: Int): String = n match {
    case x if x > 0 => "positive"
    case x if x < 0 => "negative"
    case _          => "zero"
  }
  def main(args: Array[String]): Unit = {
    println(sign(5))
    println(sign(-3))
    println(sign(0))
  }
}

Mengikat Lalu Memberi Penjaga

Penjaga dapat merujuk pada nama yang Anda ikat dalam pola. Dengan cara inilah Anda menguji properti nilai yang cocok.

object Main {
  def fizz(n: Int): String = n match {
    case x if x % 15 == 0 => "FizzBuzz"
    case x if x % 3 == 0  => "Fizz"
    case x if x % 5 == 0  => "Buzz"
    case x                => x.toString
  }
  def main(args: Array[String]): Unit = {
    println(fizz(15))
    println(fizz(9))
    println(fizz(7))
  }
}

Penjaga pada Rentang

Penjaga sangat cocok untuk rentang, yang tidak dapat dinyatakan langsung oleh pola literal.

object Main {
  def band(score: Int): String = score match {
    case s if s >= 90 => "A"
    case s if s >= 80 => "B"
    case s if s >= 70 => "C"
    case _            => "F"
  }
  def main(args: Array[String]): Unit = {
    println(band(95))
    println(band(83))
    println(band(60))
  }
}

Pengikatan Pola dengan @

Simbol @ mengikat seluruh nilai yang cocok ke sebuah nama, sambil tetap mencocokkan strukturnya.

Di sini, whole @ pattern berarti: cocokkan pattern, dan beri nama whole pada nilai yang cocok tersebut.

object Main {
  def main(args: Array[String]): Unit = {
    val x: Any = 7
    val msg = x match {
      case n @ (_: Int) => s"int value is $n"
      case _            => "other"
    }
    println(msg)
  }
}

Pengikatan dalam Koleksi

Pengikatan @ sangat berguna dengan pola terstruktur, misalnya untuk menangkap seluruh list sekaligus memeriksa head-nya.

object Main {
  def describe(xs: List[Int]): String = xs match {
    case all @ (first :: _) => s"starts with $first, full = $all"
    case Nil                => "empty"
  }
  def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3)))
    println(describe(Nil))
  }
}

Menggabungkan Pola Tipe dan Penjaga

Anda dapat mencampur pola tipe dengan penjaga. Pertama, tipe diperiksa, lalu kondisi boolean diperiksa.

object Main {
  def label(x: Any): String = x match {
    case s: String if s.length > 3 => "long string"
    case s: String                 => "short string"
    case _                         => "not a string"
  }
  def main(args: Array[String]): Unit = {
    println(label("hello"))
    println(label("hi"))
    println(label(42))
  }
}

Beberapa Kondisi

Penjaga hanyalah ekspresi boolean, jadi Anda dapat menggabungkan kondisi dengan && dan ||.

object Main {
  def category(age: Int): String = age match {
    case a if a >= 13 && a <= 19 => "teen"
    case a if a < 13             => "child"
    case _                       => "adult"
  }
  def main(args: Array[String]): Unit = {
    println(category(15))
    println(category(8))
    println(category(40))
  }
}

Penjaga Tidak Berlanjut ke Bawah

Jika sebuah pola cocok tetapi penjaganya false, Scala beralih ke kasus berikutnya, bukan ke penjaga berikutnya dari pola yang sama.

Pastikan kasus setelahnya dapat menangani nilai yang gagal pada semua penjaga.

object Main {
  def test(n: Int): String = n match {
    case x if x > 100 => "big"
    case x            => s"not big: $x"
  }
  def main(args: Array[String]): Unit = {
    println(test(200))
    println(test(5))
  }
}

Mengapa Penjaga dan Pengikatan?

Secara bersama-sama, penjaga dan pengikatan @ membuat pencocokan pola menjadi ekspresif:

Penjaga menambahkan kondisi seperti rentang dan keterbagian
@ menangkap seluruh nilai sambil menguraikan strukturnya
Keduanya membuat logika percabangan tetap ringkas dan mudah dibaca

Menggabungkan Semuanya

Contoh ini mengikat nilai, memeriksa penjaga, dan menyediakan fallback.

object Main {
  def temp(c: Int): String = c match {
    case t if t >= 30 => s"hot ($t)"
    case t if t >= 15 => s"mild ($t)"
    case t            => s"cold ($t)"
  }
  def main(args: Array[String]): Unit = {
    println(temp(35))
    println(temp(20))
    println(temp(5))
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang penjaga dan pengikatan.

Rangkuman

Anda telah belajar menyempurnakan pencocokan:

Penjaga adalah kondisi if setelah sebuah pola
Jika penjaga false, pencocokan beralih ke kasus berikutnya
Operator @ mengikat seluruh nilai sambil menguraikan strukturnya
Penjaga dapat digabungkan dengan pola tipe dan operator boolean

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Guard dan Binding” gratis?

Ya — teks lengkap “Guard dan Binding” 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 “Guard dan Binding”?

Kondisi dalam pencocokan. 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 3 dari 4.

Berapa lama pelajaran “Guard dan Binding” 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