ทำไม (ตำแหน่ง <ขนาด) รูปแบบที่แพร่หลายเช่นนี้ในเงื่อนไข

ในคำสั่งเงื่อนไข (IF) ทุกคนใช้(position < size)แต่ทำไม?
การประชุมเท่านั้นหรือมีเหตุผลที่ดีสำหรับสิ่งนั้น?

พบในป่า:

if (pos < array.length) {
   // do some with array[pos];
}

ไม่ค่อยพบ:

if (array.length > pos) {
   // do some with array[pos];
}

รูปแบบที่ลึกกว่าคือการที่เราใช้ "[สิ่งที่แตกต่าง] [เปรียบเทียบ] [สิ่งที่ไม่แตกต่างกัน]" ตามลำดับมาตรฐาน หลักการนี้ยังคงเป็นจริงสำหรับตัวอย่างของคุณเนื่องจากตำแหน่งอาจแตกต่างกันในขณะที่ขนาดจะไม่

ข้อยกเว้นทั่วไปเพียงอย่างเดียวคือเมื่อทดสอบความเท่าเทียมกันโปรแกรมเมอร์บางคนฝึกฝนตัวเองให้ใช้คำสั่งตรงกันข้าม (เรียกว่าเงื่อนไขโยดา ) เพื่อหลีกเลี่ยงข้อผิดพลาดทั่วไปvariable = constantมากกว่าvariable == constantข้อผิดพลาด - ฉันไม่ได้ถือความคิดนี้เพราะฉันพบคำสั่งตามธรรมชาติ เหนือสิ่งอื่นใดที่สามารถอ่านได้ส่วนใหญ่เป็นเพราะมันเป็นวิธีที่เราแสดงความคิดเป็นภาษาอังกฤษและเพราะคอมไพเลอร์สมัยใหม่ส่วนใหญ่จะตรวจจับสิ่งนี้และออกคำเตือน

เหตุผลเดียวที่ฉันเคยเห็นก็คือมันเป็นเหมือนหมายเลขบรรทัดหรือสิ่งอื่น ๆ ที่เราเรียนรู้ในโรงเรียน ตัวอย่างเช่นเราเขียนบรรทัดตัวเลขดังนี้:

<--|--|--|--|--|--|-->
   1  2  3  4  5  6

สิ่งเล็ก ๆ ปรากฏขึ้นทางด้านซ้ายของสิ่งที่ใหญ่กว่า เช่นเดียวกับสิ่งอื่น ๆ เช่นวันที่ (คิดว่าการวางปฏิทิน)

โดยทั่วไปแล้วเราจะคิดถึงสิ่งต่าง ๆ ตามลำดับ การอ่านแบบฟอร์มแรกนั้นง่ายกว่าเพราะคุณไม่ต้องใช้กระบวนการทางจิตมากนัก

ในขณะที่เรื่องของการประชุมส่วนใหญ่เป็นความคิดของฉันที่ดีที่สุดตรงกับวิธีที่เราคิด - มันแสดงรายการที่เราให้ความสำคัญ

ถ้าเราแปลสิ่งเหล่านี้เป็นภาษาอังกฤษมันจะเป็นวลี "ถ้าตำแหน่งน้อยกว่าความยาวของอาเรย์" โดยที่หัวเรื่องของประโยคนั้นเป็นรายการชั่วคราว

ในการแสดงวิธีอื่น "ถ้าความยาวของอาเรย์มากกว่าตำแหน่ง" ทำให้ความยาวของอาเรย์ (ถือว่าเป็นค่าคงที่) ในเรื่องและตำแหน่ง (ชั่วคราว) จะกลายเป็นวัตถุโดยตรง

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

มันเหมือนกับการสนทนาครึ่งหนึ่งที่ว่างเปล่ากับครึ่งเต็ม เหมือนกันทางคณิตศาสตร์ แต่สมองของฉันจะเห็นพวกเขาแตกต่างกันขึ้นอยู่กับบริบท

โดยส่วนตัวถ้าฉันเห็น

if (array.lengh > pos) {
    // do some with array[pos];
}

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

บางทีฉันอาจจะไม่สดใส แต่ถ้าฉันต้องทำการวิเคราะห์ในทุกบรรทัดของรหัสสมองของฉันก็จะเจ็บ

เพื่อแสดงสิ่งที่บางคนพยายามจะทำในวิธีที่แตกต่าง ...

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

