แบบฝึกหัด - สร้างสิ่งที่ทําและในขณะที่วนรอบการทําซ้ํา

10 นาที

บนพื้นผิว do-while คําสั่ง และ while ยังเป็นคําสั่งการทําซ้ํา อีกคําสั่ง ที่ช่วยให้คุณสามารถทําซ้ําผ่านบล็อกรหัสและดังนั้นจึงเปลี่ยนการไหลของการดําเนินการของโค้ดของคุณ อย่างไรก็ตาม เมื่อเราตรวจสอบวิธีการทํางานแต่ละอย่าง เราสามารถระบุความแตกต่างของคําสั่งการทําซ้ําแต่ละคําสั่งได้ดียิ่งขึ้น และเมื่อใดที่ควรใช้

คําสั่ง do-while คืออะไร

คําสั่ง do-while จะดําเนินการคําสั่งหรือบล็อกของคําสั่งในขณะที่นิพจน์บูลีนที่ระบุประเมินเป็น true เนื่องจากนิพจน์นั้นจะถูกประเมินหลังจากการดําเนินการรอบแต่ละครั้ง การวนรอบ do-while จะดําเนินการอย่างน้อยหนึ่งครั้ง

do
{
    // This code executes at least one time
} while (true);

โฟลว์ของการดําเนินการเริ่มต้นภายในวงเล็บปีกกา โค้ดจะดําเนินการอย่างน้อยหนึ่งครั้ง จากนั้นนิพจน์บูลีนที่อยู่ถัดจาก while คําสําคัญจะถูกประเมิน หากนิพจน์บูลีนส่งกลับ trueระบบจะดําเนินการบล็อกโค้ดอีกครั้ง

ด้วยการเขียนโค้ดนิพจน์บูลีนแบบยากไปยัง trueเราได้สร้างลูปแบบวนรอบไม่มีที่สิ้นสุดซึ่งไม่สิ้นสุดอย่างน้อยไม่ใช่ตามที่เขียนไว้ในขณะนี้ เราจําเป็นต้องมีวิธีในการแยกออกจากรอบภายในของบล็อกโค้ด เราจะกล่าวถึงเกณฑ์ do-while การออกจากระบบสักเล็กน้อย

เอาล่ะ ตอนนี้เรามาเตรียมสภาพแวดล้อมการเขียนโค้ดของเราและเริ่มการตรวจสอบตัวอย่างโค้ดที่ใช้ do-while คําสั่ง

เตรียมสภาพแวดล้อมการเข้ารหัสของคุณ

โมดูลนี้ประกอบด้วยกิจกรรมลงมือทําซึ่งจะแนะนําคุณตลอดกระบวนการสร้างและเรียกใช้รหัสการสาธิต เราขอแนะนําให้คุณทํากิจกรรมเหล่านี้ให้เสร็จสมบูรณ์โดยใช้ Visual Studio Code เป็นสภาพแวดล้อมการพัฒนาของคุณ การใช้ Visual Studio Code สําหรับกิจกรรมเหล่านี้จะช่วยให้คุณเขียนและเรียกใช้โค้ดในสภาพแวดล้อมของนักพัฒนาที่มืออาชีพใช้ทั่วโลกได้อย่างสะดวกขึ้น

เปิด Visual Studio Code

คุณสามารถใช้เมนูเริ่มต้นของ Windows (หรือทรัพยากรที่เทียบเท่าสําหรับระบบปฏิบัติการอื่น) เพื่อเปิด Visual Studio Code
บนเมนู ไฟล์ รหัส Visual Studio เลือก เปิดโฟลเดอร์
ในกล่องโต้ตอบ เปิดโฟลเดอร์ ให้ไปยังโฟลเดอร์ Windows Desktop

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

ถ้าคุณเห็นกล่องโต้ตอบความปลอดภัยที่ถามว่าคุณเชื่อถือผู้เขียนหรือไม่ ให้เลือก ใช่
บนเมนู เทอร์มินัล Visual Studio Code ให้เลือก เทอร์มินัลใหม่

