Guest Adventurer 🥉 Lv.1
🪙 50
🔷 10
← กลับคลังเนื้อหา
Article · programming

EP. 3: ฟังก์ชันและการตัดสินใจด้วย JavaScript

JavaScript

บทเรียนตอนที่ 3 ของซีรีส์ JavaScript คืออะไร? เริ่มต้นเขียนโปรแกรม เรียนรู้การใช้เงื่อนไข if...else ฟังก์ชัน และการส่งค่าเข้าไปประมวลผล พร้อมตัวอย่างที่สามารถนำไปทดลองได้จริง

1. ทบทวนพื้นฐานก่อนเริ่มตอนที่ 3

ในสองตอนแรก เราเริ่มทำความรู้จัก JavaScript และเรียนรู้การประกาศตัวแปรกับชนิดข้อมูลกันแล้ว ตอนนี้เราจะนำความรู้เหล่านั้นมาสร้างโปรแกรมที่คิดและตัดสินใจได้ตามเงื่อนไขที่กำหนด
ลองนึกถึงระบบตรวจสอบคะแนนสอบ โปรแกรมจำเป็นต้องรู้ว่าคะแนนของผู้เรียนถึงเกณฑ์ผ่านหรือไม่ หากคะแนนตั้งแต่ 50 คะแนนขึ้นไปให้แสดงว่า “ผ่าน” แต่ถ้าต่ำกว่านั้นให้แสดงว่า “ไม่ผ่าน” การใช้เงื่อนไขช่วยให้โปรแกรมเลือกทำงานตามข้อมูลที่ได้รับ
เป้าหมายของตอนนี้เราจะเปลี่ยนจากการเขียนคำสั่งทีละบรรทัด ไปสู่การสร้างชุดคำสั่งที่สามารถตรวจสอบข้อมูล ตัดสินใจ และนำกลับมาใช้ซ้ำได้

2. การตัดสินใจด้วย if...else

คำสั่ง `if` ใช้ตรวจสอบเงื่อนไข หากผลเป็นจริง โปรแกรมจะทำงานในส่วนที่กำหนดไว้ ส่วน `else` ใช้ระบุสิ่งที่ต้องทำเมื่อเงื่อนไขไม่เป็นจริง การตรวจสอบเงื่อนไขจึงช่วยให้โปรแกรมตอบสนองต่อข้อมูลที่แตกต่างกันได้
const score = 72;

if (score >= 50) {
    console.log('ผ่าน');
} else {
    console.log('ไม่ผ่าน');
}
ในตัวอย่างนี้ `score >= 50` เป็นนิพจน์เปรียบเทียบ หากคะแนนเท่ากับหรือมากกว่า 50 ผลจะเป็น `true` และโปรแกรมแสดงคำว่า “ผ่าน” แต่หากคะแนนต่ำกว่า 50 ผลจะเป็น `false` และโปรแกรมเข้าสู่ส่วน `else`
ตัวดำเนินการความหมายตัวอย่าง
===เท่ากันทั้งค่าและชนิดข้อมูล5 === 5 เป็น true
!==ไม่เท่ากันทั้งค่าและชนิดข้อมูล5 !== '5' เป็น true
>มากกว่า8 > 3 เป็น true
<น้อยกว่า2 < 7 เป็น true
>=มากกว่าหรือเท่ากับ50 >= 50 เป็น true
<=น้อยกว่าหรือเท่ากับ40 <= 50 เป็น true
ระวังการเปรียบเทียบควรใช้ `===` เมื่อต้องการตรวจสอบทั้งค่าและชนิดข้อมูล เช่น `5 === '5'` จะได้ `false` เพราะค่าด้านหนึ่งเป็นตัวเลข แต่อีกด้านเป็นข้อความ

3. ตรวจสอบหลายเงื่อนไข

บางสถานการณ์มีมากกว่าสองผลลัพธ์ เช่น การแบ่งระดับคะแนน เราสามารถใช้ `else if` เพื่อตรวจสอบเงื่อนไขเพิ่มเติม โดยโปรแกรมจะตรวจจากบนลงล่างและทำงานในส่วนแรกที่มีเงื่อนไขเป็นจริง
const score = 86;

