0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Fungsi Orde Tinggi & Kari

Jelajahi konsep fungsional tingkat lanjut seperti fungsi orde tinggi dan kari untuk membuat kode yang fleksibel serta dapat digunakan kembali.

Fungsi Orde Tinggi & Kari adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. 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 3 pelajaran total.

Membuka Fungsi Orde Tinggi

Selamat datang di Pelajaran 2! Dalam pemrograman fungsional, fungsi sangatlah kuat. Fungsi bukan hanya digunakan untuk menghitung nilai; fungsi juga dapat diperlakukan seperti data lainnya.

Artinya, fungsi dapat diteruskan sebagai argumen ke fungsi lain, atau bahkan dikembalikan sebagai hasil. Ketika sebuah fungsi melakukan hal ini, fungsi tersebut disebut Fungsi Orde Tinggi (HOF).

  • HOF menerima satu atau beberapa fungsi sebagai argumen.
  • HOF mengembalikan sebuah fungsi sebagai hasil.
  • Atau melakukan keduanya!

HOF Beraksi: `map`

Salah satu HOF yang paling umum di Scala adalah map. HOF ini mengubah setiap elemen dalam koleksi dengan menerapkan fungsi tertentu padanya, lalu mengembalikan koleksi baru.

Cobalah menjalankan contoh sederhana ini:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    val doubledNumbers = numbers.map(x => x * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubledNumbers")
  }
}

HOF Beraksi: `filter`

HOF lain yang berguna adalah filter. HOF ini memilih elemen dari koleksi yang memenuhi kondisi tertentu (fungsi yang mengembalikan nilai boolean), lalu membuat koleksi baru.

Berikut cara menggunakan filter untuk menemukan bilangan genap:

object Main {
  def main(args: Array[String]): Unit = {
    val allNumbers = List(1, 2, 3, 4, 5, 6)
    val evenNumbers = allNumbers.filter(x => x % 2 == 0)
    println(s"All: $allNumbers")
    println(s"Even: $evenNumbers")
  }
}

Mendefinisikan HOF Anda Sendiri

Anda tidak terbatas pada HOF bawaan! Anda dapat mendefinisikan fungsi sendiri yang menerima fungsi lain sebagai parameter. Sintaks untuk jenis fungsi adalah (InputType => ReturnType).

Contoh ini mendefinisikan fungsi applyOperation yang menerima sebuah Int dan fungsi lain bernama op (yang menerima sebuah Int dan mengembalikan sebuah Int).

object Main {
  // A HOF that applies an operation to a number
  def applyOperation(x: Int, op: Int => Int): Int = {
    op(x)
  }

  def main(args: Array[String]): Unit = {
    val result = applyOperation(10, _ * 3) // Pass an anonymous function
    println(s"Result of 10 * 3: $result")

    val anotherResult = applyOperation(7, _ + 5)
    println(s"Result of 7 + 5: $anotherResult")
  }
}

Fungsi Anonim & Singkatan

Saat meneruskan fungsi ke HOF, Anda sering menggunakan fungsi anonim (yang juga disebut lambda). Scala menyediakan cara ringkas untuk menuliskannya.

  • x => x * 2: Fungsi anonim lengkap.
  • _ * 2: Singkatan untuk fungsi anonim dengan satu parameter.

Keduanya umum digunakan dan membuat kode Anda lebih pendek serta mudah dibaca.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(10, 20, 30)

    // Using full anonymous function syntax
    val dividedByTwo = numbers.map(x => x / 2)
    println(s"Divided by two: $dividedByTwo")

    // Using shorthand `_` syntax
    val plusOne = numbers.map(_ + 1)
    println(s"Plus one: $plusOne")
  }
}

Memperkenalkan Currying

Currying adalah teknik yang mengubah fungsi yang menerima beberapa argumen menjadi rangkaian fungsi, yang masing-masing menerima satu argumen.

Teknik ini dinamai menurut ahli logika Haskell Curry. Di Scala, fungsi dengan beberapa daftar parameter secara otomatis menggunakan currying.

Alih-alih menulis f(arg1, arg2), Anda menulis f(arg1)(arg2).

