โครงสร้างการควบคุมทางเลือกใดที่มีประโยชน์ที่คุณรู้ [ปิด]

คำถามที่คล้ายกันถูกปิดใน SO

บางครั้งเมื่อเราเขียนโปรแกรมเราพบว่าโครงสร้างการควบคุมบางอย่างจะมีประโยชน์มากสำหรับเรา แต่ไม่สามารถใช้ได้โดยตรงในภาษาการเขียนโปรแกรมของเรา

โครงสร้างการควบคุมทางเลือกใดที่คุณคิดว่าเป็นวิธีที่มีประโยชน์ในการจัดระเบียบการคำนวณ

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

คุณสามารถสร้างไวยากรณ์ / ความหมายที่ปรารถนาไม่พร้อมใช้งานในขณะนี้หรืออ้างอิงโครงสร้างการควบคุมที่รู้จักน้อยในภาษาการเขียนโปรแกรมที่มีอยู่

รู้รอบควรให้แนวคิดสำหรับภาษาการเขียนโปรแกรมใหม่หรือปรับปรุงภาษาจริง

คิดว่านี่เป็นการระดมสมองดังนั้นโพสต์สิ่งที่คุณคิดว่าเป็นความคิดที่บ้า แต่มันสามารถทำงานได้ในบางสถานการณ์

มันเกี่ยวกับการเขียนโปรแกรมที่จำเป็น

ตกลงนี่เป็นคำถามที่สนุก

ฉันอยากจะมีนายพลอยู่elseครู่หนึ่งและเป็นห่วงเพราะเมื่อเงื่อนไขไม่เป็นจริงในการทดสอบครั้งแรก :

while (condition) {
    // process
}
else {
    // condition was never true
}

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

ทำไมไม่บดคำตอบเล็ก ๆ น้อย ๆ เป็นหนึ่งเดียว?

while (expr) {

    // Executed every iteration, unless first{} is present.
    // May be explicitly called rest{} if you like first{} to come first.

    // Blocks may return results, and consequently be used in expressions.
    return expr;

} first {

    // Executed only on the first iteration.

} pre {

    // Executed before every iteration.

} post {

    // Executed after every iteration.

} catch (oops) {

    // All blocks are implicitly try{}ed if followed by a catch{}.

} finally {

    // Executes after the block completes, regardless of exceptions.

} else {

    // Executed if the loop body or rest{} never executes.

} never {

    // Executes only when a client is present.

} drop (bad, worse), // Explicitly ignore certain exceptions.
  until (expr);      // Here, have a post-body condition, too.

ไวยากรณ์การสร้างโฟลว์คอนโทรลควบคุมทั่วไปที่ขยายได้ในภาษาที่จำเป็นจะค่อนข้างมีประโยชน์และสนุกสนาน จนกว่าสิ่งนั้นจะปรากฏขึ้นเดาว่าฉันจะใช้ Lisp หรืออะไรซักอย่าง

โครงสร้างการควบคุมเป็นฟังก์ชั่น

ฉันต้องการfor, if, else, whileฯลฯ จะเป็นฟังก์ชั่นโครงสร้างไม่ได้พิเศษ

ฉันต้องการreturn, try/exceptและgotoจะเป็นอนุพันธ์ของต

แน่นอนว่าสิ่งนี้มีส่วนเกี่ยวข้องกับโครงสร้างการควบคุมเฉพาะน้อยกว่าและอื่น ๆ เกี่ยวกับวิธีที่คุณเห็นโครงสร้างการควบคุมโดยทั่วไปคือเมตาของโครงสร้างการควบคุม

บทความที่เชื่อมโยงแน่นอนได้รับมันถูกต้องเกี่ยวกับโดนัลด์ของ Knuth N + 2/1 ลูป แสดงเป็น C / C ++ / Java:

for (;;) {
  get next element;
  if (at the end) break;
  process the element;
}