if (score >= 80) {
    console.log('ระดับดีมาก');
} else if (score >= 70) {
    console.log('ระดับดี');
} else if (score >= 50) {
    console.log('ผ่าน');
} else {
    console.log('ควรทบทวนบทเรียน');
}
เมื่อ `score` มีค่า 86 เงื่อนไขแรกเป็นจริง โปรแกรมจึงแสดง “ระดับดีมาก” และไม่ตรวจสอบเงื่อนไข `else if` ที่เหลือต่อในชุดคำสั่งเดียวกัน หากเปลี่ยนคะแนนเป็น 74 โปรแกรมจะข้ามเงื่อนไขแรกและเข้าสู่ระดับดี

ใช้ตัวดำเนินการทางตรรกะ

ตัวดำเนินการ `&&` หมายถึงเงื่อนไขทั้งสองต้องเป็นจริง ส่วน `||` หมายถึงมีอย่างน้อยหนึ่งเงื่อนไขเป็นจริง และ `!` ใช้กลับค่าความจริงของนิพจน์
const age = 20;
const hasTicket = true;

if (age >= 18 && hasTicket) {
    console.log('อนุญาตให้เข้า');
} else {
    console.log('ยังไม่สามารถเข้าได้');
}
จำให้ขึ้นใจ`&&` เหมาะกับกรณีที่ต้องผ่านทุกข้อ เช่น อายุถึงเกณฑ์และมีบัตร ส่วน `||` เหมาะกับกรณีที่ยอมรับทางเลือกอย่างใดอย่างหนึ่ง

4. ฟังก์ชันคืออะไร

ฟังก์ชัน (Function) คือชุดคำสั่งที่ตั้งชื่อไว้เพื่อเรียกใช้งานเมื่อจำเป็น แทนที่จะคัดลอกโค้ดเดิมหลายครั้ง เราสามารถเขียนฟังก์ชันเพียงครั้งเดียว แล้วเรียกใช้ซ้ำด้วยข้อมูลที่แตกต่างกันได้
function greet() {
    console.log('สวัสดี ยินดีต้อนรับสู่ JavaScript');
}

greet();
greet();
คำว่า `function` ใช้ประกาศฟังก์ชัน `greet` คือชื่อฟังก์ชัน วงเล็บ `()` ใช้สำหรับรับพารามิเตอร์ และเครื่องหมายปีกกา `{}` ครอบชุดคำสั่ง เมื่อเรียก `greet()` โปรแกรมจะทำงานภายในฟังก์ชันนั้น

5. ส่งข้อมูลเข้าไปในฟังก์ชัน

ฟังก์ชันสามารถรับข้อมูลผ่านพารามิเตอร์ (Parameter) ซึ่งเป็นชื่อตัวแปรที่ประกาศไว้ในฟังก์ชัน ส่วนค่าจริงที่ส่งเข้าไปขณะเรียกใช้เรียกว่าอาร์กิวเมนต์ (Argument)
function greetUser(name) {
    console.log(`สวัสดี ${name}`);
}

greetUser('มิน');
greetUser('นัท');
เมื่อเรียก `greetUser('มิน')` ค่าข้อความ 'มิน' จะถูกส่งเข้าไปยังพารามิเตอร์ `name` ทำให้ฟังก์ชันแสดงคำทักทายของมินได้ และเมื่อเรียกด้วยชื่ออื่น ฟังก์ชันเดิมก็ทำงานกับข้อมูลใหม่ได้ทันที

6. ใช้ return เพื่อส่งค่ากลับ

คำสั่ง `return` ใช้ส่งผลลัพธ์กลับไปยังจุดที่เรียกฟังก์ชัน เมื่อฟังก์ชันทำงานถึง `return` การทำงานของฟังก์ชันนั้นจะสิ้นสุดลงทันที ค่าที่ส่งกลับสามารถนำไปเก็บในตัวแปรหรือใช้คำนวณต่อได้
function calculateTotal(price, quantity) {
    return price * quantity;
}

