มีประโยชน์ใด ๆ ของการใช้ตัวแปรพิเศษนี้ในการทำหมายเหตุประกอบแบบลูปหรือไม่

ฉันได้พบคำอธิบายประกอบแบบวนรอบต่อไปนี้ในโครงการขนาดใหญ่ที่ฉันกำลังทำงาน (pseudocode):

var someOtherArray = [];
for (var i = 0, n = array.length; i < n; i++) {
    someOtherArray[i] = modifyObjetFromArray(array[i]);
}

สิ่งที่ทำให้ฉันสนใจคือตัวแปรพิเศษ "n" ฉันไม่เคยเห็น a lop เขียนในลักษณะนี้มาก่อน

เห็นได้ชัดว่าในสถานการณ์นี้ไม่มีเหตุผลว่าทำไมโค้ดนี้ไม่สามารถเขียนได้ด้วยวิธีต่อไปนี้ (ซึ่งฉันคุ้นเคยมาก):

var someOtherArray = [];
for (var i = 0; i < array.length; i++) {
    someOtherArray[i] = modifyObjetFromArray(array[i]);
}

แต่มันทำให้ฉันคิด

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

การลดขนาดอาร์เรย์ภายในลูปไม่สมเหตุสมผลมากนักเนื่องจากเรามีแนวโน้มที่จะได้รับ OutOfBoundsException

มีรูปแบบการออกแบบที่เป็นที่รู้จักซึ่งการเพิ่มความคิดเห็นนี้มีประโยชน์หรือไม่

แก้ไขดัง ที่บันทึกไว้โดย @ Jerry101 เหตุผลคือประสิทธิภาพ นี่คือการเชื่อมโยงในการทดสอบประสิทธิภาพการทำงานที่ผมได้สร้าง: http://jsperf.com/ninforloop ในความเห็นของฉันความแตกต่างนั้นไม่ใหญ่พอเว้นแต่คุณจะทำซ้ำแม้ว่าจะมีชุดใหญ่มาก รหัสที่ฉันคัดลอกมานั้นมีองค์ประกอบมากถึง 20 ชิ้นเท่านั้นดังนั้นฉันจึงคิดว่าการอ่านในกรณีนี้มีค่ามากกว่าการพิจารณาเกี่ยวกับประสิทธิภาพ

ตัวแปรnช่วยให้มั่นใจว่ารหัสที่สร้างขึ้นไม่สามารถดึงความยาวของอาเรย์สำหรับการวนซ้ำทุกครั้ง

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

การดึงความยาวของอาเรย์อาจเป็น "ราคาแพงกว่า" อย่างง่ายดายจากนั้นการกระทำจริงที่คุณทำซ้ำ

ดังนั้นหากชุดไม่เปลี่ยนแปลงให้ค้นหาความยาวเพียงครั้งเดียว

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

แนวคิดมาอยู่ในใจว่าความยาวของ "อาเรย์" อาจมีการเปลี่ยนแปลงในระหว่างการดำเนินการลูป แต่เราไม่ต้องการวนซ้ำเกินกว่าขนาดดั้งเดิม แต่ฉันไม่สามารถจินตนาการถึงสถานการณ์ดังกล่าวได้

ผู้คนที่พูดถึงการแสดงอาจถูกต้องว่านี่คือสาเหตุที่เขียนขึ้นมาด้วยวิธีนี้ (คนที่เขียนแบบนั้นอาจไม่ถูกต้องว่ามันมีผลกระทบต่อการแสดงอย่างมีนัยสำคัญ

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

guests = [];
for (i = 0; i < invitations.length; ++i) {
    if (! invitations[i].is_declined()) {
        guests.append(invitations[i].recipient())
    }
}
// maybe some other stuff to modify the guestlist
for (i = 0, n = guests.length; i < n; ++i) {
    if (guests[i].has_plus_one()) {
        guests.append(guests[i].get_plus_one());
    }
}

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

ที่จริงฉันคิดว่าสิ่งที่ผิดปกติมากที่สุดของรหัสนี้คือการเป็นสมาชิกของguestsอาร์เรย์หมายถึงสิ่งต่าง ๆ ที่จุดต่าง ๆ ในรหัส ดังนั้นแน่นอนฉันจะไม่เรียกมันว่า "รูปแบบ" แต่ฉันไม่รู้ว่ามันมีข้อบกพร่องเพียงพอที่จะแยกแยะว่าเคยทำอะไรแบบนี้ :-)

ถ้าเป็นไปได้คุณควรใช้ตัววนซ้ำที่ลัดเลาะองค์ประกอบทั้งหมดของอาร์เรย์ คุณใช้อาเรย์เป็นลำดับไม่ใช่การจัดเก็บแบบสุ่มเข้าถึงดังนั้นจึงเป็นที่ชัดเจนว่าตัววนซ้ำที่เพิ่งเข้าถึงแบบลำดับจะเร็วขึ้น ลองนึกภาพสิ่งที่คุณคิดว่าอาร์เรย์เป็นจริงต้นไม้ไบนารี แต่มีคนเขียนโค้ดที่กำหนด "ความยาว" โดยการนับองค์ประกอบและรหัสที่เข้าถึงองค์ประกอบ i-th เช่นกันโดยการข้ามองค์ประกอบใน O (n ) ตัววนซ้ำเร็วมากวนซ้ำจะวนไปเรื่อย ๆ