Scala for Backend Engineering & Functional Programming · Pelajaran

Pola Akumulator

Ubah menjadi rekursi ekor.

Pola Akumulator 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.

Pola Akumulator

Pola akumulator mengubah fungsi non-rekursif-ekor menjadi fungsi rekursif-ekor. Anda membawa hasil sementara dalam parameter tambahan (yaitu akumulator), bukan membangunnya setelah pemanggilan selesai.

Gagasan Inti

Alih-alih menggunakan n + sum(n-1) (pekerjaan setelah pemanggilan), Anda menghitung total sementara baru sebelum pemanggilan: sum(n-1, acc + n). Kini pemanggilan rekursif menjadi tindakan terakhir.

Sebelum: Jumlah Non-Ekor

Versi langsung ini bukan rekursif-ekor: penjumlahan menunggu pemanggilan rekursif.

object Main {
  def sum(n: Int): Int =
    if (n == 0) 0 else n + sum(n - 1)

  def main(args: Array[String]): Unit = {
    println(sum(50))
  }
}

Sesudah: Jumlah Ekor dengan Akumulator

Tambahkan parameter acc yang menyimpan total berjalan. Kini pemanggilan rekursif berada dalam posisi ekor dan dapat dioptimalkan.

import scala.annotation.tailrec

object Main {
  @tailrec
  def sum(n: Int, acc: Int = 0): Int =
    if (n == 0) acc else sum(n - 1, acc + n)

  def main(args: Array[String]): Unit = {
    println(sum(50))
  }
}

Faktorial Rekursif-Ekor

Terapkan transformasi yang sama pada faktorial: kalikan ke dalam akumulator sebelum melakukan rekursi.

import scala.annotation.tailrec

object Main {
  @tailrec
  def factorial(n: Int, acc: Long = 1): Long =
    if (n <= 1) acc else factorial(n - 1, acc * n)

  def main(args: Array[String]): Unit = {
    println(factorial(10))
  }
}

Menyembunyikan Akumulator

Parameter tambahan merupakan detail implementasi. Bungkus pekerja rekursif-ekor dalam fungsi publik yang bersih agar pemanggil tidak melihat acc.

import scala.annotation.tailrec

object Main {
  def factorial(n: Int): Long = {
    @tailrec
    def loop(m: Int, acc: Long): Long =
      if (m <= 1) acc else loop(m - 1, acc * m)
    loop(n, 1)
  }

  def main(args: Array[String]): Unit = {
    println(factorial(6))
  }
}

Mengakumulasikan Daftar

Pola ini juga dapat membangun koleksi. Pembalikan rekursif-ekor menambahkan setiap kepala ke bagian depan daftar akumulator.

import scala.annotation.tailrec

object Main {
  def reverse[A](xs: List[A]): List[A] = {
    @tailrec
    def loop(rem: List[A], acc: List[A]): List[A] = rem match {
      case Nil    => acc
      case h :: t => loop(t, h :: acc)
    }
    loop(xs, Nil)
  }

  def main(args: Array[String]): Unit = {
    println(reverse(List(1, 2, 3, 4)))
  }
}

Urutan Akumulasi

Perhatikan bahwa menambahkan elemen ke bagian depan akumulator secara alami membalik urutan. Untuk fungsi pembangun daftar yang mempertahankan urutan, Anda biasanya membangun daftar dalam keadaan terbalik lalu membaliknya di akhir, atau menggunakan struktur penambahan yang efisien.

map Rekursif-Ekor

Bangun daftar hasil dengan akumulator, lalu balikkan sekali di akhir untuk memulihkan urutan.

import scala.annotation.tailrec

object Main {
  def mapTail[A, B](xs: List[A])(f: A => B): List[B] = {
    @tailrec
    def loop(rem: List[A], acc: List[B]): List[B] = rem match {
      case Nil    => acc.reverse
      case h :: t => loop(t, f(h) :: acc)
    }
    loop(xs, Nil)
  }

  def main(args: Array[String]): Unit = {
    println(mapTail(List(1, 2, 3))(_ * 10))
  }
}

Hubungan dengan foldLeft

Pola akumulator persis seperti yang digeneralisasikan oleh foldLeft: pola tersebut meneruskan akumulator melalui koleksi secara rekursif-ekor. Banyak fungsi akumulator manual dapat ditulis ulang sebagai satu foldLeft.

@main def run(): Unit = {
  val total = List(1, 2, 3, 4).foldLeft(0)(_ + _)
  println(total)
}

Kapan Menggunakannya

Gunakan pola akumulator ketika fungsi rekursif memproses struktur linear yang besar dan jika tidak, akan menyebabkan luapan tumpukan. Pola ini menukar bentuk yang sedikit kurang jelas dengan keamanan tumpukan yang terjamin.

Pemeriksaan Singkat

Uji pemahaman Anda tentang pola akumulator.

Ringkasan

Anda telah mempelajari pola akumulator:

Bawa hasil sementara dalam parameter tambahan.
Hitung hasil tersebut sebelum melakukan rekursi agar mencapai posisi ekor.
Sembunyikan akumulator di balik fungsi publik yang bersih.
Pola ini digeneralisasikan oleh foldLeft.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola Akumulator” gratis?

Ya — teks lengkap “Pola Akumulator” 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 “Pola Akumulator”?

Ubah menjadi rekursi ekor. 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 “Pola Akumulator” 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