Scala for Backend Engineering & Functional Programming · Pelajaran

Komposisi

andThen dan compose.

Komposisi 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 fungsi

Komposisi fungsi berarti membangun fungsi baru dengan menghubungkan dua fungsi yang sudah ada, sehingga keluaran salah satunya menjadi masukan bagi fungsi berikutnya. Scala menyediakan andThen dan compose untuk keperluan ini.

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val double = (x: Int) => x * 2
    val both = addOne andThen double
    println(both(5))
  }
}

andThen: dari kiri ke kanan

f andThen g menjalankan f terlebih dahulu, lalu g. Pembacaan dari kiri ke kanan sesuai dengan urutan eksekusi, yang dianggap intuitif oleh banyak orang.

(f andThen g)(x) == g(f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne andThen triple
    println(pipeline(4))  // (4 + 1) * 3
  }
}

compose: dari kanan ke kiri

f compose g menjalankan g terlebih dahulu, lalu f, sesuai urutan matematis f(g(x)).

(f compose g)(x) == f(g(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne compose triple
    println(pipeline(4))  // (4 * 3) + 1
  }
}

andThen vs compose

Keduanya merupakan cerminan satu sama lain:

f andThen g = g compose f
f compose g = g andThen f

Pilihlah yang lebih alami dibaca sesuai situasi Anda.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x + 10
    val g = (x: Int) => x * 2
    println((f andThen g)(3))
    println((g compose f)(3))
  }
}

Merangkai beberapa fungsi

Anda dapat merangkai banyak fungsi dengan mengulangi andThen untuk membangun alur pemrosesan yang lebih panjang dan mengalir dari atas ke bawah.

object Main {
  def main(args: Array[String]): Unit = {
    val clean = (s: String) => s.trim
    val lower = (s: String) => s.toLowerCase
    val bang  = (s: String) => s + "!"
    val process = clean andThen lower andThen bang
    println(process("  HELLO  "))
  }
}

Komposisi mengubah tipe

Fungsi-fungsi yang dikomposisikan harus memiliki tipe yang kompatibel: tipe keluaran fungsi pertama harus cocok dengan tipe masukan fungsi kedua. Alur pemrosesan dapat mengubah tipe di sepanjang proses.

object Main {
  def main(args: Array[String]): Unit = {
    val length = (s: String) => s.length
    val isLong = (n: Int) => n > 5
    val check = length andThen isLong
    println(check("scala"))
    println(check("functional"))
  }
}

Fungsi identitas

identity mengembalikan input-nya tanpa perubahan. Ini adalah elemen netral dalam komposisi: f andThen identity == f. Berguna sebagai nilai bawaan dalam pelipatan dan kondisional.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x * 2
    val same = f andThen identity[Int]
    println(same(7))
  }
}

Menyusun dengan reduce

Karena fungsi adalah nilai, Anda dapat menyimpan beberapa fungsi dalam sebuah daftar lalu menyusunnya semuanya menggunakan reduce dengan andThen.

object Main {
  def main(args: Array[String]): Unit = {
    val steps: List[Int => Int] = List(_ + 1, _ * 2, _ - 3)
    val pipeline = steps.reduce(_ andThen _)
    println(pipeline(5))  // ((5+1)*2)-3
  }
}

Membangun pipeline yang dapat digunakan kembali

Komposisi mendorong penggunaan fungsi-fungsi kecil dengan satu tujuan, yang kemudian Anda rangkai menjadi perilaku yang lebih besar. Ini adalah gagasan penting dalam pemrograman fungsional.

object Main {
  def main(args: Array[String]): Unit = {
    val sanitize = (s: String) => s.trim.toLowerCase
    val capitalize = (s: String) => s.capitalize
    val format = sanitize andThen capitalize
    println(format("  aLiCe "))
  }
}

Komposisi dengan map

Fungsi hasil komposisi tetaplah sebuah fungsi, sehingga Anda dapat langsung meneruskannya ke map untuk menerapkan seluruh pipeline pada suatu koleksi.

object Main {
  def main(args: Array[String]): Unit = {
    val transform = ((x: Int) => x + 1) andThen ((x: Int) => x * x)
    println(List(1, 2, 3).map(transform))
  }
}

Membaca urutan komposisi dengan saksama

Kesalahan yang umum terjadi adalah tertukar antara andThen dan compose. Selalu ingat: andThen = pertama ini, lalu itu; compose = sebaliknya.

object Main {
  def main(args: Array[String]): Unit = {
    val inc = (x: Int) => x + 1
    val sqr = (x: Int) => x * x
    println((inc andThen sqr)(2))  // (2+1)^2 = 9
    println((inc compose sqr)(2))  // (2^2)+1 = 5
  }
}

Pemeriksaan singkat

Diberikan f dan g, apa yang dihitung oleh (f andThen g)(x)?

Rangkuman

Anda telah mempelajari komposisi fungsi:

f andThen g → g(f(x)) (dari kiri ke kanan)
f compose g → f(g(x)) (dari kanan ke kiri)
Keduanya merupakan cerminan satu sama lain
identity adalah elemen netral
Susun daftar fungsi dengan reduce(_ andThen _)

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Komposisi” gratis?

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

andThen dan compose. 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 “Komposisi” 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