แบบฝึกหัด - สร้างและกําหนดค่าสําหรับการวนรอบการทําซ้ํา

14 นาที

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

ข้อความนี้ `for` คืออะไร?

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

นอกจากนี้คําสั่ง for ยังช่วยให้คุณสามารถควบคุมกระบวนการทําซ้ําได้มากขึ้นโดยเปิดเผยเงื่อนไขสําหรับการทําซ้ํา

ในแบบฝึกหัดนี้ คุณจะใช้ for คําสั่ง เพื่อเรียนรู้วิธีการควบคุมเงื่อนไขก่อนการทําซ้ํา สภาพการทํางาน รูปแบบการทําซ้ํา และอื่น ๆ นอกจากนี้ คุณจะได้เรียนรู้กรณีการใช้งานทั่วไปสําหรับ for คําสั่ง

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

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

โมดูลนี้ประกอบด้วยกิจกรรมลงมือทําซึ่งจะแนะนําคุณตลอดกระบวนการสร้างและเรียกใช้รหัสการสาธิต เราขอแนะนําให้คุณทํากิจกรรมเหล่านี้ให้เสร็จสมบูรณ์โดยใช้ 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# นี้เพื่อสร้าง สร้าง และเรียกใช้ตัวอย่างโค้ดในระหว่างโมดูลนี้
ปิดแผงเทอร์มินัล

เขียนพื้นฐานสําหรับคําสั่ง

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

หมายเหตุ

Program.cs ควรว่างเปล่า ถ้าไม่ ให้เลือกและลบบรรทัดรหัสทั้งหมด
พิมพ์โค้ดต่อไปนี้ลงใน Visual Studio Code Editor
```
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}
```
รหัสนี้แสดงคําสั่งอย่างง่ายforที่วนรอบผ่านบล็อกโค้ด 10 ครั้ง พิมพ์ค่าปัจจุบันของi
บนเมนู ไฟล์ของ Visual Studio Code เลือก บันทึก

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

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

หมายเหตุ

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

คุณควรเห็นผลลัพธ์ต่อไปนี้
```
0
1
2
3
4
5
6
7
8
9
```
ใช้เวลาสักครู่เพื่อระบุหกส่วนของ for คําสั่ง

คําสั่ง for ประกอบด้วยหกส่วนต่อไปนี้:
1. คําสําคัญ for
2. ชุดของวงเล็บที่กําหนดเงื่อนไขของการ for ทําซ้ํา วงเล็บประกอบด้วยส่วนที่แตกต่างกันสามส่วน ซึ่งคั่นด้วยจุดสิ้นสุดของตัวดําเนินการคําสั่ง เครื่องหมายอัฒภาค
3. ส่วนแรกจะกําหนดและเตรียมใช้งานตัวแปรตัวทําซ้ํา ในตัวอย่างนี้: int i = 0 ส่วนนี้เรียกว่าตัวกําหนดค่าเริ่มต้น
4. ส่วนที่สองกําหนดเงื่อนไขการเสร็จสมบูรณ์ ในตัวอย่างนี้: i < 10 กล่าวอีกนัยหนึ่ง รันไทม์จะทําซ้ําโค้ดในบล็อกโค้ดด้านล่างforคําสั่ง ขณะที่iน้อยกว่า10 เมื่อ i เท่ากับ 10รันไทม์จะหยุดการดําเนินการ for บล็อกรหัสของคําสั่ง เอกสารอ้างอิงถึงส่วนนี้เป็นเงื่อนไข
5. ส่วนที่สามกําหนดการดําเนินการที่จะดําเนินการหลังจากการทําซ้ําแต่ละครั้ง ในกรณีนี้ หลังจากการ i++ ทําซ้ําแต่ละครั้ง จะเพิ่มค่าของ i ด้วย 1 เอกสารจะอ้างอิงไปยังส่วนนี้ในฐานะตัวทําซ้ํา
6. ในท้ายที่สุด บล็อกรหัส บล็อกรหัสประกอบด้วยรหัสที่จะดําเนินการสําหรับการทําซ้ําแต่ละครั้ง โปรดสังเกตว่าค่าของ i ถูกอ้างอิงภายในบล็อกโค้ด เอกสารอ้างอิงไปยังส่วนนี้เป็น เนื้อความ
เมื่อกําหนดกฎสําหรับการตั้งชื่อตัวแปร คุณอาจสงสัยว่า i เป็นชื่อที่ถูกต้องสําหรับตัวแปรที่มีการเกิดซ้ําปัจจุบันหรือไม่ ในกรณีนี้ i ถือว่ามีผลบังคับใช้มากที่สุด ตัวเลือกที่ได้รับความนิยมอื่น ๆ คือ x และcounter นอกจากนี้ ชื่อjจะถูกใช้ในสถานการณ์เหล่านั้นเมื่อคุณมีคําสั่งภายนอกforที่ใช้ iและจําเป็นต้องสร้างตัวแปรการทําซ้ําสําหรับคําสั่งภายในfor