โปรดสังเกตว่าพร้อมท์คําสั่งในแผงเทอร์มินัล จะแสดงเส้นทางโฟลเดอร์สําหรับโฟลเดอร์ปัจจุบัน เช่น:
```
C:\Users\someuser\Desktop>
```
หมายเหตุ

ถ้าคุณกําลังทํางานบนพีซีของคุณเองแทนที่จะเป็น Sandbox หรือสภาพแวดล้อมที่เป็นโฮสต์ และคุณจบมอดูล Microsoft Learn อื่นๆ ใน C# ซีรี่ส์นี้ คุณอาจสร้างโฟลเดอร์โครงการสําหรับตัวอย่างโค้ดไว้แล้ว ถ้าเป็นกรณีนี้ คุณสามารถข้ามขั้นตอนถัดไป ซึ่งใช้เพื่อสร้างแอปคอนโซลในโฟลเดอร์ TestProject
ที่พรอมต์คําสั่งเทอร์มินัล หากต้องการสร้างแอปพลิเคชันคอนโซลใหม่ในโฟลเดอร์ที่ระบุ ให้ป้อนพร้อมท์ต่อไปนี้:
```
dotnet new console -o ./CsharpProjects/TestProject
```
คําสั่ง .NET CLI นี้ใช้เทมเพลตโปรแกรม .NET เพื่อสร้างโครงการแอปพลิเคชันคอนโซล C# ใหม่ในตําแหน่งที่ตั้งโฟลเดอร์ที่ระบุ คําสั่งจะสร้างโฟลเดอร์ CsharpProjects และ TestProject ให้คุณ และใช้ TestProject เป็นชื่อของไฟล์ของคุณ.csproj

ถ้ามีข้อความแสดงขึ้นเพื่อบอกให้คุณทราบว่ามีไฟล์อยู่แล้ว ให้ทําตามขั้นตอนถัดไป คุณจะใช้ไฟล์โครงการที่มีอยู่อีกครั้ง
ในมุมมอง EXPLORER ให้ขยายโฟลเดอร์ CsharpProjects

คุณควรเห็นโฟลเดอร์ TestProject และแฟ้มสองแฟ้ม แฟ้มโปรแกรม C# ที่ชื่อว่า Program.cs และแฟ้มโครงการ C# ที่ชื่อ TestProject.csproj
บนเมนู ไฟล์ รหัส Visual Studio เลือก เปิดโฟลเดอร์
ในกล่องโต้ตอบ เปิดโฟลเดอร์ เลือกโฟลเดอร์ CsharpProjects จากนั้นเลือก เลือกโฟลเดอร์
ในมุมมอง EXPLORER ให้ขยายโฟลเดอร์ TestProject จากนั้นเลือก Program.cs
ลบบรรทัดรหัสที่มีอยู่

คุณจะใช้โครงการคอนโซล C# นี้เพื่อสร้าง สร้าง และเรียกใช้ตัวอย่างโค้ดในระหว่างโมดูลนี้
ปิดแผงเทอร์มินัล

เขียนคําสั่ง do-while เพื่อแบ่งเมื่อสร้างตัวเลขสุ่มบางอย่าง

ลองเขียนโค้ดที่จะเก็บสร้างตัวเลขสุ่มระหว่าง 1 และ 10 จนกว่าเราจะสร้างตัวเลข 7 อาจใช้เวลาเพียงหนึ่งการเกิดซ้ําเพื่อรับ 7 หรืออาจต้องใช้การทําซ้ําหลายสิบครั้ง

ตรวจสอบให้แน่ใจว่าคุณมี Visual Studio Code เปิดและ Program.cs แสดงในแผง ตัวแก้ไข

หมายเหตุ

Program.cs ควรว่างเปล่า ถ้าไม่ ให้เลือกและลบบรรทัดรหัสทั้งหมด

พิมพ์โค้ดต่อไปนี้ลงใน Visual Studio Code Editor

Random random = new Random();
int current = 0;

do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);

บนเมนู ไฟล์ Visual Studio Code ให้เลือก บันทึก

