การทำเคอร์รี
การประยุกต์ใช้บางส่วน
การทำเคอร์รี เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ฟังก์ชันในฐานะค่า
- การทำเคอร์รี
- การประกอบฟังก์ชัน
- โคลเชอร์