Java Academy · บทเรียน

ข้อควรระวังด้านความอ่านง่าย

เขียน expression ให้ชัดเจน

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

ความสามารถอันทรงพลังอาจลดความอ่านเข้าใจง่าย

นิพจน์เงื่อนไขสามส่วนกระชับ แต่การใช้มากเกินไปอาจทำให้โค้ดอ่านเป็นปริศนา

เป้าหมายคือความชัดเจน ไม่ใช่การใช้ตัวอักษรให้น้อยที่สุด บรรทัดที่ผู้อ่านไม่สามารถทำความเข้าใจได้ในพริบตาคือปัญหาที่พร้อมจะเกิดขึ้น

บทเรียนนี้ครอบคลุมจุดพลาดที่พบบ่อยและวิธีหลีกเลี่ยง

จุดพลาด: การซ้อนกันลึก

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

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

// hard to follow on one line
String g = s>=90?"A":s>=80?"B":s>=70?"C":s>=60?"D":"F";

วิธีแก้: ใช้เงื่อนไขหลายทางเลือก

เมื่อมีทางเลือกหลายทาง โครงสร้างแบบ if/else if จะชัดเจนกว่าการต่อเงื่อนไขเป็นสายยาว

แต่ละเงื่อนไขจะอยู่คนละบรรทัด ทำให้ตรวจดูและแก้จุดบกพร่องได้ง่าย

String g;
if (s >= 90) g = "A";
else if (s >= 80) g = "B";
else if (s >= 70) g = "C";
else g = "F";

จุดพลาด: ลืมใส่วงเล็บ

การใช้ตัวดำเนินการเงื่อนไขสามส่วนร่วมกับ + โดยไม่ใส่วงเล็บจะเปลี่ยนความหมายของนิพจน์

เนื่องจาก + มีลำดับการผูกแน่นกว่า ?: การต่อข้อความจึงอาจรวมส่วนหนึ่งของเงื่อนไขหรือค่าเข้าไปด้วย

int n = 5;
// surprising: + groups before ?:
String out = "n is " + n > 3 ? "big" : "small"; // does NOT compile as intended

วิธีแก้: ใส่วงเล็บครอบนิพจน์เงื่อนไขสามส่วน

ใส่วงเล็บให้นิพจน์เงื่อนไขสามส่วนที่ใช้ภายในการต่อข้อความเสมอ

วิธีนี้ทำให้ขอบเขตต่าง ๆ ชัดเจนและให้ผลลัพธ์ตามที่คาดไว้

public class Main {
    public static void main(String[] args) {
        int n = 5;
        String out = "n is " + (n > 3 ? "big" : "small");
        System.out.println(out);
    }
}

จุดพลาด: มีผลข้างเคียงอยู่ภายใน

การใส่การเรียกเมธอดที่มีผลข้างเคียงไว้ในทั้งสองทางเลือกทำให้มองไม่เห็นว่าอะไรจะทำงาน

มองเพียงคร่าว ๆ ได้ยากว่าการเรียกใดจะทำงาน ทั้งที่ในความเป็นจริงจะทำงานเพียงทางเลือกเดียว

หากการกระทำมีความสำคัญ ให้เลือกใช้โครงสร้างเงื่อนไขแทน

// unclear which side effect happens
boolean ok = check();
int r = ok ? save() : rollback();

จุดพลาด: ค่าของทางเลือกยาวเกินไป

เมื่อค่าของกรณีจริงหรือกรณีเท็จเป็นนิพจน์ยาว นิพจน์เงื่อนไขสามส่วนจะกลายเป็นกำแพงตัวอักษร

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

// cramped
double total = vip ? base*0.8 + tax + ship - coupon : base + tax + ship;

วิธีแก้: ตั้งชื่อค่า промежกลาง

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

ตอนนี้นิพจน์เงื่อนไขสามส่วนอ่านได้เหมือนภาษาธรรมดา

public class Main {
    public static void main(String[] args) {
        boolean vip = true;
        double regular = 100.0, discounted = 80.0;
        double total = vip ? discounted : regular;
        System.out.println(total);
    }
}

จุดพลาด: ความซ้ำซ้อนของบูลีน

การเขียน flag ? true : false เป็นสิ่งไม่จำเป็น เพราะเงื่อนไขนั้นเป็นค่าบูลีนอยู่แล้ว

ใช้เงื่อนไขโดยตรงได้เลย เช่นเดียวกัน flag ? false : true ก็คือ !flag นั่นเอง

boolean active = user != null;
// not: user != null ? true : false
boolean inactive = user == null;

จัดรูปแบบนิพจน์เงื่อนไขสามส่วนหลายบรรทัด

หากจำเป็นต้องใช้นิพจน์เงื่อนไขสามส่วนต่อไป การจัดรูปแบบจะช่วยได้ ให้วาง ? และ : ไว้ต้นบรรทัดและจัดแนวให้ตรงกัน

วิธีนี้จะเปลี่ยนสายเงื่อนไขให้เป็นโครงสร้างแบบขั้นบันไดที่อ่านง่าย

String tier = points >= 1000 ? "gold"
            : points >= 500  ? "silver"
            : "bronze";

รายการตรวจสอบความอ่านเข้าใจง่าย

ก่อนนำนิพจน์เงื่อนไขสามส่วนไปใช้ ให้ถามตัวเองว่า เป็นตัวเลือกง่าย ๆ เพียงหนึ่งอย่างหรือไม่ ชนิดข้อมูลเข้ากันได้หรือไม่ วงเล็บชัดเจนหรือไม่

หากมีคำตอบใดเป็นไม่ ให้เลือกใช้โครงสร้างเงื่อนไขหรือแยกตัวแปรออกมา โค้ดที่อ่านง่ายย่อมดีกว่าโค้ดที่ดูฉลาดแต่เข้าใจยาก

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

ลองสังเกตว่าการเขียนใหม่แบบใดอ่านง่ายกว่า

สรุปทบทวน

นิพจน์เงื่อนไขสามส่วนมีประโยชน์เมื่อยังคงเรียบง่าย หลีกเลี่ยงการซ้อนกันลึก การลืมใส่วงเล็บ ผลข้างเคียง และความซ้ำซ้อนของบูลีน

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

เมื่อไม่แน่ใจ ให้เลือกรูปแบบที่อ่านได้ชัดเจนที่สุด

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

บทเรียน “ข้อควรระวังด้านความอ่านง่าย” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ข้อควรระวังด้านความอ่านง่าย”

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

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

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

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

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

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

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

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

← กลับไปที่ Java Academy