Scala for Backend Engineering & Functional Programming · Pelajaran

Folding dan Reducing

foldLeft dan reduce.

Pelajaran 3 dari 413 langkah

Folding dan Reducing 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.

Menggabungkan elemen menjadi satu

Terkadang Anda perlu menggabungkan semua elemen dalam koleksi menjadi satu nilai, seperti jumlah atau penggabungan. Scala menyediakan fold, foldLeft, foldRight, dan reduce untuk keperluan ini.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    println(nums.sum)
    println(nums.product)
  }
}

reduce: menggabungkan tanpa nilai awal

reduce menggabungkan elemen secara berpasangan menggunakan fungsi biner. Fungsi ini memerlukan setidaknya satu elemen; jika tidak, pengecualian akan terjadi.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val total = nums.reduce((a, b) => a + b)
    println(total)
    val max = nums.reduce((a, b) => if (a > b) a else b)
    println(max)
  }
}

foldLeft: menggabungkan dengan nilai awal

foldLeft menerima nilai awal dan sebuah fungsi. Fungsi ini aman digunakan pada koleksi kosong (mengembalikan nilai awal) dan memungkinkan tipe hasil berbeda dari tipe elemen.

Sintaks: xs.foldLeft(seed)((acc, x) => ...).

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val sum = nums.foldLeft(0)((acc, x) => acc + x)
    println(sum)
    val empty = List.empty[Int].foldLeft(0)(_ + _)
    println(empty)
  }
}

Pola akumulator

Dalam operasi fold, argumen pertama adalah akumulator yang menyimpan hasil sementara, sedangkan argumen kedua adalah elemen saat ini. Pada setiap langkah, akumulator diperbarui.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("Scala", "is", "great")
    val sentence = words.foldLeft("")((acc, w) => acc + w + " ")
    println(sentence.trim)
  }
}

Tipe hasil dapat berbeda

Salah satu fitur hebat foldLeft adalah tipe akumulator dapat berbeda dari tipe elemen. Di sini, kita melipat daftar angka menjadi sebuah String.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3)
    val joined = nums.foldLeft("nums:")((acc, n) => acc + " " + n)
    println(joined)
  }
}

foldRight: dari kanan

foldRight memproses elemen dari kanan ke kiri. Akumulator adalah argumen kedua: (x, acc) => .... Arah pemrosesan penting untuk operasi yang tidak komutatif.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val left = nums.foldLeft("")((acc, x) => acc + x)
    val right = nums.foldRight("")((x, acc) => acc + x)
    println("foldLeft:  " + left)
    println("foldRight: " + right)
  }
}

Kiri vs kanan dan performa

foldLeft bersifat rekursif ekor dan aman bagi tumpukan pada daftar besar. foldRight pada sebuah List dapat menyebabkan luapan tumpukan untuk masukan yang sangat besar. Pilihlah foldLeft kecuali urutan pemrosesan mengharuskan sebaliknya.

object Main {
  def main(args: Array[String]): Unit = {
    val big = (1 to 100000).toList
    val total = big.foldLeft(0L)((acc, x) => acc + x)
    println(total)
  }
}

Membangun koleksi dengan fold

Operasi fold cukup umum untuk membangun koleksi. Di sini, kita membalik daftar dengan menambahkan setiap elemen ke bagian depan daftar akumulator.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val reversed = nums.foldLeft(List.empty[Int])((acc, x) => x :: acc)
    println(reversed)
  }
}

reduceOption untuk keamanan

Karena reduce gagal pada koleksi kosong, reduceOption mengembalikan sebuah Option: Some(result) jika tidak kosong, dan None jika kosong.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(3, 1, 4).reduceOption(_ + _))
    println(List.empty[Int].reduceOption(_ + _))
  }
}

fold: varian simetris

fold mirip dengan foldLeft, tetapi akumulator harus memiliki tipe yang sama dengan elemen. Operasi ini sering digunakan bersama koleksi paralel.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val total = nums.fold(0)(_ + _)
    println(total)
  }
}

Menghitung dengan foldLeft

Operasi fold dapat menghitung hasil yang lebih kaya, seperti menghitung jumlah elemen yang memenuhi suatu kondisi, semuanya dalam satu kali lintasan.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(4, 7, 2, 9, 6, 1)
    val evenCount = nums.foldLeft(0)((acc, x) => if (x % 2 == 0) acc + 1 else acc)
    println(s"even numbers: $evenCount")
  }
}

Pemeriksaan Singkat

Apa perbedaan utama antara reduce dan foldLeft?

Jawab di pelajaran interaktif

Ringkasan

Anda telah mempelajari operasi folding dan reducing:

reduce — menggabungkan secara berpasangan, tanpa nilai awal, gagal jika kosong
reduceOption — varian aman yang mengembalikan Option
foldLeft — nilai awal + akumulator, aman bagi tumpukan, tipe hasil fleksibel
foldRight — dari kanan ke kiri, perhatikan tumpukan pada daftar besar
Operasi fold bahkan dapat membangun koleksi baru

Gratis untuk memulai

Belajar Scala dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 143

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Folding dan Reducing” gratis?

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

foldLeft dan reduce. 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 “Folding dan Reducing” 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