ฟังก์ชันในฐานะค่าอันดับหนึ่ง
เรียนรู้การกำหนดและส่งฟังก์ชันเป็นอาร์กิวเมนต์ การส่งคืนฟังก์ชันจากฟังก์ชันอื่น และการจัดเก็บฟังก์ชันไว้ในตัวแปร
ฟังก์ชันในฐานะค่าอันดับหนึ่ง เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน
ฟังก์ชันในฐานะค่าอันดับหนึ่ง
ยินดีต้อนรับสู่แกนหลักของการเขียนโปรแกรมเชิงฟังก์ชัน! ใน Scala ฟังก์ชันไม่ได้เป็นเพียงคำสั่งเท่านั้น แต่ยังเป็นค่าอันดับหนึ่ง
หมายความว่าคุณสามารถปฏิบัติต่อฟังก์ชันได้เหมือนชนิดข้อมูลอื่น ๆ เช่น ตัวเลขหรือสตริง นี่คือแนวคิดหลักของการเขียนโปรแกรมเชิงฟังก์ชัน!
การกำหนดฟังก์ชันให้ตัวแปร
เช่นเดียวกับที่คุณกำหนดตัวเลขให้กับ val ได้ คุณก็สามารถกำหนดฟังก์ชันให้กับ val ได้เช่นกัน ในที่นี้ greet จะกลายเป็นตัวแปรที่เก็บฟังก์ชันของเรา
ลองเรียกใช้ตัวอย่างง่าย ๆ นี้:
object Main {
def main(args: Array[String]): Unit = {
val greet = (name: String) => s"Hello, $name!"
println(greet("Alice"))
}
}ฟังก์ชันไม่ระบุชื่อ (แลมบ์ดา)
ส่วน (name: String) => s"Hello, $name!" ในฉากก่อนหน้าคือฟังก์ชันไม่ระบุชื่อ หรือเรียกอีกอย่างว่านิพจน์แลมบ์ดา
ฟังก์ชันนี้ไม่มีชื่อ และมักกำหนดไว้ตรงจุดที่ต้องการใช้งาน ฟังก์ชันลักษณะนี้มีประโยชน์มากสำหรับงานเฉพาะอย่างที่ทำได้อย่างรวดเร็ว
object Main {
def main(args: Array[String]): Unit = {
val add = (x: Int, y: Int) => x + y
println(s"5 + 3 = ${add(5, 3)}")
val subtract = (a: Int, b: Int) => a - b
println(s"10 - 4 = ${subtract(10, 4)}")
}
}ฟังก์ชันในฐานะอาร์กิวเมนต์ของเมธอด
หนึ่งในความสามารถที่ทรงพลังที่สุดคือการส่งฟังก์ชันเป็นอาร์กิวเมนต์ให้ฟังก์ชันอื่น ฟังก์ชันลักษณะนี้เรียกว่า ฟังก์ชันลำดับสูง
ฟังก์ชัน applyOperation ด้านล่างรับตัวเลขสองตัวและฟังก์ชันอีกหนึ่งตัวคือ op จากนั้นจะใช้ op เพื่อรวมตัวเลขทั้งสอง
object Main {
def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
op(x, y)
}
def main(args: Array[String]): Unit = {
val add = (a: Int, b: Int) => a + b
val result = applyOperation(5, 3, add)
println(s"Result of addition: $result")
}
}ทำความเข้าใจชนิดของฟังก์ชัน
สังเกตลายเซ็นชนิดข้อมูล op: (Int, Int) => Int ในฉากก่อนหน้า
(Int, Int): หมายความว่าฟังก์ชันรับอาร์กิวเมนต์ชนิดIntสองตัว=> Int: หมายความว่าฟังก์ชันส่งคืนค่าเป็นชนิดInt
ฟังก์ชันทุกตัวมีชนิดที่อธิบายอินพุตและเอาต์พุตของฟังก์ชัน ช่วยให้ Scala ตรวจสอบความปลอดภัยของชนิดข้อมูลได้!
การส่งฟังก์ชันแบบกระชับ
คุณไม่จำเป็นต้องกำหนดฟังก์ชันที่มีชื่อก่อนเสมอไป คุณสามารถส่งฟังก์ชันไม่ระบุชื่อโดยตรงในจุดที่ต้องการอาร์กิวเมนต์ฟังก์ชันได้
วิธีนี้ทำให้โค้ดกระชับและอ่านง่ายขึ้น โดยเฉพาะสำหรับการดำเนินการอย่างง่าย
object Main {
def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
op(x, y)
}
def main(args: Array[String]): Unit = {
val result1 = applyOperation(10, 2, (a: Int, b: Int) => a * b)
println(s"Multiplication: $result1")
// Scala can often infer types, making it even shorter!
val result2 = applyOperation(20, 4, (a, b) => a / b)
println(s"Division: $result2")
}
}ฟังก์ชันในฐานะค่าที่ส่งคืน
ฟังก์ชันยังสามารถ ส่งคืนฟังก์ชันอื่น ได้ แม้ฟังดูซับซ้อน แต่มีประโยชน์อย่างมากสำหรับการสร้างโค้ดที่ยืดหยุ่นและปรับแต่งได้
ในที่นี้ makeMultiplier จะส่งคืนฟังก์ชันใหม่ที่คูณอินพุตด้วยตัวคูณที่กำหนด
object Main {
def makeMultiplier(factor: Int): Int => Int = {
(x: Int) => x * factor
}
def main(args: Array[String]): Unit = {
val multiplyByTwo = makeMultiplier(2)
val multiplyByFive = makeMultiplier(5)
println(s"5 * 2 = ${multiplyByTwo(5)}")
println(s"10 * 5 = ${multiplyByFive(10)}")
}
}ทำความเข้าใจคลอเชอร์
เมื่อ makeMultiplier ส่งคืนฟังก์ชัน ฟังก์ชันที่ส่งคืนนั้นจะ “จดจำ” ค่า factor ณ เวลาที่สร้างฟังก์ชัน นี่เรียกว่าคลอเชอร์
แม้ makeMultiplier จะทำงานเสร็จแล้ว ฟังก์ชัน multiplyByTwo ก็ยัง “รู้” ว่าตัวคูณของตนคือ 2
ประโยชน์ของฟังก์ชันอันดับหนึ่ง
เหตุใดการปฏิบัติต่อฟังก์ชันเสมือนเป็นค่าพื้นฐานจึงสำคัญ
- ความยืดหยุ่น: คุณสามารถสลับพฤติกรรมได้ง่าย ๆ ด้วยการส่งฟังก์ชันที่แตกต่างกัน
- การนำกลับมาใช้ซ้ำ: สร้างฟังก์ชันทั่วไปที่ทำงานกับฟังก์ชันใด ๆ ที่คุณส่งให้
- ความกระชับ: ช่วยให้โค้ดสั้นลงและสื่อความหมายได้ดีขึ้น โดยเฉพาะเมื่อใช้ฟังก์ชันไม่ระบุชื่อ
- รูปแบบเชิงฟังก์ชัน: เป็นรากฐานสำคัญของการเขียนโปรแกรมเชิงฟังก์ชัน และช่วยให้ใช้รูปแบบที่ทรงพลังได้
ทดสอบความรู้ของคุณ
มาตรวจสอบความเข้าใจของคุณเกี่ยวกับฟังก์ชันในฐานะค่าอันดับหนึ่งกัน
object Main {
def execute(x: Int, op: Int => Int): Int = op(x)
def main(args: Array[String]): Unit = {
val square = (n: Int) => n * n
val result = execute(5, square)
println(result)
}
}ฟังก์ชันในฐานะค่า: ทบทวน
ทำได้ยอดเยี่ยมมาก! คุณได้เรียนรู้แนวคิดพื้นฐานของฟังก์ชันในฐานะค่าอันดับหนึ่งใน Scala แล้ว
- สามารถกำหนดฟังก์ชันให้ตัวแปรได้
- สามารถส่งฟังก์ชันเป็นอาร์กิวเมนต์ให้ฟังก์ชันอื่นได้
- สามารถส่งคืนฟังก์ชันเป็นผลลัพธ์จากฟังก์ชันอื่นได้
- ทำให้เกิดรูปแบบที่ทรงพลัง เช่น ฟังก์ชันลำดับสูงและคลอเชอร์
ความสามารถนี้เป็นกุญแจสำคัญในการเขียนโค้ด Scala เชิงฟังก์ชันที่ยืดหยุ่น นำกลับมาใช้ซ้ำได้ และสื่อความหมายได้ดี ต่อไป เราจะเจาะลึกฟังก์ชันลำดับสูงขั้นสูงและการทำเคอร์รี!
คำถามที่พบบ่อย
บทเรียน “ฟังก์ชันในฐานะค่าอันดับหนึ่ง” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ฟังก์ชันในฐานะค่าอันดับหนึ่ง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน
บทเรียน “ฟังก์ชันในฐานะค่าอันดับหนึ่ง” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ฟังก์ชันในฐานะค่าอันดับหนึ่ง
- ฟังก์ชันลำดับสูงและการทำเคอร์รี
- ความไม่เปลี่ยนรูปและผลข้างเคียง