const total = calculateTotal(120, 3);
console.log(`ยอดรวม ${total} บาท`);
ตัวอย่างนี้ส่งราคา 120 และจำนวน 3 เข้าไปในฟังก์ชัน ผลคูณคือ 360 จากนั้น `return` ส่งค่า 360 กลับมาเก็บไว้ในตัวแปร `total` ก่อนนำไปแสดงผล
console.log กับ return ต่างกันอย่างไร`console.log()` ใช้แสดงข้อมูลในคอนโซล ส่วน `return` ใช้ส่งค่ากลับจากฟังก์ชัน การแสดงผลไม่ได้ทำให้ค่ากลายเป็นผลลัพธ์ที่เรียกนำไปคำนวณต่อได้โดยอัตโนมัติ

7. ตัวอย่างประยุกต์: ตรวจสอบคะแนนด้วยฟังก์ชัน

เมื่อเข้าใจทั้งเงื่อนไขและฟังก์ชันแล้ว เราสามารถนำมารวมกันเพื่อสร้างฟังก์ชันที่รับคะแนนและส่งผลการประเมินกลับมา โดยแยกหน้าที่การตัดสินใจออกจากการแสดงผล
function evaluateScore(score) {
    if (typeof score !== 'number' || score < 0 || score > 100) {
        return 'คะแนนไม่ถูกต้อง';
    }

    if (score >= 80) {
        return 'ดีมาก';
    }

    if (score >= 50) {
        return 'ผ่าน';
    }

    return 'ควรทบทวนบทเรียน';
}

const resultA = evaluateScore(92);
const resultB = evaluateScore(65);
const resultC = evaluateScore(35);
const resultD = evaluateScore(120);

console.log(resultA);
console.log(resultB);
console.log(resultC);
console.log(resultD);
คะแนนที่ส่งเข้าไปค่าที่ฟังก์ชันส่งกลับเหตุผล
92ดีมากคะแนนตั้งแต่ 80 ขึ้นไป
65ผ่านคะแนนตั้งแต่ 50 แต่ต่ำกว่า 80
35ควรทบทวนบทเรียนคะแนนต่ำกว่า 50
120คะแนนไม่ถูกต้องคะแนนเกินช่วง 0–100
การตรวจสอบ `typeof score !== 'number'` ช่วยปฏิเสธค่าที่ไม่ใช่ตัวเลข ส่วนการตรวจช่วงคะแนนช่วยป้องกันข้อมูลที่อยู่นอกขอบเขตที่ยอมรับได้ อย่างไรก็ตาม หากข้อมูลมาจากแบบฟอร์มหรือ API ควรตรวจสอบและแปลงชนิดข้อมูลอย่างเหมาะสมก่อนนำมาใช้งาน

8. Arrow Function รูปแบบฟังก์ชันที่กระชับ

JavaScript รองรับ Arrow Function ซึ่งใช้เครื่องหมาย `=>` เพื่อเขียนฟังก์ชันในรูปแบบกระชับ เหมาะกับฟังก์ชันสั้น ๆ และการส่งฟังก์ชันเป็นค่าให้คำสั่งอื่นใช้งาน
function add(a, b) {
    return a + b;
}

const addArrow = (a, b) => a + b;

console.log(add(4, 6));
console.log(addArrow(4, 6));
ทั้งสองฟังก์ชันในตัวอย่างให้ผลลัพธ์เหมือนกัน คือ 10 สำหรับ Arrow Function ที่มีนิพจน์เดียวและไม่ใช้วงเล็บปีกกา สามารถละคำว่า `return` ได้ แต่หากใช้ `{}` เพื่อเขียนหลายคำสั่ง จะต้องระบุ `return` เองเมื่อต้องการส่งค่ากลับ

9. ข้อผิดพลาดที่มือใหม่ควรหลีกเลี่ยง

