Scala for Backend Engineering & Functional Programming · Pelajaran

foldLeft dan foldRight

Ringkas koleksi menjadi sebuah nilai.

foldLeft dan foldRight 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.

Melipat Koleksi

Pelipatan meringkas koleksi menjadi satu nilai dengan berulang kali menggabungkan elemen menggunakan akumulator.

Pola akumulator yang telah Anda pelajari persis seperti yang diabstraksikan oleh fold. Alih-alih menulis pembantu rekursif sendiri, Anda memberikan nilai awal dan fungsi penggabungan.

Dasar-dasar foldLeft

foldLeft menerima akumulator awal dan fungsi (acc, element), lalu menelusuri koleksi dari kiri ke kanan.

Pada setiap langkah, akumulator digantikan dengan hasil fungsi tersebut.

val xs = List(1, 2, 3, 4)
val total = xs.foldLeft(0)((acc, x) => acc + x)

@main def run(): Unit =
  println(total)  // 10

Cara foldLeft Mengelompokkan

foldLeft mengelompokkan dari kiri. Untuk List(1, 2, 3) dengan nilai awal z, perhitungannya adalah f(f(f(z, 1), 2), 3).

Akumulator menjadi argumen kiri, sehingga nilainya terakumulasi saat Anda bergerak ke kanan melalui list.

// List(1, 2, 3).foldLeft(0)(_ + _)
// = ((0 + 1) + 2) + 3
// = 6

Dasar-dasar foldRight

foldRight juga menggabungkan elemen, tetapi dimulai dari kanan.

Fungsinya menerima (element, acc), dengan elemen di sebelah kiri dan akumulator di sebelah kanan.

val xs = List(1, 2, 3, 4)
val total = xs.foldRight(0)((x, acc) => x + acc)

@main def run(): Unit =
  println(total)  // 10

Cara foldRight Mengelompokkan

foldRight mengelompokkan dari kanan. Untuk List(1, 2, 3) dengan nilai awal z, perhitungannya adalah f(1, f(2, f(3, z))).

Nilai awal berada paling kanan dan list digabungkan ke arah dalam mulai dari ujung.

// List(1, 2, 3).foldRight(0)(_ + _)
// = 1 + (2 + (3 + 0))
// = 6

Saat Arah Menentukan Hasil

Untuk operasi asosiatif dan komutatif seperti penjumlahan atau perkalian, kedua pelipatan menghasilkan jawaban yang sama.

Untuk operasi yang tidak komutatif seperti pengurangan atau pembangunan list, arah mengubah hasilnya. Pilihlah dengan sengaja.

val xs = List(1, 2, 3)
val l = xs.foldLeft(0)(_ - _)   // ((0-1)-2)-3 = -6
val r = xs.foldRight(0)(_ - _)  // 1-(2-(3-0)) = 2

@main def run(): Unit =
  println((l, r))  // (-6, 2)

Membangun List

foldRight adalah pilihan alami untuk membangun kembali list sesuai urutan, karena bekerja dari ekor ke arah dalam dan penambahan ke bagian depan mempertahankan posisi elemen.

Ini memetakan setiap elemen sekaligus mempertahankan urutannya.

val xs = List(1, 2, 3)
val doubled = xs.foldRight(List.empty[Int]) { (x, acc) =>
  (x * 2) :: acc
}

@main def run(): Unit =
  println(doubled)  // List(2, 4, 6)

foldLeft Membalik Hasil

Jika Anda membangun list dengan foldLeft dan menambahkan elemen ke bagian depan, hasilnya menjadi terbalik karena elemen ditambahkan dari depan saat Anda bergerak ke kanan.

Terkadang, justru itulah hasil yang Anda inginkan.

val xs = List(1, 2, 3)
val rev = xs.foldLeft(List.empty[Int]) { (acc, x) =>
  x :: acc
}

@main def run(): Unit =
  println(rev)  // List(3, 2, 1)

Keamanan Tumpukan

foldLeft menggunakan rekursi ekor dan berjalan sebagai perulangan, sehingga aman untuk koleksi yang sangat besar.

foldRight pada List bukan rekursi ekor dan dapat menyebabkan luapan tumpukan untuk list yang sangat panjang. Pilih foldLeft jika Anda tidak memerlukan urutan dari kanan ke kiri.

// Safe even for millions of elements:
val n = (1 to 1000000).foldLeft(0L)(_ + _)

// foldRight on a long List risks StackOverflowError

Mengubah Jenis Hasil

Jenis akumulator dapat berbeda dari jenis elemen.

Di sini, kita melipat list berisi bilangan bulat menjadi string, sehingga nilai awalnya adalah string kosong dan setiap langkah menambahkan teks.

Jenis fold ditentukan oleh nilai awalnya.

val xs = List(1, 2, 3)
val s = xs.foldLeft("")((acc, x) => acc + x.toString)

@main def run(): Unit =
  println(s)  // "123"

Fold sebagai Pisau Serbaguna

Banyak operasi list merupakan kasus khusus dari fold: sum, product, length, max, map, filter, reverse.

Mengenali fold yang mendasarinya membantu Anda menulis kode deklaratif yang ringkas, bukan rekursi yang dibuat secara manual.

val xs = List(4, 1, 7, 3)
val maxV = xs.foldLeft(Int.MinValue)(_ max _)
val len  = xs.foldLeft(0)((acc, _) => acc + 1)

@main def run(): Unit =
  println((maxV, len))  // (7, 4)

Pemeriksaan Singkat

Jelaskan arah fold dan posisi nilai awalnya.

Ringkasan

foldLeft berjalan dari kiri ke kanan dengan akumulator di sebelah kiri dan menghitung ((z op a) op b) op c. Metode ini menggunakan rekursi ekor dan aman bagi tumpukan.

foldRight berjalan dari kanan ke kiri dengan nilai awal di sebelah kanan dan menghitung a op (b op (c op z)). Metode ini cocok untuk membangun list sambil mempertahankan urutan, tetapi dapat menyebabkan luapan pada list yang panjang.

Nilai awal menentukan jenis hasil, sehingga fold dapat mengubah koleksi menjadi nilai apa pun.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “foldLeft dan foldRight” gratis?

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

Ringkas koleksi menjadi sebuah nilai. 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 “foldLeft dan foldRight” 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