Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Pelipatan dan Pengurangan

foldLeft dan reduce

Pelajaran 3 daripada 413 langkah

Pelipatan dan Pengurangan ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 3 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.

Menggabungkan unsur menjadi satu

Kadangkala anda perlu menggabungkan semua unsur dalam koleksi menjadi satu nilai, seperti jumlah atau percantuman. Scala menyediakan fold, foldLeft, foldRight, dan reduce untuk tujuan ini.

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

reduce: gabung tanpa nilai awal

reduce menggabungkan unsur secara berpasangan menggunakan fungsi binari. Ia memerlukan sekurang-kurangnya satu unsur; jika tidak, ia akan menghasilkan pengecualian.

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: gabung dengan nilai awal

foldLeft menerima nilai awal dan satu fungsi. Ia selamat digunakan pada koleksi kosong (mengembalikan nilai awal) dan membenarkan jenis hasil berbeza daripada jenis unsur.

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)
  }
}

Corak penumpuk

Dalam operasi lipatan, argumen pertama ialah penumpuk yang membawa hasil semasa, manakala argumen kedua ialah unsur semasa. Setiap langkah mengemas kini penumpuk.

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)
  }
}

Jenis hasil boleh berbeza

Satu ciri berkuasa foldLeft: jenis penumpuk boleh berbeza daripada jenis unsur. Di sini, kita melipat senarai nombor menjadi 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 unsur dari kanan ke kiri. Penumpuk ialah argumen kedua: (x, acc) => .... Arah 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 berbanding kanan dan prestasi

foldLeft menggunakan rekursi ekor dan selamat untuk tindanan pada senarai besar. foldRight pada List boleh menyebabkan limpahan tindanan untuk input yang sangat besar. Utamakan foldLeft kecuali susunan memerlukan 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)
  }
}

Membina koleksi dengan fold

Operasi lipatan cukup umum untuk membina koleksi. Di sini, kita menterbalikkan senarai dengan menambah setiap unsur di hadapan senarai penumpuk.

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 keselamatan

Memandangkan reduce gagal pada koleksi kosong, reduceOption mengembalikan Option sebagai gantinya: Some(result) apabila tidak kosong, dan None apabila kosong.

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

fold: varian simetri

fold menyerupai foldLeft, tetapi penumpuk mestilah daripada jenis yang sama dengan unsur. Ia sering digunakan dengan koleksi selari.

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

Mengira dengan foldLeft

Operasi lipatan boleh mengira hasil yang lebih kompleks, seperti bilangan unsur yang memenuhi suatu syarat, semuanya dalam satu laluan.

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")
  }
}

Semakan Pantas

Apakah perbezaan utama antara reduce dengan foldLeft?

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari operasi lipatan dan pengurangan:

reduce — menggabungkan secara berpasangan, tanpa nilai awal, gagal jika kosong
reduceOption — varian selamat yang mengembalikan Option
foldLeft — nilai awal + penumpuk, selamat untuk tindanan, jenis hasil yang fleksibel
foldRight — dari kanan ke kiri, awasi tindanan pada senarai besar
Operasi lipatan juga boleh membina koleksi baharu

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 “Pelipatan dan Pengurangan” percuma?

Ya — teks penuh “Pelipatan dan Pengurangan” 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 “Pelipatan dan Pengurangan”?

foldLeft dan reduce 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 3 daripada 4.

Berapa lamakah pelajaran “Pelipatan dan Pengurangan” 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