หมายเหตุ

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

เปลี่ยนเงื่อนไขการเกิดซ้ํา

ดังที่เราระบุไว้ณ จุดเริ่มต้น for คําสั่งมีคุณสมบัติไม่ซ้ํากันสองอย่างในคําสั่งการทําซ้ํา

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

จะเกิดอะไรขึ้นถ้าเราจําเป็นต้องทําซ้ําผ่านบล็อกของรหัส แต่ต้องการนับถอยหลังแทนที่จะนับจํานวน?

ใช้ Visual Studio Code Editor เพื่ออัปเดตโค้ดของคุณดังต่อไปนี้:
```
for (int i = 10; i >= 0; i--)
{
    Console.WriteLine(i);
}
```
ใช้เวลาสักครู่เพื่อตรวจสอบรหัสที่อัปเดตแล้ว

โดยการเปลี่ยนสามส่วนของคําสั่ง เราจะเปลี่ยนลักษณะการทํางานของ for คําสั่ง
- เราเริ่มต้นตัวแปรการเกิดซ้ําเป็น 10
- เราเปลี่ยนเงื่อนไขความสมบูรณ์เพื่อออกจากforคําสั่งเมื่อiน้อยกว่า0
- เราเปลี่ยนรูปแบบของตัวทําซ้ําเพื่อลบ 1 ออกจาก i แต่ละครั้งที่เราดําเนินการทําซ้ําเสร็จสิ้น
บันทึกไฟล์โค้ดของคุณ จากนั้นใช้ Visual Studio Code เพื่อเรียกใช้โค้ดของคุณ

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

เมื่อคุณเรียกใช้รหัส คุณจะเห็นผลลัพธ์ต่อไปนี้
```
10
9
8
7
6
5
4
3
2
1
0
```

ทดลองกับรูปแบบของตัวทําซ้ํา

จะเกิดอะไรขึ้นถ้าเราต้องการข้ามค่าบางอย่างในตัวแปรตัวทําซ้ํา

ใช้ Visual Studio Code Editor เพื่ออัปเดตโค้ดของคุณดังต่อไปนี้:
```
for (int i = 0; i < 10; i += 3)
{
    Console.WriteLine(i);
}
```
ใช้เวลาสักครู่เพื่อตรวจสอบรหัสที่อัปเดตแล้ว

แทนที่จะเพิ่มหรือลดค่าของตัวแปรตัวทําซ้ําโดย 1เราใช้ i += 3 เพื่อข้ามสองค่าหลังจากการทําซ้ําแต่ละครั้ง
บันทึกไฟล์โค้ดของคุณ จากนั้นใช้ Visual Studio Code เพื่อเรียกใช้โค้ดของคุณ

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

