Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

reduce dan aggregate

Cara lain untuk menggabungkan elemen.

Pelajaran 4 daripada 413 langkah

reduce dan aggregate ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Daripada Fold kepada Reduce

Kadangkala anda mahu menggabungkan elemen tanpa memberikan nilai benih yang berasingan.

reduce menggunakan elemen pertama sebagai pengumpul permulaan dan menggabungkan elemen selebihnya ke dalamnya.

Ia ialah saudara fold yang lebih ringkas untuk keadaan apabila jenis elemen dan jenis hasil adalah sama.

Asas reduce

reduce menerima fungsi perduaan (a, b) dan melipatnya merentasi koleksi tanpa nilai awal yang dinyatakan secara jelas.

Untuk jumlah, ia hanya menambahkan semua elemen bersama-sama.

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

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

Perangkap Koleksi Kosong

Oleh sebab reduce tidak mempunyai benih, memanggilnya pada koleksi kosong akan melontarkan UnsupportedOperationException.

fold dan foldLeft selamat digunakan pada koleksi kosong kerana kedua-duanya kembali kepada benih yang diberikan.

Gunakan reduce hanya apabila anda pasti koleksi itu tidak kosong.

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

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

reduceOption untuk Keselamatan

reduceOption mengembalikan Option, dengan nilai None untuk koleksi kosong dan bukannya melontarkan ralat.

Inilah cara yang selamat untuk melakukan reduce apabila koleksi mungkin 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 mempunyai variasi berarah.

reduceLeft menggabungkan dari kiri ke kanan, manakala reduceRight dari kanan ke kiri. reduce biasa tidak menjamin susunan untuk koleksi selari, jadi gunakan variasi yang jelas apabila 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 Wujud

fold dan reduce memerlukan jenis penumpuk dan elemen mempunyai hubungan yang mudah.

aggregate ialah lipatan paling umum: ia membolehkan penumpuk mempunyai jenis yang berbeza DAN memberitahu Scala cara menggabungkan penumpuk separa, yang penting untuk pemprosesan selari.

Tandatangan aggregate

aggregate menerima nilai awal, operasi urutan yang melipat elemen ke dalam penumpuk, dan operasi gabungan yang menggabungkan dua penumpuk.

Pada koleksi berjujukan, operasi gabungan jarang digunakan; pada koleksi selari, operasi ini menggabungkan hasil setiap bahagian.

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 Jenis Berbeza

Di sini, aggregate melipat senarai perkataan menjadi jumlah panjang tunggal berjenis Int.

Operasi urutan menambah panjang setiap perkataan, manakala operasi gabungan menjumlahkan dua jumlah separa.

Jenis penumpuk (Int) berbeza daripada jenis 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

Pengagregatan Selari

Kuasa sebenar aggregate terserlah dengan koleksi selari.

Setiap bebenang melipat bahagiannya sendiri menggunakan operasi urutan, kemudian bahagian-bahagian itu digabungkan menggunakan operasi gabungan. Kedua-dua fungsi ini membolehkan Scala membahagi dan menyatukan semula kerja dengan selamat.

// 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 apabila jenis hasil sama dengan jenis elemen dan penggabungan bersifat asosiatif.

Gunakan foldLeft apabila anda memerlukan nilai awal atau jenis hasil yang berbeza secara berjujukan.

Gunakan aggregate apabila jenis penumpuk dan elemen berbeza serta anda mahukan penggabungan yang sesuai untuk pemprosesan selari.

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

Menggabungkan dalam Satu Lintasan

aggregate boleh mengira beberapa perkara serentak dengan mengumpulkan hasil ke dalam tupel.

Di sini kita memperoleh jumlah dan kiraan dalam satu lintasan, dengan menggabungkan tupel dalam operasi gabungan.

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)

Semakan Pantas

Tentukan operasi yang paling selamat untuk senarai yang mungkin kosong.

Jawab dalam pelajaran interaktif

Imbas Kembali

reduce menggabungkan elemen tanpa nilai awal dengan menggunakan elemen pertama sebagai permulaan; ia melontarkan ralat untuk koleksi kosong, manakala reduceOption mengembalikan None.

aggregate ialah lipatan paling umum: nilai awal, operasi urutan untuk melipat elemen, dan operasi gabungan untuk menggabungkan penumpuk separa bagi kerja selari.

Pilih reduce untuk penggabungan asosiatif dengan jenis yang sama, foldLeft untuk lipatan berjujukan dengan nilai awal, dan aggregate apabila jenis berbeza atau anda menggunakan pemprosesan selari.

Percuma untuk bermula

Pelajari Scala dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 143

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “reduce dan aggregate” percuma?

Ya — teks penuh “reduce dan aggregate” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “reduce dan aggregate”?

Cara lain untuk menggabungkan elemen. Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “reduce dan aggregate” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?

Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian