Scala for Backend Engineering & Functional Programming · บทเรียน

นิพจน์แทนคำสั่ง

ทุกอย่างคือนิพจน์

บทเรียน 3 จาก 413 ขั้นตอน

นิพจน์แทนคำสั่ง เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

นิพจน์กับคำสั่ง

คำสั่ง ทำบางอย่างแต่ไม่ส่งคืนค่าที่มีประโยชน์ ส่วน นิพจน์ จะถูกประเมินผลออกมาเป็นค่า

ใน Scala แทบทุกอย่างเป็นนิพจน์ แนวคิดนี้เป็นหลักสำคัญที่กำหนดวิธีเขียนโค้ดของคุณ

if เป็นนิพจน์

ในหลายภาษา if เป็นคำสั่ง แต่ใน Scala if/else จะส่งคืนค่า คุณจึงกำหนดค่าให้กับ val ได้โดยตรง

ไม่จำเป็นต้องมีตัวแปรแยกต่างหากที่กำหนดค่าในแต่ละแขนง

object Main {
  def main(args: Array[String]): Unit = {
    val temp = 30
    val label = if (temp > 25) "hot" else "mild"
    println(label)
  }
}

บล็อกเป็นนิพจน์

บล็อก { ... } ก็เป็นนิพจน์เช่นกัน ค่าของบล็อกคือค่าของบรรทัดสุดท้าย

ดังนั้นคุณจึงคำนวณค่าระหว่างทางได้ แล้วจบด้วยผลลัพธ์

object Main {
  def main(args: Array[String]): Unit = {
    val result = {
      val a = 2
      val b = 3
      a * b
    }
    println(result)
  }
}

match เป็นนิพจน์

การจับคู่รูปแบบด้วย match จะส่งคืนค่าเช่นกัน แต่ละแขนงสร้างผลลัพธ์ขึ้นมา และนิพจน์ทั้งหมดจะให้ค่าของแขนงที่จับคู่ได้

object Main {
  def main(args: Array[String]): Unit = {
    val day = 3
    val name = day match {
      case 1 => "Mon"
      case 2 => "Tue"
      case 3 => "Wed"
      case _ => "Other"
    }
    println(name)
  }
}

ชนิดข้อมูล Unit

นิพจน์บางอย่างมีอยู่เพียงเพื่อผลข้างเคียง เช่น println นิพจน์เหล่านี้ส่งคืนค่าเป็น Unit ซึ่งเขียนเป็น ()

Unit คล้ายกับ void ในภาษาอื่น แต่ยังคงเป็นค่าจริงชนิดหนึ่ง

object Main {
  def main(args: Array[String]): Unit = {
    val nothing: Unit = println("side effect")
    println(nothing)
  }
}

การส่งคืนค่าจากฟังก์ชัน

เนื่องจากตัวฟังก์ชันเป็นนิพจน์ นิพจน์สุดท้ายจึงเป็นค่าที่ฟังก์ชันส่งคืน โดยทั่วไปคุณแทบไม่จำเป็นต้องใช้คีย์เวิร์ด return

ในที่นี้ตัวฟังก์ชันเป็นนิพจน์เดียว

object Main {
  def max(a: Int, b: Int): Int = if (a > b) a else b
  def main(args: Array[String]): Unit = {
    println(max(7, 4))
  }
}

ฟังก์ชันที่เน้นนิพจน์

ฟังก์ชันสามารถเป็นนิพจน์แบบบล็อกที่บรรทัดสุดท้ายเป็นผลลัพธ์ได้ วิธีนี้ทำให้ตรรกะกระชับและไม่ต้องใช้ค่าชั่วคราวที่เปลี่ยนแปลงได้

object Main {
  def discount(price: Double): Double = {
    val rate = if (price > 100) 0.2 else 0.1
    price * (1 - rate)
  }
  def main(args: Array[String]): Unit = {
    println(discount(150.0))
  }
}

ไม่จำเป็นต้องเปลี่ยนแปลงค่า

เนื่องจาก if และ match เป็นนิพจน์ คุณจึงกำหนดผลลัพธ์ให้กับ val แทนการเปลี่ยนแปลงค่าใน var ได้

วิธีนี้นำไปสู่โค้ดที่สะอาดและมีลักษณะเชิงฟังก์ชันมากขึ้น

object Main {
  def main(args: Array[String]): Unit = {
    val score = 85
    val grade = if (score >= 90) "A"
      else if (score >= 80) "B"
      else "C"
    println(grade)
  }
}

การประกอบนิพจน์

เนื่องจากทุกอย่างส่งคืนค่า นิพจน์จึงซ้อนและประกอบเข้าด้วยกันได้อย่างอิสระ ผลลัพธ์ของนิพจน์หนึ่งจะกลายเป็นอินพุตของอีกนิพจน์หนึ่ง

ความสามารถในการประกอบนี้เป็นเหตุผลสำคัญที่ทำให้ Scala มีความสื่อความหมายสูง

object Main {
  def main(args: Array[String]): Unit = {
    val n = 7
    val message = "n is " + (if (n % 2 == 0) "even" else "odd")
    println(message)
  }
}

เหตุใดจึงสำคัญ

โค้ดที่เน้นนิพจน์:

ลดความจำเป็นในการใช้ตัวแปรที่เปลี่ยนแปลงได้
ทำให้ลำดับการไหลของค่าชัดเจน
ประกอบเป็นโปรแกรมขนาดใหญ่ขึ้นได้อย่างเป็นธรรมชาติ
ทำงานเข้ากันได้ดีกับค่าที่ไม่เปลี่ยนแปลง

รวมทุกอย่างเข้าด้วยกัน

ในที่นี้นิพจน์แบบบล็อกประกอบด้วยนิพจน์ if และทั้งหมดถูกกำหนดให้กับผลลัพธ์เดียวที่ไม่เปลี่ยนแปลง

object Main {
  def main(args: Array[String]): Unit = {
    val total = {
      val items = 3
      val each = 12
      val raw = items * each
      if (raw > 30) raw - 5 else raw
    }
    println(total)
  }
}

ตรวจสอบอย่างรวดเร็ว

ตรวจสอบความเข้าใจเกี่ยวกับนิพจน์ของคุณ

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

คุณได้เรียนรู้ว่าใน Scala แทบทุกอย่างเป็นนิพจน์:

if/else, match และบล็อกล้วนส่งคืนค่า
ค่าของบล็อกคือนิพจน์สุดท้ายของบล็อก
นิพจน์ที่มีผลข้างเคียงจะส่งคืนค่า Unit (())
นิพจน์สุดท้ายของฟังก์ชันคือค่าที่ฟังก์ชันส่งคืน
แนวคิดนี้ช่วยลดการเปลี่ยนแปลงค่าและเพิ่มความสามารถในการประกอบ

เริ่มต้นได้ฟรี

เรียนรู้ 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 มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “นิพจน์แทนคำสั่ง”

ทุกอย่างคือนิพจน์ คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “นิพจน์แทนคำสั่ง” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Scala for Backend Engineering & Functional Programming