แลมบ์ดาและฟังก์ชันระดับสูง
ส่งต่อพฤติกรรมในฐานะค่า
แลมบ์ดาและฟังก์ชันระดับสูง เป็นบทเรียน Android Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Android Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Android Academy มีบทเรียนทั้งหมด 4 บทเรียน
แลมบ์ดาคืออะไร
แลมบ์ดา คือฟังก์ชันขนาดเล็กที่เขียนไว้ในจุดใช้งานได้โดยไม่ต้องตั้งชื่อ
คุณครอบแลมบ์ดาด้วยวงเล็บปีกกา: { x -> x + 1 } แลมบ์ดาช่วยให้คุณส่งต่อพฤติกรรมในลักษณะเดียวกับข้อมูลได้
คุณได้ใช้แลมบ์ดากับ map และ filter มาแล้ว
การจัดเก็บแลมบ์ดาในตัวแปร
แลมบ์ดาเป็นค่าอย่างหนึ่ง คุณจึงจัดเก็บไว้ในตัวแปรแล้วเรียกใช้ภายหลังได้
เรียกใช้เหมือนฟังก์ชันโดยใช้วงเล็บ
fun main() {
val square = { x: Int -> x * x }
println(square(5))
println(square(3))
}ทางลัด it
เมื่อแลมบ์ดารับพารามิเตอร์เพียงหนึ่งตัว คุณสามารถไม่ตั้งชื่อพารามิเตอร์และใช้ it แทนได้
วิธีนี้ทำให้แลมบ์ดาสั้น ๆ กระชับและอ่านง่าย
fun main() {
val nums = listOf(1, 2, 3, 4)
val big = nums.filter { it > 2 }
println(big)
}พารามิเตอร์หลายตัว
แลมบ์ดาสามารถรับพารามิเตอร์มากกว่าหนึ่งตัว โดยคั่นด้วยจุลภาคก่อนลูกศร
นิพจน์สุดท้ายในแลมบ์ดาคือค่าที่แลมบ์ดาส่งคืน
fun main() {
val add = { a: Int, b: Int -> a + b }
println(add(4, 6))
}ฟังก์ชันลำดับสูง
ฟังก์ชันลำดับสูง คือฟังก์ชันที่รับฟังก์ชันอื่นเป็นพารามิเตอร์หรือส่งคืนฟังก์ชัน
ชนิดฟังก์ชัน (Int) -> Int หมายถึง “รับค่า Int และส่งคืนค่า Int” นี่คือวิธีการทำงานของ map และ filter
การเขียนฟังก์ชันลำดับสูง
ในตัวอย่างนี้ เรากำหนด applyTwice ซึ่งรับฟังก์ชันและเรียกใช้ฟังก์ชันนั้นสองครั้ง
พารามิเตอร์ op มีชนิดเป็น (Int) -> Int
fun applyTwice(x: Int, op: (Int) -> Int): Int {
return op(op(x))
}
fun main() {
println(applyTwice(3) { it + 1 })
}ไวยากรณ์แลมบ์ดาต่อท้าย
เมื่อแลมบ์ดาเป็นอาร์กิวเมนต์ตัวสุดท้าย คุณสามารถย้ายแลมบ์ดาออกมานอกวงเล็บได้
นี่คือเหตุผลที่ list.filter { ... } ดูสะอาดตา รูปแบบทั้งสองด้านล่างมีความหมายเท่ากัน
fun main() {
val nums = listOf(1, 2, 3)
println(nums.map({ it * 2 }))
println(nums.map { it * 2 })
}การส่งฟังก์ชันที่มีชื่อ
คุณสามารถส่งฟังก์ชันที่มีชื่ออยู่แล้วในตำแหน่งที่ต้องใช้แลมบ์ดาได้ โดยใช้ :: ซึ่งเรียกว่าการอ้างอิงฟังก์ชัน
วิธีนี้ช่วยหลีกเลี่ยงการเขียนตรรกะซ้ำในรูปแลมบ์ดา
fun isOdd(n: Int) = n % 2 == 1
fun main() {
val nums = listOf(1, 2, 3, 4)
println(nums.filter(::isOdd))
}การส่งคืนฟังก์ชัน
ฟังก์ชันลำดับสูงสามารถส่งคืนฟังก์ชันได้เช่นกัน ในตัวอย่างนี้ multiplier สร้างแลมบ์ดาสำหรับการคูณตามต้องการ
นี่เป็นรูปแบบง่าย ๆ ของการกำหนดค่า
fun multiplier(factor: Int): (Int) -> Int {
return { it * factor }
}
fun main() {
val triple = multiplier(3)
println(triple(5))
}แลมบ์ดาจับค่าตัวแปร
แลมบ์ดาสามารถอ่านตัวแปรจากขอบเขตโดยรอบได้ สิ่งนี้เรียกว่า คลอเชอร์
ในตัวอย่างนี้ แลมบ์ดายังคงจำ bonus ได้แม้ถูกส่งต่อไปที่อื่นแล้ว
fun main() {
val bonus = 10
val nums = listOf(1, 2, 3)
println(nums.map { it + bonus })
}เหตุผลที่แลมบ์ดาสำคัญบน Android
บน Android แลมบ์ดาช่วยเขียนการเรียกกลับให้กระชับและอ่านง่าย ตัวฟังการคลิกปุ่มก็คือแลมบ์ดาที่คุณส่งให้เฟรมเวิร์ก
ตัวอย่างเช่น button.setOnClickListener { showMenu() } จะเรียกใช้โค้ดของคุณเมื่อมีการแตะ
ตรวจสอบความเข้าใจ
ทดสอบความเข้าใจเกี่ยวกับแลมบ์ดาและฟังก์ชันลำดับสูง
สรุปทบทวน
แลมบ์ดาคือฟังก์ชันไร้ชื่อที่เขียนไว้ในวงเล็บปีกกา และใช้ it เมื่อมีพารามิเตอร์เพียงตัวเดียว
ฟังก์ชันลำดับสูงรับหรือส่งคืนฟังก์ชัน ทำให้เขียนการเรียกกลับและการดำเนินการที่นำกลับมาใช้ซ้ำได้ เช่น map และ filter อย่างสะอาด
คำถามที่พบบ่อย
บทเรียน “แลมบ์ดาและฟังก์ชันระดับสูง” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “แลมบ์ดาและฟังก์ชันระดับสูง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Android Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Android Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “แลมบ์ดาและฟังก์ชันระดับสูง”
ส่งต่อพฤติกรรมในฐานะค่า คุณปฏิบัติ Android Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Android Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Android Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “แลมบ์ดาและฟังก์ชันระดับสูง” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Android Academy นี้ได้ไหม
ได้ บทเรียน Android Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- รายการและรายการที่เปลี่ยนแปลงได้
- แมปและเซต
- map, filter, forEach
- แลมบ์ดาและฟังก์ชันระดับสูง