สิ่งนี้มีประโยชน์สำหรับการอ่านบรรทัดหรืออักขระจากไฟล์ทดสอบว่าคุณถึง EOF แล้วทำการประมวลผล ฉันเคยเห็นรูปแบบfor(;;)..if(..)break;ปรากฏว่ามันเป็นสำนวนให้ฉัน (ก่อนที่ฉันจะอ่านบทความ Knuth ที่พิมพ์ซ้ำในโปรแกรม Literate Programmingหนังสือเล่มนี้เคยเป็น "wtf?")

Knuth แนะนำคำหลักloop/while/repeat:

loop:
  S;
while C:
  T;
repeat

ที่ไหนSและTเป็นผู้ถือสถานที่สำหรับชุดของคำสั่งเป็นศูนย์หรือมากกว่าและCเป็นเงื่อนไขบูลีน หากไม่มีSคำสั่งก็จะเป็นวงในขณะที่และถ้าไม่มีTคำสั่งแล้วมันจะเป็นวงทำ

โครงสร้างนี้สามารถวางนัยโดยการอนุญาตให้มีwhile Cอนุประโยคเป็นศูนย์หรือมากกว่าทำให้เหมาะสำหรับการแสดงลูปไม่สิ้นสุดและจากนั้นเงื่อนไขที่หายากบางอย่างที่จะต้องใช้การตรวจสอบสองครั้ง

ในบทความเดียวกัน Knuth แนะนำกลไกการส่งสัญญาณที่จะเป็นข้อยกเว้นในการขว้างปา / จับได้ในท้องถิ่น (เป็นทางเลือกแทนการใช้ goto)

สำหรับฉัน? ฉันหวังว่า Java สนับสนุนหางเพิ่มประสิทธิภาพการโทรเพื่อที่ฉันจะแสดงใด ๆโครงสร้างการควบคุมทั่วไปตามความจำเป็น

อัปเดต:ฉันลืมที่จะพูดถึงว่าโปรแกรมเมอร์ C / C ++ / Java จำนวนมากหลีกเลี่ยงปัญหานี้โดยใช้การกำหนดแบบฝังในเงื่อนไขwhile:

while ((c = getc(f)) != -1) {
   T;
}

การใช้คำศัพท์จากโครงสร้างของ Knuth สิ่งนี้สามารถใช้ได้เมื่อSและCสามารถรวมกันเป็นนิพจน์เดียวได้ บางคนเกลียดที่จะเห็นการมอบหมายที่ฝังอยู่ด้านบนในขณะที่คนอื่นเกลียดที่จะเห็นbreakในfor (;;)ด้านบน แต่เมื่อใดSและCไม่สามารถรวมกันได้เช่นเมื่อSมีหลาย statement for (;;)มันเป็นทางเลือกเดียวโดยไม่ต้องใช้รหัสซ้ำ อีกทางเลือกหนึ่งคือการทำซ้ำSรหัส:

S;
while (C) {
  T;
  S;
}

loop/while/repeatทางเลือกของ Knuth นั้นดูดีกว่ามาก

ภาษา BCPL มีvalueofนิพจน์ที่สามารถใช้เปลี่ยนลำดับของข้อความเป็นนิพจน์เดียว:

foo(a, b, valueof {some series of statements; resultis v});

ไหนsome series of statementsสามารถเป็นอะไรก็ได้และทั้งประเมินvalueofv

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

หากคุณสามารถใช้finalสำหรับตัวแปรที่จำเป็นคุณสามารถทำได้valueofใน Java โดยใช้คลาสภายในที่ไม่ระบุชื่อ:

foo(a, b, new Object(){String valueof(){
    String v ...; some series of statements; return v;}}.valueof());

unless(condition) {
  // ...
}

ทำสิ่งเดียวกันกับ:

if(!condition) {
  // ...
}

repeat {
  // ...
} until(condition)

ทำสิ่งเดียวกันกับ:

do {
  // ...
} while(!condition)

