Pengawal dan Pengikatan
Syarat dalam padanan
Pengawal dan Pengikatan ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.
Apakah Itu Pengawal?
Pengawal menambahkan syarat boolean pada suatu kes menggunakan if. Kes itu hanya sepadan apabila coraknya sesuai dan pengawalnya bernilai benar.
Pengawal membolehkan satu corak dipecahkan kepada kes-kes yang lebih terperinci berdasarkan nilai.
Menambahkan Pengawal if
Tulis pengawal selepas corak: case n if n > 0 =>. Jika syarat itu palsu, padanan diteruskan ke kes seterusnya.
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 Kemudian Mengawal
Pengawal boleh merujuk kepada nama yang anda ikat dalam corak. Beginilah cara anda menguji sifat nilai yang sepadan.
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))
}
}Pengawal pada Julat
Pengawal amat sesuai untuk julat, yang tidak dapat dinyatakan secara terus oleh corak 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 Corak dengan @
Simbol @ mengikat keseluruhan nilai yang sepadan kepada suatu nama sambil terus memadankan strukturnya.
Di sini, whole @ pattern bermaksud: padankan pattern, dan panggil juga nilai yang sepadan itu whole.
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 @ amat berguna dengan corak berstruktur, seperti menangkap keseluruhan senarai sambil memeriksa kepala senarai.
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 Corak Jenis dan Pengawal
Anda boleh mencampurkan corak jenis dengan pengawal. Mula-mula jenis diperiksa, kemudian syarat boolean.
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))
}
}Berbilang Syarat
Pengawal hanyalah ungkapan boolean, jadi anda boleh menggabungkan syarat 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))
}
}Pengawal Tidak Bersambung ke Kes Seterusnya
Jika corak sepadan tetapi pengawalnya palsu, Scala beralih ke kes seterusnya, bukannya ke pengawal seterusnya bagi corak yang sama.
Pastikan kes yang kemudian boleh menangkap nilai yang gagal memenuhi setiap pengawal.
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 Pengawal dan Pengikatan?
Gabungan pengawal dan pengikatan @ menjadikan padanan corak lebih ekspresif:
- Pengawal menambahkan syarat seperti julat dan kebolehbahagian
@menangkap keseluruhan nilai sambil menguraikannya- Kedua-duanya menjadikan logik percabangan ringkas dan mudah dibaca
Menggabungkan Kesemuanya
Contoh ini mengikat nilai, memeriksa pengawal dan menyediakan pilihan sandaran.
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))
}
}Semakan Pantas
Uji pemahaman anda tentang pengawal dan pengikatan.
Imbas Kembali
Anda telah mempelajari cara memperincikan padanan:
- Pengawal ialah syarat
ifselepas corak - Jika pengawal palsu, padanan beralih ke kes seterusnya
- Operator
@mengikat keseluruhan nilai sambil menguraikannya - Pengawal boleh digabungkan dengan corak jenis dan operator boolean
Pelajari Scala dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 39
- Pelajaran
- 143
Soalan Lazim
Adakah pelajaran “Pengawal dan Pengikatan” percuma?
Ya — teks penuh “Pengawal dan Pengikatan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Pengawal dan Pengikatan”?
Syarat dalam padanan Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Pengawal dan Pengikatan” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?
Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Ungkapan match
- Memadankan Jenis dan Nilai
- Pengawal dan Pengikatan
- Penyahbinaan