Scala for Backend Engineering & Functional Programming · Pelajaran

Operasi Fungsional pada Koleksi

Kuasai operasi fungsional umum seperti map, filter, fold, dan reduce untuk transformasi data.

Operasi Fungsional pada Koleksi adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. 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 3 pelajaran total.

Operasi Fungsional: Mengapa Menggunakannya?

Operasi fungsional pada koleksi membantu Anda mengubah dan menggabungkan data tanpa mengubah koleksi asli. Pendekatan ini mendorong keimutan dan membuat kode Anda lebih mudah dibaca serta diuji.

Kita akan mempelajari operasi utama seperti map, filter, reduce, dan fold.

Transformasi dengan `map`

Operasi map menerapkan sebuah fungsi ke setiap elemen koleksi dan mengembalikan koleksi baru yang berisi hasil transformasi. Koleksi asli tetap tidak berubah.

Cobalah menjalankan contoh berikut:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val doubled = numbers.map(n => n * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubled")
  }
}

`map` dengan Tipe Berbeda

map sangat fleksibel! Anda dapat mengubah elemen menjadi tipe yang benar-benar berbeda. Di sini, kita mengubah angka menjadi string atau mendapatkan panjang string.

Perhatikan bahwa hasilnya adalah List[Int], meskipun inputnya adalah List[String].

object Main {
  def main(args: Array[String]): Unit = {
    val names = List("Alice", "Bob", "Charlie")
    val lengths = names.map(name => name.length)
    println(s"Names: $names")
    println(s"Lengths: $lengths")
  }
}

Memilih dengan `filter`

Operasi filter membuat koleksi baru yang hanya berisi elemen yang memenuhi kondisi tertentu (fungsi predikat). Operasi ini "menyaring" elemen yang tidak diinginkan.

Mari kita mencari angka genap:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter(n => n % 2 == 0)
    println(s"Original: $numbers")
    println(s"Evens: $evens")
  }
}

Contoh `filter` Lainnya

Anda dapat menggunakan ekspresi boolean apa pun sebagai kondisi penyaringan. Mari kita menyaring daftar kata agar hanya menyisakan kata yang panjangnya lebih dari 4 karakter.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "cat", "banana", "dog", "elephant")
    val longWords = words.filter(w => w.length > 4)
    println(s"Words: $words")
    println(s"Long words: $longWords")
  }
}

Menggabungkan dengan `reduce`

Operasi reduce menggabungkan semua elemen koleksi menjadi satu hasil. Operasi ini menerima operasi biner (fungsi yang menerima dua argumen dan mengembalikan satu hasil), lalu menerapkannya secara kumulatif.

Di sini, kita menjumlahkan semua elemen:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val sum = numbers.reduce((a, b) => a + b)
    println(s"Numbers: $numbers")
    println(s"Sum: $sum")
  }
}

`reduce` untuk Hasil Kali & Maksimum

reduce dapat melakukan berbagai agregasi. Kita dapat menghitung hasil kali angka atau mencari nilai maksimum.

Catatan: reduce akan menghasilkan error pada koleksi kosong.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 5, 2, 8)
    val product = numbers.reduce((a, b) => a * b)
    val maxNum = numbers.reduce((a, b) => if (a > b) a else b)
    println(s"Numbers: $numbers")
    println(s"Product: $product")
    println(s"Max: $maxNum")
  }
}

`fold`: Keunggulan Nilai Awal

fold mirip dengan reduce, tetapi memiliki perbedaan penting: operasi ini menerima nilai awal (juga disebut "akumulator"). Hal ini membuatnya aman untuk koleksi kosong dan memungkinkan penggunaan tipe hasil yang berbeda.

Mari kita menjumlahkan angka, dimulai dari 10:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    // foldLeft(initialValue)(operation)
    val sumWithInitial = numbers.foldLeft(10)((acc, n) => acc + n)
    println(s"Numbers: $numbers")
    println(s"Sum (starting from 10): $sumWithInitial")
  }
}

Arah: `foldLeft` vs `foldRight`

Scala menyediakan foldLeft dan foldRight. Keduanya berbeda dalam urutan pemrosesan elemen dan cara akumulator diteruskan.

foldLeft(initial)(op): Memproses dari kiri ke kanan.
foldRight(initial)(op): Memproses dari kanan ke kiri.

Untuk operasi seperti penggabungan string, arah pemrosesan berpengaruh!

object Main {
  def main(args: Array[String]): Unit = {
    val chars = List('a', 'b', 'c')
    val leftFold = chars.foldLeft("")((acc, c) => acc + c)
    val rightFold = chars.foldRight("")((c, acc) => acc + c)
    println(s"Chars: $chars")
    println(s"foldLeft: $leftFold") // Output: abc
    println(s"foldRight: $rightFold") // Output: abc (due to string append order)

    // Example where order matters: (acc, char) => char + acc
    val rightFoldReversed = chars.foldRight("")((c, acc) => c + acc)
    println(s"foldRight (char + acc): $rightFoldReversed") // Output: abc

    // A common example where order matters is for operations like subtraction or division, but string concatenation also shows it.
  }
}

Pemeriksaan Operasi Fungsional

Perhatikan potongan kode Scala berikut:

val data = List(10, 20, 30, 40)
val result1 = data.map(x => x / 10)
val result2 = data.filter(x => x > 25)
val result3 = data.reduce((a, b) => a + b)

Pernyataan berikut mana yang TRUE tentang hasilnya?

Rangkuman: Keunggulan Operasi Fungsional

Anda telah menguasai operasi fungsional yang penting!

map mengubah setiap elemen.
filter memilih elemen berdasarkan suatu kondisi.
reduce menggabungkan elemen menjadi satu hasil (memerlukan koleksi yang tidak kosong).
fold menggabungkan elemen dengan nilai awal (aman untuk koleksi kosong).

Operasi-operasi ini penting untuk menulis kode Scala yang ringkas, imutabel, dan berdaya guna. Selanjutnya, kita akan mempelajari penanganan error yang tangguh menggunakan Option, Try, dan Either.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Operasi Fungsional pada Koleksi” gratis?

Ya — teks lengkap “Operasi Fungsional pada Koleksi” 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 3 pelajaran total.

Apa yang akan aku pelajari di “Operasi Fungsional pada Koleksi”?

Kuasai operasi fungsional umum seperti map, filter, fold, dan reduce untuk transformasi 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 2 dari 3.

Berapa lama pelajaran “Operasi Fungsional pada Koleksi” 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