ในบันทึกอื่นฉันต้องการดูการสนับสนุนที่ดีขึ้นสำหรับตัววนซ้ำในภาษาโปรแกรม โดยเฉพาะอย่างยิ่งสำหรับเมื่อคุณต้องการลงสองคอลเลกชันเป็นคู่ :

for (String s, Integer i : stringsSet, integersSet) {
    // use the pair (s, i)
}

ภาษาไดนามิกบางภาษาอาจมีสิ่งนี้อยู่แล้วหรือสนับสนุนผ่านทางไลบรารี่และมาโครอย่างง่ายดาย แต่ฉันคิดว่านี่เป็นคำถามของคุณ

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

โดยธรรมชาติคุณสามารถพูดคุยเรื่องนี้เพื่อลดรายการสามรายการขึ้นไป

ปรับปรุง:ยังมีประโยชน์ที่จะทำผลิตภัณฑ์คาร์ทีเซียนระหว่าง iterables:

for (String s, Integer i : stringsSet * integersSet) {
    // use the pair (s, i), each s with each i
}

ซึ่งจะไม่มีอะไรมากไปกว่าลูปซ้อนกัน:

for (String s : stringsSet) {
    for (Integer i : integersSet) {
        // use the pair (s, i), each s with each i
    }
}

ฉันกังวลเล็กน้อยว่าระหว่างสองสัญลักษณ์ที่ฉันมีให้ที่นี่มีความแตกต่างของ O (n) และ O (n ^ 2) ในจำนวนคู่โดยมีการเปลี่ยนแปลงเพียงตัวเดียว

มีสิ่งที่เรียกว่า "ห่วงของ Dijkstra" (เรียกอีกอย่างว่า "ห่วงรักษาความปลอดภัยของ Dijkstra") มันถูกกำหนดไว้ในยามคำสั่งภาษา (GCL) คุณสามารถหาข้อมูลเกี่ยวกับมันบางไวยากรณ์และความหมายในข้างต้นวิกิพีเดียบทความที่ส่วนที่ 6 การทำซ้ำ: ทำ

ทุกวันนี้ฉันรู้ภาษาการเขียนโปรแกรมภาษาเดียวที่รองรับการควบคุมนี้โดยตรง มันคือOberon-07 (PDF, 70 KB) และสนับสนุน "Dijkstra's Loop" ในรูปแบบของคำสั่ง while ดูหัวข้อ 9.6 ในขณะที่งบใน PDF ข้างต้น

WHILE m > n DO m := m – n 
ELSIF n > m DO n := n – m 
END

PS นี่เป็นสำเนาคำตอบ SO ของฉัน

การแสดงออกสไตล์ไอคอนด้วยการย้อนรอยในตัว

Python ได้รับประโยชน์จากเครื่องมือสร้างไอคอนจำนวนมาก - และทำงานได้ดีขึ้นโดยทั่วไป IMO และโดยหลักการแล้วการย้อนรอยเป็นเพียงข้อยกเว้น แต่มันคือความเรียบง่ายในการแสดงออกที่เทียบเท่ากับ ...

x = (a / b) else c;

การจัดการกรณีที่ล้มเหลวเช่นการหารด้วยศูนย์

ไอคอนไปที่ถั่ว - ไม่มีตัวดำเนินการเปรียบเทียบแบบบูลีนที่ส่งคืน การเปรียบเทียบประสบความสำเร็จหรือถูกกระตุ้นให้ย้อนรอยและมีปัญหาความหมายอื่น ๆ ซึ่งตอนนี้ฉันพยายามอย่างยิ่งที่จะจำได้ว่า ... เอาละเราแค่บอกว่ามันอาจจะถูกควบคุมมากกว่าที่ถูกลืม

ฉันมักจะคิดว่าพวกเขาควรจะมีการifแสดงออกโดยไม่มีส่วนอื่น - if (condition, success-value)ชนิดของสิ่งที่ย้อนกลับหากเงื่อนไขผลตอบแทนที่เป็นเท็จ - และวางการเปรียบเทียบที่แปลก