เมื่อคุณเรียกใช้รหัส คุณจะเห็นผลลัพธ์ต่อไปนี้
```
0
3
6
9
```
เป็นที่ยอมรับว่าคุณจะไม่ทําสิ่งดังกล่าวบ่อย แต่หวังว่าคุณสามารถชื่นชมว่าคุณมีระดับการควบคุมการทําซ้ําอย่างละเอียดคุณควรต้องการ

ใช้คําสําคัญแบ่งเพื่อแบ่งคําสั่งการทําซ้ํา

จะเกิดอะไรขึ้นถ้าเราจําเป็นต้องออกจากคําสั่งการทําซ้ําอย่างไม่สมบูรณ์ตามเงื่อนไขบางอย่าง เราสามารถใช้ break คําสําคัญ

ใช้ Visual Studio Code Editor เพื่ออัปเดตโค้ดของคุณดังต่อไปนี้:
```
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
    if (i == 7) break;
}
```
ใช้เวลาสักครู่เพื่อตรวจสอบการใช้ break คําสําคัญในโค้ดที่อัปเดตแล้วของคุณ

ก่อนอื่นเราเห็น break คําสําคัญในโมดูล "สาขาโฟลว์ของโค้ดโดยใช้โครงสร้าง switch-case ใน C#" เมื่อปรากฎว่าเราสามารถใช้ break คําสําคัญเพื่อออกจากคําสั่งการทําซ้ําได้เช่นกัน
บันทึกไฟล์โค้ดของคุณ จากนั้นใช้ Visual Studio Code เพื่อเรียกใช้โค้ดของคุณ

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

เมื่อคุณเรียกใช้รหัส คุณจะเห็นผลลัพธ์ต่อไปนี้
```
0
1
2
3
4
5
6
7
```

วนรอบไปตามแต่ละองค์ประกอบของอาร์เรย์

การใช้งานทั่วไปสําหรับ for คําสั่งคือการทําซ้ําผ่านอาร์เรย์ขององค์ประกอบ โดยเฉพาะอย่างยิ่งถ้าคุณต้องการควบคุมลักษณะที่เกิดการทําซ้ํา ในขณะที่ทําซ้ํา foreach ผ่านทุกองค์ประกอบของอาร์เรย์ for สามารถปรับแต่งคําสั่งเพื่อให้มีการกําหนดเองเพิ่มเติม

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

string[] names = { "Alex", "Eddie", "David", "Michael" };
for (int i = names.Length - 1; i >= 0; i--)
{
    Console.WriteLine(names[i]);
}

ใช้เวลาสักครู่เพื่อตรวจสอบรหัสที่อัปเดตแล้ว

ก่อนอื่น ให้สังเกตว่าเราได้สร้างอินสแตนซ์ของอาร์เรย์สตริงที่ names ชื่อว่าประกอบด้วยสี่ชื่อ

ถัดไป โปรดสังเกตว่าเรากําลังใช้ Array.Length คุณสมบัติ เพื่อรับจํานวนองค์ประกอบในอาร์เรย์ และเรากําลังใช้ค่านี้เพื่อเริ่มต้นตัวแปรตัวทําซ้ําของเรา (int i = names.Length - 1) เราลบ 1 ออกจากค่า เนื่องจากหมายเลขดัชนีสําหรับองค์ประกอบอาร์เรย์เป็นไปตามศูนย์ (หมายเลขดัชนีของสี่องค์ประกอบคือ 0-3)

สุดท้าย สังเกตว่าเราได้เลือกทําซ้ําผ่านอาร์เรย์ ย้อนกลับ-- สิ่งที่เราไม่สามารถทําได้ด้วย foreach คําสั่ง เราใช้ค่าของตัวแปรการเกิดซ้ําภายในบล็อกรหัสเพื่อระบุหมายเลขดัชนีขององค์ประกอบอาร์เรย์ (names[i])
บันทึกไฟล์โค้ดของคุณ จากนั้นใช้ Visual Studio Code เพื่อเรียกใช้โค้ดของคุณ

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

เมื่อคุณเรียกใช้รหัส คุณจะเห็นผลลัพธ์ต่อไปนี้
```
Michael
David
Eddie
Alex
```
หมายเหตุ

