Dekonstruksi
Ekstrak dari data.
Dekonstruksi 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 Dekonstruksi?
Dekonstruksi (juga disebut destructuring) berarti mengekstrak bagian-bagian struktur data langsung di dalam pola.
Alih-alih memanggil metode pengakses, Anda menjelaskan bentuknya dan menamai bagian yang diinginkan.
Mendekonstruksi Tuple
Tuple mengelompokkan beberapa nilai. Anda dapat memisahkannya dalam satu pengikatan dengan menulis nama-nama di dalam tanda kurung.
object Main {
def main(args: Array[String]): Unit = {
val pair = ("Ada", 1815)
val (name, year) = pair
println(s"$name was born in $year")
}
}Tuple dalam match
Anda dapat mendekonstruksi tuple di dalam match, dengan menamai atau mencocokkan setiap komponennya.
object Main {
def quadrant(p: (Int, Int)): String = p match {
case (0, 0) => "origin"
case (x, 0) => s"on x-axis at $x"
case (0, y) => s"on y-axis at $y"
case (x, y) => s"point ($x, $y)"
}
def main(args: Array[String]): Unit = {
println(quadrant((0, 0)))
println(quadrant((3, 0)))
println(quadrant((2, 5)))
}
}Mendekonstruksi Head List
Operator :: (cons) memisahkan list menjadi elemen pertamanya (head) dan sisanya (tail).
Pola head :: tail cocok dengan list apa pun yang tidak kosong.
object Main {
def first(xs: List[Int]): String = xs match {
case head :: tail => s"head=$head, rest=$tail"
case Nil => "empty"
}
def main(args: Array[String]): Unit = {
println(first(List(10, 20, 30)))
println(first(Nil))
}
}Mencocokkan Bentuk List yang Tepat
Anda dapat mencocokkan list dengan panjang tertentu dengan mencantumkan elemennya, seperti List(a, b) untuk tepat dua item.
object Main {
def shape(xs: List[Int]): String = xs match {
case List() => "none"
case List(a) => s"one: $a"
case List(a, b) => s"two: $a, $b"
case _ => "many"
}
def main(args: Array[String]): Unit = {
println(shape(List()))
println(shape(List(1)))
println(shape(List(1, 2)))
println(shape(List(1, 2, 3)))
}
}Rekursi dengan Head dan Tail
Pemisahan head dari tail memungkinkan rekursi yang rapi pada sebuah list.
Di sini kita menjumlahkan list dengan menambahkan head ke jumlah tail.
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case head :: tail => head + sum(tail)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}Mendekonstruksi Struktur Bertingkat
Pola dapat bersarang. Anda dapat mendekonstruksi tuple di dalam list, atau list di dalam tuple, sekaligus.
object Main {
def main(args: Array[String]): Unit = {
val data = List(("a", 1), ("b", 2))
data match {
case (key, value) :: _ => println(s"first key=$key value=$value")
case Nil => println("empty")
}
}
}Mengabaikan Bagian dengan _
Gunakan _ untuk komponen yang tidak Anda perlukan. Dengan demikian, pola tetap berfokus pada data yang benar-benar dibutuhkan.
object Main {
def main(args: Array[String]): Unit = {
val triple = (1, 2, 3)
val (_, middle, _) = triple
println(s"middle = $middle")
}
}Mengikat Dua Elemen Pertama, Menyimpan Sisanya
Anda dapat menamai elemen-elemen pertama dan menangkap semua elemen setelahnya dengan pola tail.
object Main {
def main(args: Array[String]): Unit = {
val xs = List(1, 2, 3, 4, 5)
xs match {
case a :: b :: rest => println(s"a=$a b=$b rest=$rest")
case _ => println("too short")
}
}
}Mengapa Dekonstruksi?
Dekonstruksi membuat akses data menjadi:
- Deklaratif: Anda menjelaskan bentuknya, bukan langkah-langkahnya
- Aman: struktur diperiksa saat Anda mengekstraknya
- Ringkas: beberapa nilai diikat dalam satu pola
Dekonstruksi menjadi lebih kuat lagi jika digunakan dengan case class.
Menggabungkan Semuanya
Contoh ini mendekonstruksi list berisi tuple dan merespons bentuknya.
object Main {
def report(scores: List[(String, Int)]): String = scores match {
case Nil => "no scores"
case (name, pts) :: Nil => s"only $name with $pts"
case (name, pts) :: rest => s"top $name=$pts plus ${rest.size} more"
}
def main(args: Array[String]): Unit = {
println(report(Nil))
println(report(List(("Ann", 90))))
println(report(List(("Ann", 90), ("Bo", 80))))
}
}Pemeriksaan Singkat
Uji pemahaman Anda tentang dekonstruksi.
Rangkuman
Anda telah belajar mendekonstruksi data dalam pola:
- Tuple dipisahkan dengan
(a, b) - List dipisahkan dengan
head :: tailatau bentuk tepat sepertiList(a, b) Nilcocok dengan list kosong- Gunakan
_untuk mengabaikan bagian; susun pola secara bersarang untuk struktur yang dalam - Pemisahan head/tail memungkinkan rekursi yang rapi
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Dekonstruksi” gratis?
Ya — teks lengkap “Dekonstruksi” 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 “Dekonstruksi”?
Ekstrak dari data. 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 “Dekonstruksi” 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.