แก้ไขฉันจำได้ - ชัดเจนจริงๆ การเปรียบเทียบกับสองข้อโต้แย้งจะประสบความสำเร็จหรือล้มเหลว - มันไม่ได้คำนวณค่าใหม่เพื่อส่งกลับ ดังนั้นเมื่อมันประสบความสำเร็จในสิ่งที่ไม่มันกลับมา? คำตอบ - หนึ่งในข้อโต้แย้ง แต่ถ้าคุณเขียนa > bซึ่งเป็นเหตุผลตรรกะที่จะส่งกลับ - aหรือb? และถ้าคุณเขียนb < aแทนล่ะ ฉันคิดว่ามันมักจะส่งคืนอาร์กิวเมนต์ที่ถูกต้องซึ่งทำให้รู้สึกถึงอะไรก็ได้ แต่มันก็มักจะดูเหมือนว่าการโต้แย้งที่ผิดกับฉัน

นี่เป็นเพียงแนวคิดและไวยากรณ์ทั่วไป:

if (cond)
   //do something
else (cond)
   //do something
also (cond)
   //do something
else
   //do something
end

เงื่อนไข ALSO จะได้รับการประเมินเสมอ ELSE ทำงานได้ตามปกติ

มันใช้ได้กับกรณีด้วย อาจเป็นวิธีที่ดีในการกำจัดคำสั่ง break:

case (exp)
   also (const)
      //do something
   else (const)
      //do something
   also (const)
      //do something
   else
      //do something
end

สามารถอ่านได้เป็น:

switch (exp)
   case (const)
      //do something
   case (const)
      //do something
      break
   case (const)
      //do something
   default
      //do something
end

ฉันไม่รู้ว่าสิ่งนี้มีประโยชน์หรือง่ายต่อการอ่าน แต่เป็นตัวอย่าง

สไตล์ที่ต่อเนื่องผ่านการคำนึงถึง แน่นอนว่าคุณต้องมีTail Call Optimizationเช่นกัน

การแยกเธรดที่ไร้รอยต่อนั้นจะมีไวยากรณ์เหมือนฟังก์ชัน แต่ดำเนินการในเธรดแยกต่างหากและไม่สามารถเข้าถึงข้อมูลที่ไม่ได้ถูกส่งไปในตอนแรก

branch foo(data, to, be, processed){
    //code
    return [resulting, data]
}

เมื่อสาขาถูกเรียกมันจะส่งคืนหมายเลขอ้างอิงทันที

handle=foo(here, is, some, data)

หมายเลขอ้างอิงสามารถใช้เพื่อตรวจสอบว่างานเสร็จสมบูรณ์หรือไม่

handle.finished() //True if the execution is complete

หากมีการร้องขอผลลัพธ์ก่อนที่การดำเนินการจะเสร็จสมบูรณ์เธรดหลักจะรอ

[result, storage]=handle.result()

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

if (cond)
   //do something
else (cond)
   //do something
else (cond)
   //do something
first
   //do something
then
   //do something
else (cond)
   //do something
else
   //do something
end

FIRST และบล็อก THEN นั้นจะทำงานหากมีการประเมินเงื่อนไขใด ๆ 3 ข้อเป็นจริง FIRST block จะทำงานก่อนที่บล็อกแบบมีเงื่อนไขและ THEN จะทำงานหลังจากบล็อกแบบมีเงื่อนไขทำงานแล้ว

เงื่อนไขอื่น ๆ หรือการเขียนขั้นสุดท้ายต่อไปนี้คำสั่ง FIRST และ THEN นั้นเป็นอิสระจากบล็อกเหล่านี้

มันสามารถอ่านเป็น:

