ฟังก์ชันลำดับสูงและการทำเคอร์รี
สำรวจแนวคิดเชิงฟังก์ชันขั้นสูง เช่น ฟังก์ชันลำดับสูงและการทำเคอร์รี เพื่อสร้างโค้ดที่ยืดหยุ่นและนำกลับมาใช้ซ้ำได้
ฟังก์ชันลำดับสูงและการทำเคอร์รี เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน
ปลดล็อกพลังของฟังก์ชันลำดับสูง
ยินดีต้อนรับสู่บทเรียนที่ 2 ครับ/ค่ะ! ในการเขียนโปรแกรมเชิงฟังก์ชัน ฟังก์ชันมีความทรงพลัง ไม่ได้มีไว้เพียงคำนวณค่าเท่านั้น แต่ยังสามารถจัดการได้เหมือนข้อมูลชนิดอื่น ๆ
นั่นหมายความว่า เราสามารถส่งฟังก์ชันเป็นอาร์กิวเมนต์ให้ฟังก์ชันอื่น หรือแม้แต่รับฟังก์ชันกลับมาเป็นผลลัพธ์ได้ เมื่อฟังก์ชันทำเช่นนี้ เราจะเรียกว่าเป็น ฟังก์ชันลำดับสูง (HOF)
- HOF รับฟังก์ชันอย่างน้อยหนึ่งฟังก์ชันเป็นอาร์กิวเมนต์
- HOF ส่งคืนฟังก์ชันเป็นผลลัพธ์
- หรือทำได้ทั้งสองอย่าง!
HOF ในการทำงาน: `map`
HOF ที่ใช้กันทั่วไปมากที่สุดรายการหนึ่งใน Scala คือ map ซึ่งจะแปลงสมาชิกแต่ละรายการในคอลเลกชันด้วยการใช้ฟังก์ชันที่กำหนด แล้วส่งคืนคอลเลกชันใหม่
ลองเรียกใช้ตัวอย่างง่าย ๆ นี้:
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 ในการทำงาน: `filter`
HOF ที่มีประโยชน์อีกรายการหนึ่งคือ filter ซึ่งจะเลือกสมาชิกจากคอลเลกชันที่ตรงตามเงื่อนไขที่กำหนด (ฟังก์ชันที่ส่งคืนค่าบูลีน) แล้วสร้างคอลเลกชันใหม่
มาดูวิธีใช้ filter เพื่อค้นหาจำนวนคู่กัน:
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")
}
}การกำหนด HOF ของคุณเอง
คุณไม่ได้จำกัดอยู่แค่ HOF ที่มีมาให้ในระบบเท่านั้น! คุณสามารถกำหนดฟังก์ชันของคุณเองที่รับฟังก์ชันอื่นเป็นพารามิเตอร์ได้ ไวยากรณ์สำหรับชนิดฟังก์ชันคือ (InputType => ReturnType)
ตัวอย่างนี้กำหนดฟังก์ชัน applyOperation ที่รับค่า Int และฟังก์ชัน op อีกหนึ่งฟังก์ชัน (ซึ่งรับค่า Int และส่งคืนค่า 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")
}
}ฟังก์ชันไม่ระบุชื่อและรูปแบบย่อ
เมื่อส่งฟังก์ชันให้ HOF คุณมักใช้ ฟังก์ชันไม่ระบุชื่อ (เรียกอีกอย่างว่าแลมบ์ดา) โดย Scala มีวิธีเขียนฟังก์ชันเหล่านี้ให้กระชับ
x => x * 2: ฟังก์ชันไม่ระบุชื่อแบบเต็ม_ * 2: รูปแบบย่อของฟังก์ชันไม่ระบุชื่อที่มีพารามิเตอร์เดียว
ทั้งสองรูปแบบใช้กันทั่วไป และช่วยให้โค้ดสั้นลงและอ่านง่ายขึ้น
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")
}
}แนะนำการทำเคอร์รี
การทำเคอร์รี คือเทคนิคที่แปลงฟังก์ชันซึ่งรับอาร์กิวเมนต์หลายตัวให้เป็นลำดับของฟังก์ชัน โดยแต่ละฟังก์ชันรับอาร์กิวเมนต์เพียงตัวเดียว
ชื่อนี้ตั้งตามนักตรรกศาสตร์ Haskell Curry ใน Scala ฟังก์ชันที่มีรายการพารามิเตอร์หลายรายการจะถูกทำเคอร์รีโดยอัตโนมัติ
แทนที่จะเขียน f(arg1, arg2) ให้เขียนเป็น f(arg1)(arg2)
ตัวอย่างการทำเคอร์รี: รายการพารามิเตอร์หลายรายการ
มาดูการทำเคอร์รีในการใช้งานกัน สังเกตว่า add รับอาร์กิวเมนต์ในรายการพารามิเตอร์สองรายการแยกกัน
วิธีนี้ช่วยให้คุณใช้ฟังก์ชันบางส่วนได้ โดยสร้างฟังก์ชันใหม่จากการกำหนดค่าอาร์กิวเมนต์บางตัวไว้ล่วงหน้า
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)}")
}
}ประโยชน์ของการทำเคอร์รี
เหตุใดจึงควรใช้การทำเคอร์รี การทำเคอร์รีมีข้อดีหลายประการในการเขียนโปรแกรมเชิงฟังก์ชัน:
- การใช้ฟังก์ชันบางส่วน: สร้างฟังก์ชันเฉพาะทางจากการกำหนดค่าอาร์กิวเมนต์บางตัวไว้ล่วงหน้า ซึ่งช่วยให้ใช้โค้ดซ้ำได้ดีขึ้น
- การประกอบฟังก์ชัน: ฟังก์ชันที่ผ่านการทำเคอร์รีมักนำไปประกอบกับฟังก์ชันอื่นได้ง่ายกว่า
- การอนุมานชนิดข้อมูล: บางครั้งช่วยการอนุมานชนิดข้อมูลของ Scala โดยเฉพาะเมื่อต้องทำงานกับชนิดข้อมูลทั่วไปที่ซับซ้อน
การทำเคอร์รีสำหรับตัวบันทึกแบบกำหนดเอง
ลองจินตนาการว่าคุณต้องการสร้างฟังก์ชันบันทึกข้อมูลหลายแบบสำหรับระดับที่แตกต่างกัน (เช่น INFO และ ERROR) โดยใช้ตรรกะหลักชุดเดียวกัน การทำเคอร์รีเหมาะอย่างยิ่งสำหรับงานนี้!
คุณสามารถกำหนดฟังก์ชัน log ทั่วไป แล้วนำไปใช้บางส่วนเพื่อสร้างตัวบันทึกเฉพาะแบบได้
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!")
}
}ตรวจสอบอย่างรวดเร็ว: HOF และการทำเคอร์รี
พิจารณาชุดโค้ด Scala ต่อไปนี้:
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)ค่า result1 และ result2 คือเท่าใด
ทบทวน: HOF และการทำเคอร์รี
ทำได้ดีมากครับ/ค่ะ! คุณได้เรียนรู้แนวคิดสำคัญสองประการในการเขียนโปรแกรมเชิงฟังก์ชัน:
- ฟังก์ชันลำดับสูง (HOF): ฟังก์ชันที่รับฟังก์ชันอื่นเป็นอาร์กิวเมนต์ หรือส่งคืนฟังก์ชันเหล่านั้นเป็นผลลัพธ์ ฟังก์ชันเหล่านี้ช่วยให้โค้ดยืดหยุ่นและนำกลับมาใช้ซ้ำได้ เช่น
mapและfilter - การทำเคอร์รี: เทคนิคที่แปลงฟังก์ชันซึ่งมีอาร์กิวเมนต์หลายตัวให้เป็นลำดับของฟังก์ชัน โดยแต่ละฟังก์ชันรับอาร์กิวเมนต์เพียงตัวเดียว เทคนิคนี้เหมาะอย่างยิ่งสำหรับการใช้ฟังก์ชันบางส่วนและการสร้างฟังก์ชันเฉพาะทาง
แนวคิดเหล่านี้เป็นพื้นฐานสำคัญของการเขียนโค้ด Scala ที่สื่อความหมายได้ดีและแบ่งเป็นส่วนประกอบได้!
เรียนรู้ Scala ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 39
- บทเรียน
- 143
คำถามที่พบบ่อย
บทเรียน “ฟังก์ชันลำดับสูงและการทำเคอร์รี” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ฟังก์ชันลำดับสูงและการทำเคอร์รี” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชันลำดับสูงและการทำเคอร์รี”
สำรวจแนวคิดเชิงฟังก์ชันขั้นสูง เช่น ฟังก์ชันลำดับสูงและการทำเคอร์รี เพื่อสร้างโค้ดที่ยืดหยุ่นและนำกลับมาใช้ซ้ำได้ คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน
บทเรียน “ฟังก์ชันลำดับสูงและการทำเคอร์รี” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ฟังก์ชันในฐานะค่าอันดับหนึ่ง
- ฟังก์ชันลำดับสูงและการทำเคอร์รี
- ความไม่เปลี่ยนรูปและผลข้างเคียง