นิพจน์เหนือคำสั่ง
ทุกอย่างส่งคืนค่า
นิพจน์เหนือคำสั่ง เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน
ทุกอย่างคือนิพจน์
ในหลายภาษา if และบล็อกเป็น คำสั่ง ที่ทำงานบางอย่างแต่ไม่สร้างค่าใด ๆ ส่วนใน Scala สิ่งเหล่านี้เป็น นิพจน์ ที่ประเมินผลออกมาเป็นค่า
แนวคิดนี้เป็นหัวใจสำคัญของการเขียนโปรแกรมเชิงฟังก์ชันใน Scala
val max = if (3 > 2) 3 else 2if ในฐานะนิพจน์
if/else ของ Scala จะส่งคืนค่าของแขนงที่ทำงาน คุณสามารถกำหนดผลลัพธ์นั้นให้กับ val ได้โดยตรง
ไม่จำเป็นต้องใช้ตัวแปรที่เปลี่ยนค่าได้แล้วกำหนดค่าภายในแต่ละแขนง
object Main extends App {
val temp = 18
val label = if (temp > 20) "warm" else "cool"
println(label)
}บล็อกส่งคืนบรรทัดสุดท้าย
บล็อก { ... } เป็นนิพจน์ในตัวเอง ค่าของบล็อกคือค่าของ นิพจน์สุดท้าย ภายในบล็อก
ในที่นี้ บล็อกจะประเมินผลเป็น 30 ซึ่งกลายเป็นค่าของ result
object Main extends App {
val result = {
val a = 10
val b = 20
a + b
}
println(result)
}ไม่จำเป็นต้องใช้ return อย่างชัดเจน
เนื่องจากเนื้อหาของเมธอดเป็นนิพจน์ ค่าของเมธอดจึงเป็นเพียงค่าของนิพจน์สุดท้ายที่ประเมินผล คำสำคัญ return จึงแทบไม่ถูกใช้
เมธอดทั้งสองด้านล่างทำงานเหมือนกัน แต่แบบที่เป็นสำนวนตามแนวทางของภาษาจะละเว้น return
def double(x: Int) = x * 2
// instead of: def double(x: Int) = { return x * 2 }match ก็เป็นนิพจน์เช่นกัน
การจับคู่รูปแบบด้วย match ก็ให้ค่าเช่นกัน จึงเหมาะอย่างยิ่งสำหรับการแปลงอินพุตเป็นผลลัพธ์
แขนงของแต่ละกรณีจะสร้างค่าของแขนงนั้น
object Main extends App {
val day = 3
val name = day match {
case 1 => "Mon"
case 3 => "Wed"
case _ => "Other"
}
println(name)
}นิพจน์ประกอบกันได้
เนื่องจากนิพจน์ส่งคืนค่า คุณจึงซ้อนและรวมเข้าด้วยกันได้อย่างอิสระ
if สามารถเป็นอาร์กิวเมนต์ของฟังก์ชัน หรือเป็นส่วนหนึ่งของการคำนวณที่ใหญ่ขึ้นได้โดยไม่ต้องใช้ตัวแปรชั่วคราว
object Main extends App {
val n = 7
println("sign: " + (if (n >= 0) "+" else "-"))
}ยังมีคำสั่งอยู่
ไม่ใช่ทุกอย่างที่จะสร้างค่าที่มีประโยชน์ การดำเนินการที่ทำเพียงเพื่อ ผลข้างเคียง เช่น println หรือการกำหนดค่า จะประเมินผลเป็น Unit
สิ่งเหล่านี้คือนิพจน์ที่มีลักษณะคล้ายคำสั่งใน Scala
val x: Unit = println("hello") // value is ()หลีกเลี่ยง var เมื่อใช้นิพจน์
รูปแบบการเขียนด้วยนิพจน์ช่วยให้คุณแทนที่รูปแบบการใช้ var ที่เปลี่ยนค่าได้ แทนที่จะประกาศ var แล้วกำหนดค่าภายในแต่ละแขนง ให้กำหนดผลลัพธ์ของ if ทั้งหมดให้กับ val
object Main extends App {
val score = 85
val grade = if (score >= 90) "A" else if (score >= 80) "B" else "C"
println(grade)
}for สร้างค่า
for ที่ใช้ร่วมกับ yield เป็นนิพจน์ที่สร้างคอลเลกชันใหม่ แทนที่จะวนซ้ำเพียงเพื่อให้เกิดผลข้างเคียง
วิธีนี้เปลี่ยนการวนซ้ำให้เป็นการแปลงข้อมูลที่สร้างค่า
object Main extends App {
val squares = for (i <- 1 to 4) yield i * i
println(squares)
}เหตุใดจึงสำคัญต่อโค้ดฝั่งเซิร์ฟเวอร์
โค้ดที่เน้นการใช้นิพจน์มักสั้นกว่า มีส่วนประกอบที่ต้องจัดการน้อยกว่า และทดสอบได้ง่ายกว่า
- ตัวแปรที่เปลี่ยนค่าได้น้อยลงหมายถึงข้อผิดพลาดน้อยลง
- ผลลัพธ์ไหลมาจากอินพุตได้อย่างเป็นธรรมชาติ
- ทำงานประกอบกับไลบรารีเชิงฟังก์ชันของ Scala ได้ดี
รูปแบบคำสั่งเทียบกับรูปแบบนิพจน์
ลองเปรียบเทียบแนวคิดทั้งสองแบบ รูปแบบคำสั่งจะเปลี่ยนค่าของตัวแปร ส่วนรูปแบบนิพจน์จะส่งคืนค่าโดยตรง
Scala รองรับทั้งสองแบบ แต่สนับสนุนรูปแบบนิพจน์มากกว่า
var s = "" // statement style
if (true) s = "yes" else s = "no"
val e = if (true) "yes" else "no" // expression styleตรวจสอบความเข้าใจ
if/else ใน Scala ประเมินผลออกมาเป็นอะไร
สรุป
Scala ให้ความสำคัญกับนิพจน์ที่สร้างค่ามากกว่าคำสั่งที่ทำได้เพียงเปลี่ยนสถานะ
if,match, บล็อก และfor/yieldล้วนส่งคืนค่า- เนื้อหาของเมธอดจะส่งคืนค่านิพจน์สุดท้าย จึงแทบไม่จำเป็นต้องใช้
return - โค้ดที่มีผลข้างเคียงจะส่งคืน
Unit - รูปแบบนี้ช่วยลดการใช้
varและลดข้อผิดพลาด
คำถามที่พบบ่อย
บทเรียน “นิพจน์เหนือคำสั่ง” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “นิพจน์เหนือคำสั่ง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “นิพจน์เหนือคำสั่ง” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