Scala for Backend Engineering & Functional Programming · Pelajaran

reduce dan aggregate

Cara lain untuk menggabungkan elemen.

reduce dan aggregate 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.

Dari Fold ke Reduce

Terkadang Anda ingin menggabungkan elemen tanpa memberikan nilai awal terpisah.

reduce menggunakan elemen pertama sebagai akumulator awal dan menggabungkan elemen lainnya ke dalamnya.

Ini adalah versi fold yang lebih ringkas untuk kasus ketika jenis elemen dan jenis hasilnya sama.

Dasar-dasar reduce

reduce menerima fungsi biner (a, b) dan menerapkannya di seluruh koleksi, tanpa nilai awal eksplisit.

Untuk penjumlahan, reduce cukup menjumlahkan semua elemen.

val xs = List(1, 2, 3, 4)
val total = xs.reduce((a, b) => a + b)

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

Jebakan Koleksi Kosong

Karena reduce tidak memiliki nilai awal, pemanggilannya pada koleksi kosong akan memunculkan UnsupportedOperationException.

fold dan foldLeft aman digunakan pada koleksi kosong karena keduanya menggunakan nilai awal yang diberikan.

Gunakan reduce hanya jika Anda mengetahui bahwa koleksinya tidak kosong.

// List.empty[Int].reduce(_ + _)
// throws UnsupportedOperationException

List.empty[Int].foldLeft(0)(_ + _)  // safe, returns 0

reduceOption untuk Keamanan

reduceOption mengembalikan sebuah Option, dengan None untuk koleksi kosong alih-alih menimbulkan pengecualian.

Ini adalah cara aman untuk melakukan reduce ketika ada kemungkinan koleksi kosong.

val xs = List(5, 9, 2)
val maybeMax = xs.reduceOption(_ max _)

@main def run(): Unit =
  println(maybeMax)  // Some(9)

reduceLeft dan reduceRight

Seperti fold, reduce memiliki varian berdasarkan arah.

reduceLeft menggabungkan dari kiri ke kanan, sedangkan reduceRight dari kanan ke kiri. reduce biasa tidak menjamin urutan untuk koleksi paralel, jadi gunakan varian eksplisit ketika arah penting.

val xs = List(1, 2, 3)
val l = xs.reduceLeft(_ - _)   // (1-2)-3 = -4
val r = xs.reduceRight(_ - _)  // 1-(2-3) = 2

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

Mengapa aggregate Ada

fold dan reduce mengharuskan tipe accumulator dan elemen memiliki hubungan yang sederhana.

aggregate adalah fold yang paling umum: Anda dapat menggunakan tipe accumulator yang berbeda DAN memberi tahu Scala cara menggabungkan accumulator parsial, yang penting untuk pemrosesan paralel.

Signature aggregate

aggregate menerima seed, seqop yang melipat elemen ke dalam accumulator, dan combop yang menggabungkan dua accumulator.

Pada koleksi berurutan, combop jarang digunakan; pada koleksi paralel, combop menggabungkan hasil dari setiap bagian.

val xs = List(1, 2, 3, 4)
val sum = xs.aggregate(0)(
  (acc, x) => acc + x,   // seqop
  (a, b)   => a + b      // combop
)

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

aggregate dengan Tipe Berbeda

Di sini aggregate melipat daftar kata menjadi total panjang bertipe Int.

seqop menambahkan panjang setiap kata, sedangkan combop menjumlahkan dua total parsial.

Tipe accumulator (Int) berbeda dari tipe elemen (String).

val words = List("hi", "there", "you")
val chars = words.aggregate(0)(
  (acc, w) => acc + w.length,
  (a, b)   => a + b
)

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

Agregasi Paralel

Kekuatan aggregate yang sebenarnya terlihat pada koleksi paralel.

Setiap thread melipat bagiannya sendiri dengan seqop, lalu bagian-bagian tersebut digabungkan dengan combop. Kedua fungsi ini memungkinkan Scala membagi dan menyatukan kembali pekerjaan dengan aman.

// Conceptual: par splits the work
// val n = data.par.aggregate(0)(_ + _.length, _ + _)
// seqop runs per chunk, combop merges chunk results

Memilih Alat yang Tepat

Gunakan reduce atau reduceOption ketika tipe hasil sama dengan tipe elemen dan penggabungannya bersifat asosiatif.

Gunakan foldLeft ketika Anda memerlukan seed atau tipe hasil yang berbeda secara berurutan.

Gunakan aggregate ketika tipe accumulator dan elemen berbeda dan Anda menginginkan penggabungan yang cocok untuk pemrosesan paralel.

// reduce:    same type, non-empty, associative
// foldLeft:  seed + different type, sequential
// aggregate: different type + parallel merge

Menggabungkan dalam Satu Lintasan

aggregate dapat menghitung beberapa hal sekaligus dengan mengakumulasi ke dalam tuple.

Di sini kita mendapatkan jumlah dan banyak elemen dalam satu lintasan, dengan menggabungkan tuple di combop.

val xs = List(2, 4, 6, 8)
val (s, c) = xs.aggregate((0, 0))(
  (acc, x) => (acc._1 + x, acc._2 + 1),
  (a, b)   => (a._1 + b._1, a._2 + b._2)
)

@main def run(): Unit = println((s, c))  // (20, 4)

Pemeriksaan Singkat

Tentukan operasi mana yang paling aman untuk daftar yang mungkin kosong.

Ringkasan

reduce menggabungkan elemen tanpa seed, dengan menggunakan elemen pertama sebagai awal; reduce menimbulkan pengecualian pada koleksi kosong, sedangkan reduceOption mengembalikan None.

aggregate adalah fold yang paling umum: seed, seqop untuk melipat elemen, dan combop untuk menggabungkan accumulator parsial dalam pekerjaan paralel.

Pilih reduce untuk penggabungan asosiatif dengan tipe yang sama, foldLeft untuk fold berurutan dengan seed, dan aggregate ketika tipenya berbeda atau Anda menggunakan pemrosesan paralel.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “reduce dan aggregate” gratis?

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

Cara lain untuk menggabungkan elemen. 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 “reduce dan aggregate” 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