Functions

ใช้ `return` เพื่อส่งค่ากลับจากฟังก์ชัน

`return` คือ keyword ที่ใช้ส่งค่ากลับออกจากฟังก์ชันไปยังจุดที่เรียกใช้ ก่อนหน้านี้ฟังก์ชันของเราใช้ `console.log(...)` แสดงผลบน console อย่างเดียว แต่ `return` ทำให้ฟังก์ชันสามารถคำนวณอะไรบางอย่างแล้วส่งผลลัพธ์กลับมาให้เราเอาไปใช้ต่อได้ — เช่น เก็บในตัวแปร ส่งต่อให้ฟังก์ชันอื่น หรือใช้ใน expression

function add(a, b) {
  return a + b;
}

const total = add(3, 5);
console.log(total); // 8

หัวใจของ `return` คือการเปลี่ยนฟังก์ชันจาก "ผู้แสดงผล" เป็น "ผู้ผลิตค่า" — ฟังก์ชันกลายเป็นกล่องที่รับ input เข้าไป แล้วคาย output ออกมาให้เราเอาไปใช้ต่อที่ไหนก็ได้

ค่าที่ `return` ต้องเก็บไว้จึงจะใช้ต่อได้

เมื่อฟังก์ชันส่งค่ากลับมา เราต้อง**รับค่านั้นไว้** — โดยเก็บในตัวแปร หรือใช้ต่อใน expression ทันที ถ้าเรียกฟังก์ชันที่ return ค่าแล้วไม่รับไว้ ค่านั้นก็จะหายไปหลังจากฟังก์ชันทำงานจบ

function square(number) {
  return number * number;
}

const result = square(4);
const message = "ผลลัพธ์คือ " + result;

console.log(message); // ผลลัพธ์คือ 16

ในตัวอย่าง `square(4)` ถูกแทนที่ด้วยค่า `16` ในบรรทัดที่เรียกใช้ — ทำให้เราเอา `result` ไปใช้งานต่อได้เหมือนเป็นค่าธรรมดา **รูปแบบการใช้งานที่พบบ่อย**: เก็บ return value ใน `const` หรือ `let` → ใช้ค่านั้นในบรรทัดถัดไป หรือส่งเข้า parameter ของอีกฟังก์ชัน

ไม่มี `return` หรือ `return;` — ได้ `undefined`

JavaScript มีกฎเกี่ยวกับ `return` 3 กรณีที่ให้ผลต่างกัน:

function getName() {
  return "Mali";
}

function stopHere() {
  return;
}

function doSomething() {
  const score = 10; // ไม่มี return
}

console.log(getName());     // "Mali"
console.log(stopHere());    // undefined
console.log(doSomething());  // undefined

`return;` แบบไม่มีค่ามักใช้เมื่อเราอยากหยุดฟังก์ชันกลางคันโดยไม่สนใจค่าที่ส่งกลับ — เช่น early return ในหัวข้อถัดไป

`return` ทำให้ฟังก์ชันหยุดทำงานทันที

เมื่อ JavaScript เจอ `return` มันจะออกจากฟังก์ชันทันที โค้ดที่อยู่หลัง `return` ในฟังก์ชันเดียวกันจะไม่ถูกรัน — โค้ดเหล่านั้นเรียกว่า **dead code** (โค้ดที่ไม่มีทางรัน)

function getPrice() {
  return 250;
  console.log("บรรทัดนี้คือ dead code");
}

const price = getPrice();
console.log(price); // 250 — บรรทัดด้านล่างไม่แสดง

Early return — เช็กกรณีพิเศษก่อนแล้วออกทันที

**Early return** คือเทคนิคการเช็กกรณีที่ไม่ถูกต้องหรือกรณีพิเศษก่อน แล้ว `return` ออกจากฟังก์ชันทันที ก่อนที่จะไปถึงโค้ดหลัก ประโยชน์: ลดการซ้อน `if` ทำให้โค้ดอ่านง่ายขึ้น — แทนที่จะเขียน `if (ok) { ... โค้ดยาว ๆ ... }` เราเขียน `if (not ok) return` ก่อน แล้วค่อยเขียนโค้ดหลักต่อด้านล่าง

function divideSafe(a, b) {
  if (b === 0) {
    return "หารด้วยศูนย์ไม่ได้";
  }

  return a / b;
}

console.log(divideSafe(10, 2)); // 5
console.log(divideSafe(10, 0)); // "หารด้วยศูนย์ไม่ได้"

**หลักคิดของ early return**: เขียนเช็กกรณีที่ "ใช้ไม่ได้" ก่อน → return ทันที → หลังจากผ่านทุกเช็กแล้ว ค่อยเขียนโค้ดหลักที่ทำงานปกติ ลำดับนี้ทำให้โค้ดอ่านจากบนลงล่างแล้วเข้าใจง่าย

ข้อผิดพลาดที่พบบ่อย

• **ใช้ `console.log(...)` แทน `return`**: `console.log(...)` แค่แสดงผลให้เราเห็น ไม่ได้ส่งค่ากลับ — ถ้าพยายามเอาผลจากฟังก์ชันที่ใช้ `console.log(...)` ไปใช้ต่อ ค่าที่ได้จะเป็น `undefined`
• **ลืมเขียน `return`**: ถ้าฟังก์ชันทำงานจนจบโดยไม่มี `return` — JavaScript จะคืน `undefined` ให้โดยอัตโนมัติ โดยที่เราไม่รู้ตัว
• **วางโค้ดไว้หลัง `return`**: หลังจาก `return` แล้วฟังก์ชันจะหยุดทันที โค้ดด้านล่างที่คิดว่าจะรันต่อจะกลายเป็น dead code — ถ้าต้องการรันโค้ดก่อน return ให้ย้ายไปไว้ข้างบน
• **ไม่เก็บค่า return ไว้**: การเรียกฟังก์ชันที่ return ค่าแล้วไม่รับไว้ จะทำให้ค่าที่คำนวณมาหายไป — ต้องใช้ `const result = functionName()` เพื่อดักจับค่านั้น
• **เข้าใจผิดว่า `return;` คือ return `undefined` สลับกับไม่มี `return`**: แม้สองกรณีจะได้ `undefined` เหมือนกัน แต่ `return;` จะหยุดฟังก์ชันทันที ส่วนไม่มี `return` เลยจะรันจนจบฟังก์ชัน — ต่างกันที่จุดที่หยุด

Lab 1: return ค่าคูณ 2

Lab 2: return ข้อความจาก parameter

Lab 3: เก็บค่าที่ return ไปใช้ต่อ

Lab 4: return ค่า boolean

Lab 5: return คนละค่าตามเงื่อนไข

Lab 6: ใช้ early return

Lab 7: แก้จาก `console.log(...)` ให้เป็น `return`

Lab 8: Mini Challenge — ใช้ค่าที่ return ไปต่อกัน