ข้อผิดพลาดผลที่อาจเกิดขึ้นแนวทางแก้ไข
ใช้ `=` แทน `===`เป็นการกำหนดค่าแทนการเปรียบเทียบเลือกตัวดำเนินการให้ตรงกับสิ่งที่ต้องการ
ลืมวงเล็บปีกกาในชุดคำสั่งที่ซับซ้อนทำให้ขอบเขตการทำงานไม่เป็นไปตามที่ตั้งใจใช้ `{}` เพื่อแบ่งบล็อกคำสั่งให้ชัดเจน
ลืมส่งค่าด้วย `return`ผลลัพธ์ของฟังก์ชันอาจเป็น `undefined`ตรวจว่าฟังก์ชันต้องส่งค่ากลับหรือเพียงแสดงผล
ตั้งชื่อฟังก์ชันไม่สื่อความหมายอ่านและดูแลโค้ดยากขึ้นใช้ชื่อที่บอกหน้าที่ เช่น `calculateTotal`
ไม่ตรวจสอบข้อมูลขาเข้าเกิดผลลัพธ์ที่ไม่ถูกต้องเมื่อได้รับข้อมูลผิดรูปแบบตรวจชนิดข้อมูลและขอบเขตที่ยอมรับ

10. แบบฝึกหัดท้ายบท

ลองเขียนฟังก์ชัน `calculateDiscount(price, percent)` เพื่อคำนวณราคาหลังหักส่วนลด โดย `price` คือราคาเต็ม และ `percent` คือเปอร์เซ็นต์ส่วนลด เช่น ราคา 500 บาท ลด 10% ต้องได้ราคาสุทธิ 450 บาท จากนั้นปรับฟังก์ชันให้ตรวจสอบว่าราคาไม่ติดลบและเปอร์เซ็นต์ส่วนลดอยู่ระหว่าง 0 ถึง 100
function calculateDiscount(price, percent) {
    if (typeof price !== 'number' || typeof percent !== 'number') {
        return 'ข้อมูลต้องเป็นตัวเลข';
    }

    if (price < 0 || percent < 0 || percent > 100) {
        return 'ข้อมูลอยู่นอกช่วงที่ยอมรับ';
    }

    const discount = price * percent / 100;
    return price - discount;
}

console.log(calculateDiscount(500, 10));
console.log(calculateDiscount(250, 20));
console.log(calculateDiscount(100, 100));
เฉลยแนวคิดคำนวณส่วนลดด้วย `price * percent / 100` แล้วนำส่วนลดไปลบจากราคาเต็ม สำหรับราคา 500 บาทและส่วนลด 10% จะได้ส่วนลด 50 บาท และราคาสุทธิ 450 บาท

11. สรุปสิ่งที่ได้เรียนรู้

ตอนนี้เราได้เรียนรู้วิธีให้ JavaScript ตัดสินใจด้วย `if...else` การตรวจสอบหลายเงื่อนไข การสร้างฟังก์ชัน การส่งพารามิเตอร์ และการใช้ `return` เพื่อส่งผลลัพธ์กลับ เรารวมแนวคิดเหล่านี้เข้าด้วยกันเพื่อสร้างฟังก์ชันที่ตรวจสอบคะแนนและคำนวณส่วนลดได้
โปรแกรมที่ดีไม่ได้มีเพียงคำสั่งที่ทำงานได้ แต่ควรมีโครงสร้างที่อ่านเข้าใจ ตรวจสอบได้ และนำกลับมาใช้ซ้ำได้
ตอนต่อไปEP. 4: Array และ Loop — เรียนรู้การเก็บข้อมูลหลายรายการไว้ในชุดเดียว และใช้ลูปประมวลผลข้อมูลโดยไม่ต้องเขียนคำสั่งซ้ำทีละรายการ
อ่านจนถึงระยะ 500px ก่อนท้ายหน้าและอยู่ในหน้านี้อย่างน้อย 5 นาที เพื่อรับ EXP วันละครั้ง

⏳ กำลังจับเวลาอ่าน...

🌐
เลือกภาษา / Select Language
21 World Languages Supported