Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Komposisi

andThen dan compose

Pelajaran 3 daripada 413 langkah

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

Komposisi fungsi bermaksud membina fungsi baharu dengan menyambungkan dua fungsi sedia ada, supaya output satu fungsi menjadi input fungsi seterusnya. Scala menyediakan andThen dan compose untuk tujuan 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: kiri ke kanan

f andThen g menjalankan f dahulu, kemudian g. Membaca dari kiri ke kanan sepadan dengan turutan pelaksanaan, yang dianggap intuitif oleh ramai 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: kanan ke kiri

f compose g menjalankan g dahulu, kemudian f, iaitu turutan matematik 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 berbanding compose

Kedua-duanya ialah imej cermin:

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

Pilih yang lebih semula jadi untuk dibaca dalam 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))
  }
}

Merantaikan beberapa fungsi

Anda boleh merantaikan banyak fungsi dengan mengulang andThen untuk membina saluran paip 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 jenis

Fungsi yang dikomposisikan memerlukan jenis yang serasi: jenis output fungsi pertama mesti sepadan dengan jenis input fungsi kedua. Saluran paip boleh mengubah jenis 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 identiti

identity mengembalikan inputnya tanpa perubahan. Ia ialah unsur neutral bagi penggubahan: f andThen identity == f. Berguna sebagai nilai lalai dalam operasi lipatan dan syarat.

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

Menggubah dengan reduce

Memandangkan fungsi ialah nilai, Anda boleh menyimpan beberapa fungsi dalam senarai dan menggubah 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
  }
}

Membina saluran paip boleh guna semula

Penggubahan menggalakkan fungsi kecil yang mempunyai satu tujuan, yang kemudiannya Anda susun untuk membentuk tingkah laku yang lebih besar, iaitu idea penting dalam pengaturcaraan berfungsi.

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

Penggubahan dengan map

Fungsi yang telah digubah tetap merupakan fungsi, jadi Anda boleh terus menghantarnya kepada map untuk menggunakan seluruh saluran paip pada sesuatu 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 tertib penggubahan dengan teliti

Ralat yang biasa berlaku ialah kekeliruan antara andThen dengan compose. Sentiasa ingat: andThen = mula-mula yang ini, kemudian yang 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
  }
}

Semakan Pantas

Diberikan f dan g, apakah yang dikira oleh (f andThen g)(x)?

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari penggubahan fungsi:

f andThen g → g(f(x)) (kiri ke kanan)
f compose g → f(g(x)) (kanan ke kiri)
Kedua-duanya ialah imej cermin antara satu sama lain
identity ialah unsur neutral
Gubah senarai fungsi dengan reduce(_ andThen _)

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 “Komposisi” percuma?

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

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