เราสามารถวนใหม่ไปข้างหน้าผ่านองค์ประกอบอาร์เรย์ โดยการสร้างforคําสั่ง ดังนี้: for (int i = 0; i < names.Length; i++)

ตรวจสอบข้อจํากัดของคําสั่ง foreach

จะเกิดอะไรขึ้นถ้าคุณต้องการอัปเดตค่าในอาร์เรย์ในระหว่างการ foreach ทําซ้ํา

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

string[] names = { "Alex", "Eddie", "David", "Michael" };
foreach (var name in names)
{
    // Can't do this:
    if (name == "David") name = "Sammy";
}

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

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

หากคุณพยายามคอมไพล์และเรียกใช้โค้ดนี้ คุณจะเห็นข้อยกเว้น
```
Cannot assign to name because it is a 'foreach iteration variable'
```
กล่าวอีกนัยหนึ่ง คุณไม่สามารถกําหนดค่าของ name เนื่องจากเป็นส่วนหนึ่งของ foreach การใช้งานภายในของการเกิดซ้ํา

การเอาชนะข้อจํากัดของคําสั่ง foreach โดยใช้คําสั่ง สําหรับ

ลองใช้ for คําสั่ง เพื่อปรับเปลี่ยนเนื้อหาของอาร์เรย์ภายในบล็อกรหัสการทําซ้ํา

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

string[] names = { "Alex", "Eddie", "David", "Michael" };
for (int i = 0; i < names.Length; i++)
    if (names[i] == "David") names[i] = "Sammy";

foreach (var name in names) Console.WriteLine(name);

ใช้เวลาสักครู่เพื่อตรวจสอบรหัสที่อัปเดตแล้ว

โปรดสังเกตว่าเราได้ลบวงเล็บปีกกาออกจากบล็อกโค้ดที่มีโค้ดบรรทัดเดียวเท่านั้น การแก้ไขนี้ใช้เทคนิคเดียวกับที่เราพูดถึงในโมดูล "ควบคุมขอบเขตตัวแปรและตรรกะโดยใช้บล็อกโค้ดใน C#" นักพัฒนาหลายคนพบว่าสไตล์นี้ยากต่อการอ่านในขณะที่คนอื่นชอบสไตล์ตัวย่อนี้เพราะมันช่วยให้พวกเขาเขียนได้อย่างชัดเจนและแสดงออกมากขึ้น ถ้าคุณพบว่าโค้ดนี้อ่านยาก หรือถ้าคุณไม่ต้องการสไตล์นี้ โปรดวางใจว่าสามารถใช้วงเล็บปีกกาในบล็อกโค้ดของคุณได้เสมอ หากต้องการ ให้อัปเดตรหัสในแผงตัวแก้ไขด้วยรหัสต่อไปนี้:
```
string[] names = { "Alex", "Eddie", "David", "Michael" };

for (int i = 0; i < names.Length; i++)
{
    if (names[i] == "David")
    {
        names[i] = "Sammy";
    }
}

foreach (var name in names)
{
    Console.WriteLine(name);
}
```
บันทึกไฟล์โค้ดของคุณ จากนั้นใช้ Visual Studio Code เพื่อเรียกใช้โค้ดของคุณ

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

เมื่อคุณเรียกใช้รหัส คุณจะเห็นผลลัพธ์ต่อไปนี้
```
Alex
Eddie
Sammy
Michael
```
เนื่องจากอาร์เรย์ไม่ได้เป็นส่วนหนึ่งของการใช้งานคําสั่งทําซ้ําโดยตรง คุณสามารถเปลี่ยนค่าภายในอาร์เรย์ได้

สรุป

ต่อไปนี้เป็นตัวอย่างของประเด็นน่าลองในบทนี้:

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

คำติชม

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

แบบฝึกหัด - สร้างและกําหนดค่าสําหรับการวนรอบการทําซ้ํา

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

คำติชม