Contoh Currying: Daftar Parameter Multipel

Mari kita lihat currying beraksi. Perhatikan bahwa add menerima argumennya dalam dua daftar parameter yang terpisah.

Hal ini memungkinkan Anda menerapkan fungsi secara parsial, dengan membuat fungsi baru setelah menetapkan beberapa argumen.

object Main {
  // A curried function with two parameter lists
  def add(a: Int)(b: Int): Int = {
    a + b
  }

  def main(args: Array[String]): Unit = {
    // Call the function normally
    println(s"5 + 3 = ${add(5)(3)}")

    // Partially apply the first argument
    val addFive = add(5)_ // `_` tells Scala to treat it as a partially applied function
    println(s"5 + 10 = ${addFive(10)}")
    println(s"5 + 20 = ${addFive(20)}")
  }
}

Manfaat Currying

Mengapa menggunakan currying? Teknik ini menawarkan beberapa keuntungan dalam pemrograman fungsional:

  • Penerapan Parsial: Buat versi khusus dari suatu fungsi dengan menetapkan beberapa argumen. Ini meningkatkan penggunaan ulang kode.
  • Komposisi Fungsi: Fungsi yang menggunakan currying sering kali lebih mudah dikomposisikan dengan fungsi lain.
  • Inferensi Jenis: Terkadang dapat membantu inferensi jenis Scala, terutama saat bekerja dengan jenis generik yang kompleks.

Currying untuk Pencatat Khusus

Bayangkan Anda ingin membuat fungsi pencatatan yang berbeda untuk berbagai tingkat (misalnya, INFO dan ERROR), tetapi tetap menggunakan logika inti yang sama. Currying sangat cocok untuk ini!

Anda dapat mendefinisikan fungsi umum log, lalu menerapkannya secara parsial untuk membuat pencatat tertentu.

object Main {
  def log(level: String)(message: String): Unit = {
    println(s"[$level] $message")
  }

  def main(args: Array[String]): Unit = {
    // Create specialized loggers using partial application
    val infoLogger = log("INFO")_
    val errorLogger = log("ERROR")_

    infoLogger("User logged in successfully.")
    errorLogger("Failed to connect to database!")
  }
}

Pemeriksaan Singkat: HOF dan Currying

Perhatikan potongan kode Scala berikut:

def calculate(x: Int)(y: Int, op: (Int, Int) => Int): Int = {
  op(x, y)
}

val add = (a: Int, b: Int) => a + b
val multiply = (a: Int, b: Int) => a * b

val result1 = calculate(10)(5, add)
val result2 = calculate(2)(3, multiply)

Berapakah nilai result1 dan result2?

Ringkasan: HOF dan Currying

Bagus! Anda telah mempelajari dua konsep penting dalam pemrograman fungsional:

  • Fungsi Orde Tinggi (HOF): Fungsi yang dapat menerima fungsi lain sebagai argumen atau mengembalikannya sebagai hasil. Fungsi ini memungkinkan kode yang fleksibel dan dapat digunakan kembali, seperti map dan filter.
  • Currying: Teknik untuk mengubah fungsi dengan beberapa argumen menjadi rangkaian fungsi, yang masing-masing menerima satu argumen. Teknik ini sangat baik untuk penerapan parsial dan pembuatan fungsi khusus.

Konsep-konsep ini merupakan dasar untuk menulis kode Scala yang ekspresif dan modular!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Fungsi Orde Tinggi & Kari” gratis?

Ya — teks lengkap “Fungsi Orde Tinggi & Kari” 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 3 pelajaran total.

Apa yang akan aku pelajari di “Fungsi Orde Tinggi & Kari”?

Jelajahi konsep fungsional tingkat lanjut seperti fungsi orde tinggi dan kari untuk membuat kode yang fleksibel serta dapat digunakan kembali. 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 2 dari 3.

Berapa lama pelajaran “Fungsi Orde Tinggi & Kari” 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

  1. Fungsi sebagai Nilai Kelas Utama
  2. Fungsi Orde Tinggi & Kari
  3. Imutabilitas dan Efek Samping
← Kembali ke Scala for Backend Engineering & Functional Programming