0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

การทำเคอร์รี

การประยุกต์ใช้บางส่วน

การทำเคอร์รี เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

Currying คืออะไร

Currying คือการแปลงฟังก์ชันที่มีหลายอาร์กิวเมนต์ให้เป็นสายของฟังก์ชัน โดยแต่ละฟังก์ชันรับหนึ่งอาร์กิวเมนต์ ใน Scala เขียนโดยใช้รายการพารามิเตอร์หลายรายการ

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    println(add(3)(4))
  }
}

รายการพารามิเตอร์หลายรายการ

เมธอดแบบเคอร์รีมีรายการพารามิเตอร์หลายรายการ: def f(a: Int)(b: Int) คุณเรียกใช้โดยส่งแต่ละรายการตามลำดับ: f(1)(2)

object Main {
  def combine(prefix: String)(value: Int): String = s"$prefix$value"
  def main(args: Array[String]): Unit = {
    println(combine("id-")(42))
  }
}

การประยุกต์ใช้บางส่วน

คุณสามารถส่งรายการอาร์กิวเมนต์เพียงบางส่วน แล้วรับฟังก์ชันที่รออาร์กิวเมนต์ส่วนที่เหลือกลับมาได้ การทำเช่นนี้เรียกว่าการประยุกต์ใช้บางส่วน

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    val addFive = add(5) _
    println(addFive(10))
    println(addFive(20))
  }
}

การทำให้ฟังก์ชันทั่วไปมีความเฉพาะเจาะจง

การประยุกต์ใช้บางส่วนช่วยให้คุณสร้างฟังก์ชันเฉพาะทางจากฟังก์ชันทั่วไป และลดการเขียนซ้ำ

object Main {
  def power(exp: Int)(base: Int): Int = math.pow(base, exp).toInt
  def main(args: Array[String]): Unit = {
    val square = power(2) _
    val cube = power(3) _
    println(square(5))
    println(cube(2))
  }
}

การทำฟังก์ชันปกติให้เป็นแบบเคอร์รี

ค่าฟังก์ชันทั่วไปมีเมธอด .curried ที่แปลงฟังก์ชันให้เป็นรูปแบบเคอร์รี

object Main {
  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val curriedAdd = add.curried
    println(curriedAdd(3)(4))
  }
}

ย้อนกลับจากแบบเคอร์รี

ตัวช่วย Function.uncurried ย้อนกระบวนการดังกล่าว โดยเปลี่ยนฟังก์ชันแบบเคอร์รีกลับเป็นฟังก์ชันที่มีรายการพารามิเตอร์เดียว

object Main {
  def main(args: Array[String]): Unit = {
    val curried: Int => Int => Int = a => b => a + b
    val normal = Function.uncurried(curried)
    println(normal(3, 4))
  }
}

เหตุผลที่ Currying มีประโยชน์

Currying ช่วยให้ใช้ซ้ำได้ โดยกำหนดอาร์กิวเมนต์แรกไว้ครั้งเดียว แล้วเรียกผลลัพธ์ซ้ำหลายครั้งด้วยอาร์กิวเมนต์ที่เหลือแตกต่างกัน นอกจากนี้ยังช่วยให้คอมไพเลอร์อนุมานชนิดในรายการถัดไปได้

object Main {
  def discount(rate: Double)(price: Double): Double = price * (1 - rate)
  def main(args: Array[String]): Unit = {
    val blackFriday = discount(0.3) _
    println(blackFriday(100))
    println(blackFriday(250))
  }
}

การอนุมานชนิดในรายการสุดท้าย

เหตุผลเชิงปฏิบัติสำหรับการใช้รายการพารามิเตอร์หลายรายการคือ คอมไพเลอร์สามารถอนุมานชนิดพารามิเตอร์ของแลมบ์ดาจากรายการก่อนหน้าได้ คุณจึงละชนิดเหล่านั้นได้

object Main {
  def fold[A](xs: List[A])(init: A)(op: (A, A) => A): A =
    xs.foldLeft(init)(op)
  def main(args: Array[String]): Unit = {
    val total = fold(List(1, 2, 3))(0)((a, b) => a + b)
    println(total)
  }
}

Currying ด้วยสามรายการ

คุณสามารถมีรายการพารามิเตอร์ได้มากเท่าที่ต้องการ การเรียกแต่ละครั้งจะส่งหนึ่งรายการและคืนฟังก์ชันสำหรับรายการถัดไป

object Main {
  def make(a: Int)(b: Int)(c: Int): Int = a + b + c
  def main(args: Array[String]): Unit = {
    println(make(1)(2)(3))
    val step = make(10) _
    println(step(20)(30))
  }
}

การสร้างตัวตรวจสอบที่กำหนดค่าได้

การใช้งานจริงที่พบบ่อยคือ ทำกฎการตรวจสอบให้เป็นเคอร์รี กำหนดค่าขีดจำกัดไว้ แล้วนำเงื่อนไขที่ได้กลับมาใช้กับชุดข้อมูล

object Main {
  def atLeast(min: Int)(value: Int): Boolean = value >= min
  def main(args: Array[String]): Unit = {
    val adult = atLeast(18) _
    println(List(15, 21, 18, 12).map(adult))
  }
}

Currying เทียบกับการประยุกต์ใช้บางส่วน

Currying คือการแปลงโครงสร้างให้เป็นฟังก์ชันที่รับอาร์กิวเมนต์เดียว ส่วนการประยุกต์ใช้บางส่วนคือการส่งอาร์กิวเมนต์บางส่วนในตอนนี้ แล้วส่งส่วนที่เหลือในภายหลัง ฟังก์ชันแบบเคอร์รีทำให้การประยุกต์ใช้บางส่วนเป็นเรื่องธรรมชาติ

object Main {
  def greet(greeting: String)(name: String): String = s"$greeting, $name!"
  def main(args: Array[String]): Unit = {
    val sayHi = greet("Hi") _
    println(sayHi("Ann"))
    println(sayHi("Bob"))
  }
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

คุณกำหนดเมธอดแบบเคอร์รีใน Scala อย่างไร

สรุปทบทวน

คุณได้เรียนรู้ Currying และการประยุกต์ใช้บางส่วนแล้ว:

  • เมธอดแบบเคอร์รีใช้รายการพารามิเตอร์หลายรายการ: f(a)(b)
  • ประยุกต์ใช้บางส่วนด้วย f(x) _ เพื่อรับฟังก์ชันใหม่
  • .curried และ Function.uncurried ใช้แปลงรูปแบบ
  • ช่วยให้ใช้ซ้ำ ทำให้เฉพาะทาง และอนุมานชนิดได้

คำถามที่พบบ่อย

บทเรียน “การทำเคอร์รี” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การทำเคอร์รี” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การทำเคอร์รี”

การประยุกต์ใช้บางส่วน คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การทำเคอร์รี” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. ฟังก์ชันในฐานะค่า
  2. การทำเคอร์รี
  3. การประกอบฟังก์ชัน
  4. โคลเชอร์
← กลับไปที่ Scala for Backend Engineering & Functional Programming