0Pricing
Ruby Academy · บทเรียน

ประโยคเงื่อนไขป้องกัน

การคืนค่าก่อนกำหนดอย่างสะอาด

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

การคืนค่าก่อนอย่างเป็นระเบียบ

ประโยคเฝ้าระวังคือการตรวจสอบที่ด้านบนของเมธอด ซึ่งจะคืนค่าก่อนเมื่อพบกรณีที่ไม่ถูกต้องหรือกรณีพิเศษ วิธีนี้ช่วยให้ตรรกะหลักอยู่ในระดับเดียวและอ่านง่าย

def greet(name)
  return "Hello, stranger" if name.nil?
  "Hello, #{name}"
end
puts greet(nil)
puts greet("Ada")

ปัญหา: การซ้อนหลายชั้น

หากไม่มีประโยคเฝ้าระวัง การตรวจสอบความถูกต้องจะกองซ้อนกันเป็นบล็อก if ที่ซ้อนกัน งานจริงจึงถูกฝังอยู่ลึกทางด้านขวาของหน้าจอ

def charge(user)
  if user
    if user[:active]
      puts "Charging #{user[:name]}"
    end
  end
end
charge({ name: "Sam", active: true })

วิธีแก้: ประโยคเฝ้าระวัง

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

def charge(user)
  return unless user
  return unless user[:active]
  puts "Charging #{user[:name]}"
end
charge({ name: "Sam", active: true })

return ที่ไม่มีค่า

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

def log(message)
  return if message.nil? || message.empty?
  puts "LOG: #{message}"
end
log("")
log("started")

การคืนค่า

ประโยคเฝ้าระวังยังสามารถคืนค่าที่มีความหมาย เช่น ค่าปริยายที่เหมาะสม เพื่อให้ผู้เรียกได้รับสิ่งที่นำไปใช้ได้เสมอ

def discount(price)
  return 0 if price <= 0
  price * 0.1
end
puts discount(-5)
puts discount(200)

ประโยคเฝ้าระวังด้วย unless

return unless condition มีความหมายว่า “ออกจากการทำงานหากไม่เป็นไปตามข้อกำหนดนี้” นี่เป็นสำนวน Ruby ที่พบได้บ่อยที่สุดแบบหนึ่ง

def withdraw(balance, amount)
  return "Insufficient funds" unless balance >= amount
  "New balance: #{balance - amount}"
end
puts withdraw(100, 150)
puts withdraw(100, 40)

ประโยคเฝ้าระวังหลายรายการ

วางประโยคเฝ้าระวังหลายรายการต่อกันเพื่อตรวจสอบข้อมูลนำเข้าทีละข้อ แต่ละบรรทัดระบุกฎเพียงข้อเดียว ทำให้เมธอดอธิบายตัวเองได้

def register(name, age)
  return "Name required" if name.to_s.empty?
  return "Must be 18+" if age < 18
  "Registered #{name}"
end
puts register("", 30)
puts register("Lee", 16)
puts register("Lee", 21)

ประโยคเฝ้าระวังด้วย next ในลูป

ภายในบล็อกหรือลูป คุณไม่สามารถใช้ return เพื่อข้ามเพียงรอบเดียวได้ ให้ใช้ next เป็นประโยคเฝ้าระวังเพื่อข้ามไปยังรายการถัดไป

[1, -2, 3, -4].each do |n|
  next if n.negative?
  puts n
end

ประโยคเฝ้าระวังช่วยให้อ่านง่ายขึ้น

ลองเปรียบเทียบรูปแบบทั้งสองด้านล่างในใจ: ประโยคเฝ้าระวังช่วยตัด else ออกและลดการเยื้อง ผู้อ่านจะเห็นการจัดการกรณีที่ไม่ถูกต้องก่อน แล้วจึงเห็นตรรกะหลัก

def area(width, height)
  return 0 unless width.positive? && height.positive?
  width * height
end
puts area(0, 5)
puts area(4, 5)

การโยนข้อยกเว้นในประโยคเฝ้าระวัง

เมื่อข้อมูลนำเข้าที่ไม่ถูกต้องเกิดจากข้อผิดพลาดของผู้เขียนโปรแกรม ไม่ใช่กรณีที่คาดหมายได้ ให้โยนข้อยกเว้นในประโยคเฝ้าระวัง เพื่อให้ล้มเหลวอย่างรวดเร็วและชัดเจน

def sqrt(n)
  raise ArgumentError, "n must be >= 0" if n.negative?
  Math.sqrt(n)
end
puts sqrt(16)
puts sqrt(-1) rescue puts "caught negative input"

นำทุกอย่างมาประกอบกัน

ประโยคเฝ้าระวังเป็นนิสัยเล็ก ๆ ที่ให้ผลลัพธ์คุ้มค่าอย่างมาก:

  • จัดการกรณีพิเศษตั้งแต่ต้นแล้วคืนค่า
  • รักษาตรรกะหลักไว้โดยไม่เพิ่มการเยื้อง
  • ใช้ return/next/raise ตามสถานการณ์
def initials(name)
  return "" if name.nil? || name.strip.empty?
  name.split.map { |part| part[0].upcase }.join
end
puts initials("  ").inspect
puts initials("grace hopper")

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

ทดสอบความเข้าใจเกี่ยวกับประโยคเฝ้าระวัง

สรุปทบทวน

คุณได้เรียนรู้ประโยคเฝ้าระวัง:

  • คืนค่าก่อนสำหรับกรณีที่ไม่ถูกต้องหรือกรณีพิเศษ
  • return unless จะออกจากการทำงานเมื่อไม่เป็นไปตามข้อกำหนด
  • ใช้ next เพื่อข้ามรอบของลูป และใช้ raise สำหรับข้อผิดพลาดที่แท้จริง
  • ผลลัพธ์คือเมธอดที่มีโครงสร้างแบนราบและอธิบายตัวเองได้
def safe_divide(a, b)
  return nil if b.zero?
  a / b
end
puts safe_divide(10, 0).inspect
puts safe_divide(10, 2)

คำถามที่พบบ่อย

บทเรียน “ประโยคเงื่อนไขป้องกัน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ประโยคเงื่อนไขป้องกัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Ruby Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Ruby Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ประโยคเงื่อนไขป้องกัน”

การคืนค่าก่อนกำหนดอย่างสะอาด คุณปฏิบัติ Ruby Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Ruby Academy หรือไม่

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

บทเรียน “ประโยคเงื่อนไขป้องกัน” ใช้เวลานานแค่ไหน

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

ฉันเขียนและรันโค้ดในบทเรียน Ruby Academy นี้ได้ไหม

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

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

  1. if, unless, ternary
  2. นิพจน์ case/when
  3. ค่าความจริงใน Ruby
  4. ประโยคเงื่อนไขป้องกัน
← กลับไปที่ Ruby Academy