ต้องบันทึกไฟล์ Program.cs ก่อนที่จะสร้างหรือเรียกใช้โค้ด
ในแผง EXPLORER ในการเปิดเทอร์มินัลที่ตําแหน่งโฟลเดอร์ TestProject ของคุณ ให้คลิกขวาที่ TestProjectจากนั้นเลือก เปิดในเทอร์มินัลแบบรวม

แผงเทอร์มินัลจะเปิดขึ้น เทอร์มินัลควรมีพร้อมท์คําสั่งที่แสดงว่าเทอร์มินัลเปิดอยู่ไปยังตําแหน่งที่ตั้งโฟลเดอร์ TestProject ของคุณ
ที่พร้อมท์คําสั่งเทอร์มินัล เมื่อต้องการเรียกใช้โค้ดของคุณ ให้พิมพ์ dotnet เรียกใช้ แล้วกด Enter

หมายเหตุ

ถ้าคุณเห็นข้อความ "ไม่พบโครงการที่จะเรียกใช้" ตรวจสอบให้แน่ใจว่าพร้อมท์คําสั่งเทอร์มินัลแสดงตําแหน่งที่ตั้งโฟลเดอร์ TestProject ที่คาดไว้ ตัวอย่าง: C:\Users\someuser\Desktop\csharpprojects\TestProject>
ตรวจสอบเอาต์พุตของคุณ

เนื่องจากตัวเลขที่สร้างขึ้นเป็นแบบสุ่ม ผลลัพธ์ของคุณจะแตกต่างกัน อย่างไรก็ตาม ค่า 7 จะเป็นตัวเลขสุดท้ายที่จะพิมพ์เป็นนิพจน์บูลีนจะประเมิน false เมื่อสร้าง 7 และโฟลว์ของการดําเนินการจะออกจากบล็อกรหัส
```
2
5
8
2
7
```
ใช้เวลาสักครู่ในการตรวจสอบรหัสของคุณ

การเรียนรู้ที่สําคัญสําหรับงานแรกนี้คือบล็อกรหัสของการ do-while วนรอบจะดําเนินการอย่างน้อยหนึ่งครั้ง มันสามารถทําซ้ําได้หลายครั้งและไม่น่าเป็นไปได้ที่เรารู้ล่วงหน้าว่ามีการเกิดซ้ํากี่ครั้ง

สิ่งสําคัญคือต้องสังเกตเห็นว่ารหัสภายในบล็อกโค้ดมีอิทธิพลไม่ว่าจะดําเนินการซ้ําผ่านบล็อกโค้ดหรือไม่ บล็อกรหัสที่มีผลต่อเกณฑ์การออกเป็นเหตุผลหลักในการเลือกคําสั่ง หรือ do-while แทนที่จะเป็นwhileคําสั่งการทําซ้ําอื่นๆ foreachทั้ง และ for ขึ้นอยู่กับปัจจัยที่อยู่ภายนอกบล็อกรหัสเพื่อกําหนดจํานวนการวนซ้ําของบล็อกรหัส

เขียนคําสั่งในขณะที่ทําซ้ําเฉพาะในขณะที่ตัวเลขสุ่มมากกว่าค่าบางค่า

ตอนนี้เรามาดูคําสั่ง while กัน

ใช้ Visual Studio Code Editor เพื่ออัปเดตโค้ดของคุณดังต่อไปนี้:
```
Random random = new Random();
int current = random.Next(1, 11);

/*
do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);
*/

while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
```
หมายเหตุ

ในกรณีนี้ เราจัด while ตําแหน่งคําสําคัญและนิพจน์บูลีนก่อนบล็อกโค้ด สิ่งนี้จะเปลี่ยนความหมายของโค้ดและทําหน้าที่เป็น "ประตู" เพื่ออนุญาตให้โฟลว์ของการดําเนินการเข้าหากนิพจน์บูลีนประเมินเป็นจริงเท่านั้น
บันทึกไฟล์โค้ดของคุณ จากนั้นใช้ Visual Studio Code เพื่อเรียกใช้โค้ดของคุณ

ใส่ dotnet run จากพร้อมท์คําสั่งเทอร์มินัล เพื่อเรียกใช้โค้ดของคุณ
ตรวจสอบค่าเอาต์พุตที่แสดงอยู่ในรายการ

