การใช้งาน While Loop ในภาษา Dart แบบง่ายๆ

While Loop คืออะไร?

While Loop เป็นหนึ่งในโครงสร้างการควบคุมการทำงานที่ช่วยให้โปรแกรมสามารถทำงานซ้ำ ในการทำงานของ While Loop จะมีการตรวจสอบเงื่อนไขซึ่งเมื่อเงื่อนไขนั้นเป็นจริง โปรแกรมจะทำการประมวลผลเนื้อหาภายในลูปซ้ำไปเรื่อยๆ จนกว่าเงื่อนไขจะเป็นเท็จ

รูปแบบของ While Loop ในภาษา Dart

โครงสร้างพื้นฐานของ While Loop ในภาษา Dart มีลักษณะตามนี้:

 while (condition) {
  // คำสั่งที่ต้องทำซ้ำ
}

ตัวอย่างโค้ด While Loop

มาดูตัวอย่างโค้ดที่ใช้งาน While Loop เพื่อหาผลรวมของตัวเลข 1 ถึง 10 กันดีกว่า:

 void main() {
  int sum = 0;
  int number = 1;

  while (number <= 10) {
    sum += number; // เพิ่มค่าตัวเลขลงใน sum
    number++; // ไปยังตัวเลขถัดไป
  }

  print('ผลรวมของตัวเลขจาก 1 ถึง 10 คือ: $sum');
}

การอธิบายการทำงานของโค้ด

1. เริ่มต้นด้วยการสร้างตัวแปร `sum` เพื่อใช้เก็บผลรวมเริ่มต้นที่ 0 และตัวแปร `number` เพื่อนับตัวเลขเริ่มต้นที่ 1

2. While Loop จะทำงานโดยตรวจสอบเงื่อนไข `number <= 10` หากเงื่อนไขเป็นจริง โปรแกรมจะเข้าสู่ลูป

3. ในลูป เราจะบวกค่าของ `number` เก็บลงในตัวแปร `sum` และเพิ่มค่าของ `number` เพื่อเตรียมการในรอบถัดไป

4. เมื่อ `number` เพิ่มขึ้นเป็น 11 เงื่อนไข `number <= 10` จะเป็นเท็จ ทำให้ลูปหยุดทำงาน

5. ผลลัพธ์สุดท้ายจะแสดงการพิมพ์ผลรวมที่คำนวณได้

ตัวอย่าง Use Case ในโลกจริง

เพื่อให้เห็นภาพชัดเจนขึ้น เรามาดู Use Case ที่สามารถใช้ While Loop ในการควบคุมการทำงานในโลกจริงกันดีกว่า

#### การตรวจสอบสถานะบัญชีธนาคาร

ลองนึกถึงระบบธนาคารที่นักพัฒนาระบบต้องการสร้างฟังก์ชั่นให้ผู้ใช้ตรวจสอบยอดเงินของบัญชี โดยมีตัวเลือกให้ผู้ใช้โอนเงินหรือถอนเงิน และต้องทำการตรวจสอบว่ายอดเงินเพียงพอต่อการทำธุรกรรมหรือไม่ การใช้ While Loop จะช่วยให้โปรแกรมสนใจในการทำงานซ้ำจนกว่าผู้ใช้จะเลือกออกจากโปรแกรม

 import 'dart:io';

void main() {
  double balance = 1000.0; // ยอดเงินเริ่มต้น
  String command = '';

  while (command != 'exit') {
    print('ยอดเงินปัจจุบัน: \$${balance}');
    print('กรุณาเลือกคำสั่ง: deposit, withdraw, exit');
    command = stdin.readLineSync()!;

    if (command == 'deposit') {
      print('กรุณากรอกจำนวนเงินที่ต้องการฝาก:');
      double amount = double.parse(stdin.readLineSync()!);
      balance += amount;
      print('ฝากเงินเรียบร้อยแล้ว');
    } else if (command == 'withdraw') {
      print('กรุณากรอกจำนวนเงินที่ต้องการถอน:');
      double amount = double.parse(stdin.readLineSync()!);
      if (amount <= balance) {
        balance -= amount;
        print('ถอนเงินเรียบร้อยแล้ว');
      } else {
        print('ยอดเงินไม่เพียงพอ');
      }
    } else if (command != 'exit') {
      print('คำสั่งไม่ถูกต้อง โปรดลองใหม่อีกครั้ง');
    }
  }

  print('ขอบคุณที่ใช้บริการ');
}

#### การอธิบายการทำงานใน Use Case

1. เริ่มต้นด้วยการประกาศตัวแปร `balance` เพื่อเก็บยอดเงินเริ่มต้น และตัวแปร `command` เพื่อเก็บคำสั่งที่ผู้ใช้กรอก

2. While Loop จะใช้ควบคุมการทำงานจนกว่าผู้ใช้จะเลือกคำสั่ง `exit`

3. ทุกครั้งที่มีการวนลูป โปรแกรมจะแสดงยอดเงินปัจจุบันและให้ผู้ใช้เลือกคำสั่ง

4. หากผู้ใช้เลือกฝากเงิน (`deposit`) โปรแกรมจะเพิ่มยอดเงินตามที่ผู้ใช้กรอก

5. หากผู้ใช้เลือกถอนเงิน (`withdraw`) จะมีการตรวจสอบว่ามีเงินเพียงพอต่อการถอนหรือไม่

6. ในกรณีที่ยอดเงินไม่เพียงพอ โปรแกรมจะแจ้งเตือน

7. ลูปนี้จะทำซ้ำจนกว่าผู้ใช้จะเลือกที่จะออกจากโปรแกรมด้วยคำสั่ง `exit`

สรุป

การใช้ While Loop เป็นหนึ่งในวิธีที่มีประสิทธิภาพในการควบคุมการทำงานหลายครั้งในภาษา Dart ที่เราสามารถนำมาประยุกต์ใช้ในหลายๆ โครงการจริงได้ ไม่ว่าจะเป็นการคำนวณเลข การตรวจสอบข้อมูล หรือการบริหารจัดการระบบต่างๆ

หากคุณมีความสนใจในการเรียนรู้ภาษา Dart และการเขียนโปรแกรมอย่างลึกซึ้ง และอยากจะพัฒนาทักษะในด้านนี้ให้เป็นมืออาชีพ เราขอเชิญชวนคุณมาเข้าร่วมศึกษา Programming ที่ EPT (Expert-Programming-Tutor) ที่นี่คุณจะได้พบกับหลักสูตรการเรียนการสอนที่มีคุณภาพ และได้รับความรู้จากผู้เชี่ยวชาญโดยตรง โปรแกรมการสอนที่หลากหลาย ทำให้คุณสามารถนำความรู้ที่ได้ไปใช้ในชีวิตจริงได้อย่างมีประสิทธิภาพ

ถ้าคุณอยากเป็นนักพัฒนาที่มีทักษะสูง ไม่ควรรอช้า! มาเรียนรู้ร่วมกันที่ EPT กันเถอะ!

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