คําสั่งรอบ X++

หมายเหตุ

กลุ่มความสนใจของชุมชนได้ย้ายจาก Yammer ไปยัง Microsoft Viva Engage แล้ว หากต้องการเข้าร่วมชุมชน Viva Engage และเข้าร่วมในการสนทนาล่าสุด ให้กรอก แบบฟอร์ม คําขอการเข้าถึงการเงินและการดําเนินงาน Viva Engage Community และเลือกชุมชนที่คุณต้องการเข้าร่วม

บทความนี้อธิบายคําสั่งรอบใน X++

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

สําหรับรอบ

ไวยากรณ์ของ สําหรับ การวนรอบ คือ:

สําหรับ (การเตรียมใช้งาน;ทดสอบ; ทดสอบการเพิ่ม) {statement}

คําสั่ง สําหรับ รอบ ซ้ํา ๆ จะดําเนินการตราบเท่าที่การทดสอบนิพจน์เงื่อนไขเป็นจริง ข้อความ อาจเป็นบล็อกของคําสั่ง เนื้อความของ สําหรับรอบ (คําสั่ง) อาจได้รับการดําเนินการเป็นศูนย์หรือหลายครั้ง ขึ้นอยู่กับผลลัพธ์ของการทดสอบ

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

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

ตัวอย่างของการวนรอบ

ในตัวอย่างรหัสต่อไปนี้ หน่วยข้อมูลในอาร์เรย์ของจํานวนเต็มจะถูกพิมพ์

int integers[10];
for (int i = 0; i < 10; i++)
{
    info(int2str(integers[i]));
}
// The output is a series of 0's.

ขณะที่วนรอบ

ไวยากรณ์ของลูป ขณะ คือ:

คําสั่งขณะ (นิพจน์)

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

ตัวอย่างของรอบในขณะที่

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

container cont = ["one", "two", "three"];
int no = 1;
while (no <= conlen(cont))
{
    info(conPeek(cont, no));
    no++;
}
// The output is "one", "two", "three".

ปฏิบัติ ขณะที่วนรอบ

ไวยากรณ์ของ do... ขณะที่ ลูปคือ:

ทํา {statement} ในขณะที่ (นิพจน์) ;

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

ตัวอย่างของ... รอบ ขณะ

ตัวอย่างรหัสต่อไปนี้ค้นหากําลังที่เล็กที่สุดของ 10 ที่มีขนาดใหญ่กว่าrealNumber

int FindPower(real realNumber)
{
    int exponent = -1;
    real curVal;

    do
    {
        exponent++;
        curVal = power(10, exponent);
    }
    while (realNumber > curVal);

    return exponent;
}

ดําเนินการต่อคําสั่ง

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

ตัวอย่างของคําสั่งดําเนินการต่อ

ในตัวอย่างรหัสต่อไปนี้ ถ้า Iarray[i] <= 0รอบ จะไม่ดําเนินการคําสั่งที่เหลือ การวนรอบจะ i เพิ่มก่อนที่จะลองคําสั่ง if อีกครั้ง

int Iarray[100];
for (int i = 0; i < 100; i++)
{
    if (Iarray[i] <= 0)
    {
        Info("Will continue.");
        continue;
    }

    info("Did not continue.");
}
// The output is "Will continue." for all 100 interations.

คําสั่งแบ่ง

ใช้คําสั่ง แบ่ง ภายในการวนรอบเพื่อยุติรอบนั้น การดําเนินการจะย้ายไปยังคําสั่งแรกหลังจากการวนรอบ

ตัวอย่างของคําสั่งหยุด

ตัวอย่างนี้ใช้คําสั่ง หยุด ภายใน ระยะเวลา หนึ่ง เมื่อใช้ภายในการวนรอบ คําสั่ง แบ่ง จะยุติรอบและการดําเนินการดําเนินการต่อจากคําสั่งตามรอบ ลักษณะการทํางานนี้ทํางานสําหรับ ... ในขณะที่ และ สําหรับ รอบ เช่นกัน

var mainMenu = SysDictMenu::newMainMenu();
var enum = mainMenu.getEnumerator();
var found = false;
while (enum.moveNext())
{
    var menuItem = enum.current();
    if (menuItem.label() == "StringOfInterest")
    {
        found = true;
        break;
    }
}
if (found) 
{
    // do something
}