เนื่องจากตัวเลขเป็นแบบสุ่ม ดังนั้นรหัสของคุณจะสร้างลําดับที่แตกต่างกัน
```
9
7
5
Last number: 1
```
ใช้เวลาสักครู่ในการตรวจสอบรหัสของคุณ

ที่รหัสด้านบน เราใช้ random เพื่อเริ่มต้นตัวแปรของเราintที่มีชื่อว่าcurrent บรรทัดรหัสที่ใช้งานอยู่ถัดไปของเราคือคําสั่งของเราwhile

คําสั่งของ while เราจะทําซ้ําตามนิพจน์ (current >= 3)บูลีน เราไม่ทราบว่าค่าใดจะถูกกําหนดให้กับ currentแต่มีความเป็นไปได้ที่ส่งผลกระทบต่อรอบของเรา while :
- หากมี current การเตรียมใช้งานเป็นค่าที่มากกว่าหรือเท่ากับ 3นิพจน์บูลีนจะส่งกลับ trueและโฟลว์ของการดําเนินการจะป้อนบล็อกรหัส ภายในบล็อกรหัสสิ่งแรกที่เราทําคือเขียนค่าของ current ไปยังคอนโซล ถัดไปยังคงอยู่ภายในบล็อกรหัสเราอัปเดตค่าของ current ด้วยค่าสุ่มใหม่ ณ จุดนี้ ตัวควบคุมจะกลับไปที่ด้านบนของ while คําสั่งที่มีการประเมินนิพจน์บูลีน กระบวนการนี้ดําเนินต่อจนกว่านิพจน์บูลีนจะ false ส่งกลับและโฟลว์ของการดําเนินการจะแบ่งออกจากบล็อกรหัส
- ถ้ามี current การเตรียมใช้งาน (ที่ด้านบนของรหัสของเรา) เป็นค่าที่น้อยกว่า 3นิพจน์บูลีนจะส่งกลับ falseและบล็อกโค้ดจะไม่ดําเนินการ
บรรทัดโค้ดสุดท้ายจะเขียนค่าของ current ไปยังคอนโซล รหัสนี้จะเรียกใช้ว่ามีการดําเนินการบล็อกโค้ดซ้ําหรือไม่ และเป็นโอกาสของเราในการเขียนค่าสุดท้ายของ current ไปยังคอนโซล

ใช้คําสั่งดําเนินการต่อเพื่อไปยังนิพจน์บูลีนโดยตรง

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

ใช้ Visual Studio Code Editor เพื่ออัปเดตโค้ดของคุณดังต่อไปนี้:

Random random = new Random();
int current = random.Next(1, 11);

do
{
    current = random.Next(1, 11);

    if (current >= 8) continue;

    Console.WriteLine(current);
} while (current != 7);

/*
while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
*/

ใช้เวลาสักครู่ในการตรวจสอบรหัสของคุณ

โปรดสังเกตว่าเราได้เปลี่ยนกลับไปเป็นdo-while do-whileทําให้แน่ใจว่ารอบจะทําซ้ําอย่างน้อยหนึ่งครั้ง

สิ่งแรกที่เราทําภายในบล็อกรหัสคือการกําหนดค่าแบบสุ่มใหม่เป็นcurrent ถัดไป เราจะตรวจสอบว่า มีค่ามากกว่าหรือเท่ากับ currentหรือไม่8 ถ้านิพจน์นี้ส่งกลับ truecontinue คําสําคัญจะโอนย้ายตัวควบคุมไปยังจุดสิ้นสุดของบล็อกรหัสและ while จะประเมิน(current != 7) ดังนั้น รอบจะยังคงทําซ้ําตราบเท่าที่ค่าของ current ไม่เท่ากับ7

กุญแจสําคัญของขั้นตอนนี้ของแบบฝึกหัดคือบรรทัดของโค้ดที่มี continue คําสําคัญ:
```
if (current >= 8) continue;
```
เนื่องจากโค้ดของเราที่เขียนค่าของ current ไปยังคอนโซลนั้นอยู่หลัง if (current >= 8) continue;โค้ดของเราทําให้แน่ใจว่าค่า current ที่มากกว่าหรือเท่ากับ 8 จะไม่ถูกเขียนลงในหน้าต่างเอาต์พุต