if (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   //do something
else
   //do something
end


function first()
   //do something
return
function then()
   //do something
return

ฟังก์ชั่นเหล่านี้เป็นเพียงรูปแบบการอ่าน พวกเขาจะไม่สร้างขอบเขต มันเป็นเหมือน gosub / return จาก Basic

ประโยชน์และความสามารถในการอ่านเป็นเรื่องของการอภิปราย

บางครั้งฉันพบว่าตัวเองกำลังเขียนลูปที่ต้องทำสิ่งที่แตกต่างในระหว่างการทำซ้ำครั้งแรก ตัวอย่างเช่นการแสดงแท็ก <th> แทนแท็ก <td>

ฉันจัดการกับสถานการณ์นี้ด้วยธงบูลีน บางสิ่งเช่นนี้

first = true

while (some_condition)
    if (first)
        do_something
        first = false
    else
        do_something_else

ดูเหมือนว่าโง่ที่จะตรวจสอบค่าของfirstการวนซ้ำทุกครั้งเมื่อมันเป็นเท็จเกือบตลอดเวลา

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

[คัดลอกมาจากคำตอบของฉันเองใน stackoverflow]

ignoring - เพื่อละเว้นข้อยกเว้นที่เกิดขึ้นในบล็อกของรหัส

try {
  foo()
} catch {
  case ex: SomeException => /* ignore */
  case ex: SomeOtherException => /* ignore */
}

ด้วยโครงสร้างการควบคุมที่ไม่สนใจคุณสามารถเขียนได้กระชับและอ่านง่ายขึ้นเป็น:

ignoring(classOf[SomeException], classOf[SomeOtherException]) {
  foo()
}

[Scala ให้สิ่งนี้ (และโครงสร้างการควบคุมการจัดการข้อยกเว้นอื่น ๆ อีกมากมาย) ในไลบรารีมาตรฐานของมันในแพ็คเกจ util.control ]

แทน:

switch(myEnum) {
  case MyEnum.Val1: do1(); ...
  case MyEnum.Val2: do2(); ...
....

ใช้ Python หรือ C # ก็ได้เช่นกัน:

action = val2func[myEnum]
action()

Scala มีคุณสมบัติใหม่มากมาย

ในที่สุดภาษาเช่น Clojure สามารถขยายเพื่อให้การทำงานพิเศษ

ฉันมีสองแนวคิด

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

try {
    // Save something
} catch (Exception e) {
    // Something we do for all Exceptions
    catch (ProcessingException e) {
        // Something we do for all Processing exceptions
        catch (DBExcpetion e) {
            // DBExceptions are a subclass of ProcessingException
        }
        catch (BusinessRuleException e) {
            // BusinessRuleExceptions are also a subclass of ProcessingException
        }
    }
    // Something we do after specific sub class Exceptions
 }

ในการเขียนโปรแกรมเว็บฉันมักจะพบว่าตัวเองมักทำอะไรแบบนี้ (นี่ไม่ใช่ตัวอย่างจริงดังนั้นอย่าวิเคราะห์กรณีสมมติ):

Account a = getSavedAccount();
if (a == null) {
    a = getAccountFromSessionId();
}
if (a == null) {
    a = getAccountFromCookieId();
}
if (a == null) {
    a = createNewAccount();
}

ใน Javascript (ดี, ECMAScript, และอื่น ๆ ที่ฉันไม่คุ้นเคย) เนื่องจากค่าใด ๆ ที่สามารถประเมินเป็นเงื่อนไข||สามารถช่วยได้

var a = getAFromLocation1() || getAFromLocation2() || default;

ฉันชอบวิธีการที่ดูเหมือนและฉันต้องการภาษามากขึ้นโดยเฉพาะบางอย่างในฝั่งเซิร์ฟเวอร์ได้รับการสนับสนุน (PHP สามารถประเมินสิ่งใดก็ได้ตามเงื่อนไข แต่แปลงการแสดงออกตามเงื่อนไขทั้งหมดเป็นบูลีนแทนที่จะรักษาคุณค่าฉันไม่รู้เกี่ยวกับ Python หรือ Ruby) มันอาจแย่ลงหลังจากสามกรณี แต่ถ้าคุณมีมากกว่านั้น มากกว่าสามกรณีคุณอาจมีการออกแบบซอฟต์แวร์ที่ไม่ดี

สวิตช์ทั่วไปได้กล่าวข้างต้น:

 switch(x){
  predicate1:
     dosomething();
  predicate2:
     dosomethingelse();
 }

ใน Haskell:

  switch' :: a -> [(a -> Bool, b)] -> b
  switch' a [] = undefined
  switch' a (f,b):xs = if f a
                     then b
                      else switch' a xs

ใน C # ฉันต้องการใช้ง่ายswitch () { ... }แต่ขยายได้ด้วยการแสดงออกดังกล่าว:

switch (value)
{
  // string-based operators:
  case begins "Maria": // to catch Maria Carey
    break;
  case ends "Washington": // to catch George Washington
    break;
  case like "ph": // to catch Phil, Phillip, Sophie
    break;
  case between "Aaron" and "April": // to catch all names between
    break;

  // use non-static variables in case expression:
  case Dao.GetDefaultBabyName():
    break;

  // continuable cases without breaking
  case "John":
    bonus = 25;
  case "Peter":
    salary = 500;
    break;

  // jumps between cases
  case "Aleron":
    // do something
    break;
  case "Bella":
    // do something
    jump "Aleron";
    break;

}

และอื่น ๆ เช่นเดียวกับตัวเลขหรือชนิดอื่น ๆ (ที่สนับสนุนIComparable, IConvertible, ... )

นี่อาจทำให้โค้ดของฉันสั้นลงและอ่านง่ายขึ้น

มันเป็นคำถามที่สนุกอย่างที่ @Macneil พูด

โครงสร้างโปรดของฉันที่ผิดปกติการควบคุมซึ่งผม (ไออ่อนน้อมถ่อมตน) ค้นพบคือการดำเนินการที่แตกต่างกัน

มันมีประโยชน์บางอย่าง สำหรับฉันแล้วการใช้งานล้นมือในการเขียนโปรแกรมส่วนต่อประสานผู้ใช้ซึ่งเป็นตัวอย่างของปัญหาทั่วไปในการรักษาข้อมูลซ้ำซ้อนในการติดต่อ ในอีกด้านหนึ่งมีข้อมูลแอปพลิเคชันและอีกด้านหนึ่งมีการควบคุม UI ที่ต้องเก็บไว้ในข้อตกลง ฟังดูเหมือน "ผูกมัด" แต่จริงๆแล้วมันมีอะไรมากกว่านั้น

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

เมื่อฉันนำมาใช้ในแง่ของแมโคร Lisp แล้วมันก็สะอาดมาก มันไม่จำเป็นต้องมีความระมัดระวังในส่วนของโปรแกรมเมอร์ ฉันสามารถทำสิ่งเดียวกันในภาษาที่มีโครงสร้างอื่น ๆ ได้ถ้าฉันมีปัญหาในการเขียนโปรแกรมแยกวิเคราะห์ที่สมบูรณ์แล้วสร้างสิ่งที่ถูกต้องทั้งหมด นั่นเป็นโครงการขนาดใหญ่และฉันยังไม่ได้ทำ

โครงสร้างการควบคุมแบบ "ดั้งเดิม" forนั้นเกี่ยวกับการควบคุมคนทำงานทำให้เขายอมจำนนต่ออุดมการณ์ที่เสียหายของชนชั้นนายทุนทุนนิยมผู้ปกครอง นั่นเป็นเหตุผลที่ฉันใช้โครงสร้างการควบคุมทางเลือกเช่นph0rแทน มันเหมือนforแต่หัวรุนแรงมากขึ้น: คุณจะไม่ph0rสวมชุดสูทและเน็คไททำให้มี BS ขององค์กร ph0rทำให้มันเป็นจริง

ต่อสู้กับพลัง!

ที่ง่ายforloop-

for(100)
{
    //Will run for 100 times
}


for(i)
{
    //Will run for i times while i must be a positive integer
}


for(i as a)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 0 and 
    //scoped within the loop
}


for(i as a=2)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 2 and 
    //scoped within the loop
}