Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Fungsi Aras Tinggi & Currying

Terokai konsep fungsian lanjutan seperti fungsi aras tinggi dan currying untuk mencipta kod yang fleksibel serta boleh diguna semula.

Pelajaran 2 daripada 311 langkah

Fungsi Aras Tinggi & Currying ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 2 daripada 3. 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 3 pelajaran.

Membuka Fungsi Tahap Tinggi

Selamat datang ke Pelajaran 2! Dalam pengaturcaraan berfungsi, fungsi sangat berkuasa. Fungsi bukan sekadar digunakan untuk mengira nilai; fungsi juga boleh dianggap seperti mana-mana data lain.

Ini bermakna fungsi boleh dihantar sebagai argumen kepada fungsi lain, malah boleh dikembalikan sebagai hasil daripadanya. Apabila fungsi melakukan perkara ini, fungsi itu dipanggil Fungsi Tahap Tinggi (HOF).

HOF menerima satu atau lebih fungsi sebagai argumen.
HOF mengembalikan fungsi sebagai hasil.
Atau kedua-duanya!

HOF dalam Tindakan: `map`

Salah satu HOF yang paling biasa dalam Scala ialah map. Fungsi ini mengubah setiap elemen dalam koleksi dengan menggunakan fungsi yang diberikan padanya, lalu mengembalikan koleksi baharu.

Cuba jalankan contoh mudah 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 dalam Tindakan: `filter`

Satu lagi HOF yang berguna ialah filter. Fungsi ini memilih elemen daripada koleksi yang memenuhi syarat tertentu (fungsi yang mengembalikan nilai boolean), lalu menghasilkan koleksi baharu.

Beginilah cara anda boleh menggunakan filter untuk mencari nombor 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")
  }
}

Mentakrifkan HOF Anda Sendiri

Anda tidak terhad kepada HOF terbina dalam! Anda boleh mentakrifkan fungsi sendiri yang menerima fungsi lain sebagai parameter. Sintaks untuk jenis fungsi ialah (InputType => ReturnType).

Contoh ini mentakrifkan fungsi applyOperation yang menerima satu Int dan satu lagi fungsi op (yang menerima satu Int dan mengembalikan satu 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 Tanpa Nama & Bentuk Ringkas

Apabila menghantar fungsi kepada HOF, anda sering menggunakan fungsi tanpa nama (juga dipanggil lambda). Scala menyediakan cara yang ringkas untuk menulisnya.

x => x * 2: Fungsi tanpa nama penuh.
_ * 2: Bentuk ringkas untuk fungsi tanpa nama dengan satu parameter.

Kedua-duanya lazim digunakan dan menjadikan kod 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 ialah teknik yang mengubah fungsi yang menerima berbilang argumen kepada urutan fungsi, dengan setiap fungsi menerima satu argumen.

Istilah ini dinamakan sempena ahli logik Haskell Curry. Dalam Scala, fungsi dengan berbilang senarai parameter akan melalui proses currying secara automatik.

Daripada f(arg1, arg2), anda menulis f(arg1)(arg2).

Contoh Currying: Senarai Parameter Berbilang

Mari lihat currying dalam tindakan. Perhatikan bahawa add menerima argumennya dalam dua senarai parameter yang berasingan.

Ini membolehkan anda menggunakan fungsi secara separa, lalu mencipta fungsi baharu dengan menetapkan sesetengah 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)}")
  }
}

Kelebihan Currying

Mengapa menggunakan currying? Teknik ini menawarkan beberapa kelebihan dalam pengaturcaraan berfungsi:

Penggunaan Separa: Cipta versi khusus sesuatu fungsi dengan menetapkan sesetengah argumen. Ini meningkatkan penggunaan semula kod.
Penggubahan Fungsi: Fungsi yang melalui currying selalunya lebih mudah digabungkan dengan fungsi lain.
Penaakulan Jenis: Kadangkala dapat membantu penaakulan jenis Scala, terutamanya apabila bekerja dengan jenis generik yang kompleks.

Currying untuk Pencatat Tersuai

Bayangkan anda mahu mencipta fungsi pencatatan yang berbeza untuk tahap yang berbeza (contohnya, INFO dan ERROR), tetapi masih menggunakan logik teras yang sama. Currying amat sesuai untuk tujuan ini!

Anda boleh mentakrifkan fungsi umum log, kemudian menggunakannya secara separa untuk mencipta pencatat khusus.

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

Semakan Pantas: HOF dan Currying

Pertimbangkan petikan kod 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)

Apakah nilai result1 dan result2?

Jawab dalam pelajaran interaktif

Imbas Kembali: HOF dan Currying

Syabas! Anda telah meneroka dua konsep penting dalam pengaturcaraan berfungsi:

Fungsi Tahap Tinggi (HOF): Fungsi yang boleh menerima fungsi lain sebagai argumen atau mengembalikannya sebagai hasil. Fungsi ini membolehkan kod yang fleksibel dan boleh digunakan semula, seperti map dan filter.
Currying: Teknik untuk mengubah fungsi dengan berbilang argumen kepada urutan fungsi, dengan setiap fungsi menerima satu argumen. Teknik ini sangat berguna untuk penggunaan separa dan penciptaan fungsi khusus.

Konsep-konsep ini merupakan asas untuk menulis kod Scala yang ekspresif dan modular!

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 “Fungsi Aras Tinggi & Currying” percuma?

Ya — teks penuh “Fungsi Aras Tinggi & Currying” 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 3 pelajaran.

Apakah yang akan saya pelajari dalam “Fungsi Aras Tinggi & Currying”?

Terokai konsep fungsian lanjutan seperti fungsi aras tinggi dan currying untuk mencipta kod yang fleksibel serta boleh diguna semula. 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 2 daripada 3.

Berapa lamakah pelajaran “Fungsi Aras Tinggi & Currying” 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