ลองใช้ดู
บันทึกไฟล์โค้ดของคุณ จากนั้นใช้ Visual Studio Code เพื่อเรียกใช้โค้ดของคุณ

ใส่ dotnet run จากพร้อมท์คําสั่งเทอร์มินัล เพื่อเรียกใช้โค้ดของคุณ
ตรวจสอบค่าเอาต์พุตที่แสดงอยู่ในรายการ
```
5
1
6
7
```
คุณอาจเห็นผลลัพธ์ที่แตกต่างจากที่แสดงด้านล่าง อย่างไรก็ตาม คุณจะไม่เห็นค่า8ใด ๆ หรือมากกว่าในหน้าต่างเอาต์พุตก่อนที่การดําเนินการของโค้ดจะลงท้ายด้วยค่า7
พิจารณาความแตกต่างระหว่างcontinueคําสั่ง และbreak

ตามที่คุณเห็นในขั้นตอน continue สุดท้ายนี้ คําสั่งจะโอนย้ายการดําเนินการไปยังจุดสิ้นสุดของการทําซ้ําปัจจุบัน ลักษณะการทํางานนี้จะแตกต่างจากลักษณะการทํางานที่เราเห็นด้วย break คําสั่ง คําสั่ง break ยุติการเกิดซ้ํา (หรือ switch) และโอนการควบคุมไปยังคําสั่งที่ทําตามคําสั่งที่สิ้นสุด ถ้าไม่มีคําสั่งหลังจากคําสั่งที่สิ้นสุดแล้ว ให้ควบคุมการโอนย้ายไปยังจุดสิ้นสุดของไฟล์หรือวิธีการ

สรุป

มีแนวคิดสําคัญสองสามประการที่คุณควรนําออกจากหน่วยนี้:

คําสั่ง do-while จะทําซ้ําผ่านบล็อกรหัสอย่างน้อยหนึ่งครั้ง และอาจดําเนินทําซ้ําโดยยึดตามนิพจน์บูลีน การประเมินผลของนิพจน์บูลีนมักจะขึ้นอยู่กับค่าบางอย่างที่สร้างขึ้นหรือเรียกใช้ภายในบล็อกรหัส
คําสั่ง ประเมินwhileนิพจน์บูลีนก่อนและยังคงทําซ้ําผ่านบล็อกโค้ดตราบเท่าที่นิพจน์บูลีนประเมินเป็นtrue
คํา continue สําคัญที่จะไปยังขั้นตอนทันทีไปยังนิพจน์บูลีน

ข้อใด ต่อไปนี้ อธิบายลักษณะการทํางานของคําสั่งหนึ่ง do-while หรือ while คําสั่งซ้ําได้อย่างถูกต้อง

do-whileคําสั่งดําเนินการบล็อกรหัสศูนย์หรือมากกว่านั้น

whileคําสั่งจะดําเนินการบล็อกรหัสอย่างน้อยหนึ่งครั้ง

do-whileคําสั่งจะดําเนินการบล็อกรหัสอย่างน้อยหนึ่งครั้ง

นักพัฒนาจําเป็นต้องจับภาพข้อมูลป้อนเข้าของผู้ใช้ภายในการวนรอบ ผู้ใช้ป้อนข้อมูลรวม ctrl + Esc แป้นพิมพ์เพื่อออกจากการเกิดซ้ําเมื่อพวกเขาป้อนข้อมูลเสร็จสิ้นแล้ว ข้อความการเกิดซ้ําที่ดีที่สุดสําหรับวัตถุประสงค์นี้คืออะไร

ขณะ

สำหรับ

ทําในขณะที่

คุณต้องตอบคำถามทั้งหมดก่อนที่จะตรวจสอบงานของคุณ

คำติชม

หน้านี้มีประโยชน์หรือไม่

แบบฝึกหัด - สร้างสิ่งที่ทําและในขณะที่วนรอบการทําซ้ํา

การประเมินความรู้

คำติชม