ในภาษาศาสตร์หัวข้อของประโยคคือสิ่งที่กำลังพูดถึงและความคิดเห็นคือสิ่งที่ถูกพูดเกี่ยวกับหัวข้อ ในตัวอย่างนี้เราสามารถสรุปได้ว่าpositionเป็นหัวข้อและ "น้อยกว่าความยาวอาร์เรย์" คือการแสดงความคิดเห็น ในภาษาอังกฤษและในภาษาอื่น ๆ อีกมากมายหัวข้อมักจะแสดงก่อนความคิดเห็น
" แนวโน้มที่จะเป็นสถานที่ topicalized คนละประโยคแรก (หัวข้อบังหน้า) เป็นที่แพร่หลาย. "

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

มันเป็นการรวมสองสิ่งเข้าด้วยกันทั้งสองอย่างมาจากแอสเซมเบลอร์พื้นฐานที่ภาษายุคแรก ๆ ได้รวบรวมไว้

1. อาร์เรย์เป็นออฟเซ็ตที่ไม่มี zero-based ในหน่วยความจำ (เช่นกลุ่มข้อมูลแรกอยู่ที่จุดเริ่มต้นของบล็อกหน่วยความจำที่จัดสรร ... ดัชนี 0) ดังนั้นการใช้ 0..n-1 สำหรับชิ้นส่วนที่แตกต่างกัน

2. การแตกสาขาหากค่าน้อยกว่าค่าอื่น (หรือลงทะเบียน ฯลฯ ) โดยทั่วไปแล้วจะเป็นคำสั่งเดียว ดังนั้นการใช้โอเปอเรเตอร์น้อยกว่า (<) แบบง่าย

ดังนั้นรูปแบบจึงย้ายจากแอสเซมเบลอร์เก่าไปยัง ANSI-C (ซึ่งคล้ายกับแอสเซมเบลอร์แมโครในบางวิธี) และจากที่นั่นไปยัง Java และภาษา C-like อื่น ๆ

ดังที่คำตอบอื่น ๆ บอกไว้มากมายการอ่านง่ายกว่ามาก:

[thing that varies] [comparison] [thing that does not vary]

เกือบทุกคนที่ฉันรู้จักใช้สไตล์นี้โดยเฉพาะ

มีข้อยกเว้นหนึ่งประการสำหรับภาษา C-style ที่ใช้=สำหรับการมอบหมายและ==เพื่อการเปรียบเทียบ หากคุณพิมพ์โดยไม่ตั้งใจ:

if (variable = 5) ...

แทน:

if (variable == 5) ...

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

อย่างไรก็ตามถ้าคุณเขียน:

if (5 == variable) ...

คอมไพเลอร์ / ล่ามจะเกิดข้อผิดพลาดเพราะนั่นไม่ใช่โครงสร้างที่ถูกต้อง (ในภาษาส่วนใหญ่แล้ว)

สวิทช์รอบนี้มักจะเรียกว่าสภาพ Yoda

UPDATE : นี่คือรายการของสถานที่ที่เงื่อนไข Yoda มีประโยชน์

ส่วนตัวฉันชอบสิ่งนี้:

bool positionIsWithinBounds = pos < array.length;
if (positionIsWithinBounds) {
   // do some with array[pos];
}

... มันเป็นโค้ดมากกว่า แต่ก็อ่านง่ายมาก

มันเป็นเรื่องของการตั้งค่าหรือการประชุม หากคุณต้องการให้สอดคล้องกันมีสองวิธีที่สมเหตุสมผลเท่า ๆ กันที่คุณสามารถทำได้:

1. ใส่ "หัวเรื่อง" ก่อนเสมอ (คิดว่าเป็นประโยค) - ค่าที่การทดสอบเกี่ยวกับ ตัวอย่างเช่นคุณเขียนif (age>5)

2. หรือวางองค์ประกอบที่เล็กกว่าก่อนเสมอ (คิดว่าเป็นค่าที่เรียงลำดับบนหน้าจอตามลำดับที่เป็นธรรมชาติ) ตัวอย่างเช่นคุณเขียนif (a<b)โดยไม่คำนึงว่ารหัสนี้ส่วนใหญ่เกี่ยวกับ a หรือส่วนใหญ่เกี่ยวกับ b

อนุสัญญาทั้งสองจะแนะนำตัวอย่างแรกที่คุณแสดงแทนที่จะเป็นวินาทีดังนั้นฉันเดาว่าในกรณีนี้คุณมีคำตอบ ฉันว่ามันควรหลีกเลี่ยงการเขียนโค้ดที่ละเมิดทั้ง (1) และ (2) ที่นี่เพราะจะทำให้การอ่านสำหรับคนส่วนใหญ่ยากขึ้น