Nên sử dụng <hoặc <= trong vòng lặp for [đã đóng]

Nếu bạn phải lặp lại vòng lặp 7 lần, bạn sẽ sử dụng:

for (int i = 0; i < 7; i++)

hoặc là:

for (int i = 0; i <= 6; i++)

Có hai cân nhắc:

• hiệu suất
• khả năng đọc

Để thực hiện, tôi giả sử Java hoặc C #. Có vấn đề gì nếu "ít hơn" hoặc "nhỏ hơn hoặc bằng" được sử dụng không? Nếu bạn có cái nhìn sâu sắc cho một ngôn ngữ khác, xin vui lòng cho biết đó là.

Để dễ đọc, tôi giả sử các mảng dựa trên 0.

CẬP NHẬT: Việc tôi đề cập đến mảng dựa trên 0 có thể có những điều nhầm lẫn. Tôi không nói về việc lặp qua các phần tử mảng. Chỉ là một vòng lặp chung.

Có một điểm hay dưới đây về việc sử dụng hằng số sẽ giải thích con số ma thuật này là gì. Vì vậy, nếu tôi có " int NUMBER_OF_THINGS = 7" thì " i <= NUMBER_OF_THINGS - 1" sẽ trông kỳ lạ, phải không.

Đầu tiên là thành ngữ hơn . Cụ thể, nó chỉ ra (theo nghĩa 0 dựa trên) số lần lặp. Khi sử dụng một cái gì đó dựa trên 1 (ví dụ JDBC, IIRC), tôi có thể bị cám dỗ sử dụng <=. Vì thế:

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

Tôi hy vọng sự khác biệt hiệu suất sẽ nhỏ không đáng kể trong mã thế giới thực.

Cả hai vòng lặp lặp lại 7 lần. Tôi muốn nói rằng cái có 7 trong đó dễ đọc / rõ ràng hơn, trừ khi bạn có lý do thực sự tốt cho cái kia.

Tôi nhớ từ những ngày tôi làm hội 8086 ở trường đại học, việc này được thực hiện nhiều hơn:

for (int i = 6; i > -1; i--)

vì đã có một hoạt động JNS có nghĩa là Nhảy nếu không có Dấu hiệu. Sử dụng điều này có nghĩa là không có tra cứu bộ nhớ sau mỗi chu kỳ để có được giá trị so sánh và cũng không có so sánh. Ngày nay, hầu hết các trình biên dịch tối ưu hóa việc sử dụng đăng ký, do đó, bộ nhớ không còn quan trọng nữa, nhưng bạn vẫn nhận được một so sánh không bắt buộc.

Nhân tiện, đặt 7 hoặc 6 trong vòng lặp của bạn sẽ giới thiệu một " số ma thuật ". Để dễ đọc hơn, bạn nên sử dụng hằng số với Tên tiết lộ ý định. Như thế này:

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

EDIT: Mọi người không nhận được điều lắp ráp nên một ví dụ đầy đủ hơn rõ ràng là bắt buộc:

Nếu chúng tôi làm cho (i = 0; i <= 10; i ++), bạn cần làm điều này:

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

Nếu chúng ta làm cho (int i = 10; i> -1; i--) thì bạn có thể thoát khỏi điều này:

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

Tôi vừa kiểm tra và trình biên dịch C ++ của Microsoft không thực hiện tối ưu hóa này, nhưng nó thực hiện nếu bạn thực hiện:

for (int i = 10; i >= 0; i--) 

Vì vậy, đạo đức là nếu bạn đang sử dụng Microsoft C ++, và tăng dần hoặc giảm dần không có sự khác biệt, để có được một vòng lặp nhanh, bạn nên sử dụng:

for (int i = 10; i >= 0; i--)

thay vì một trong hai:

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

Nhưng thẳng thắn nhận được khả năng đọc "for (int i = 0; i <= 10; i ++)" thường quan trọng hơn nhiều so với việc thiếu một lệnh của bộ xử lý.

Trình biên dịch khác có thể làm những việc khác nhau.

Tôi luôn sử dụng <Array.length vì nó dễ đọc hơn <= Array.length-1.

cũng có <7 và cho rằng bạn biết nó bắt đầu bằng chỉ số 0, nên trực quan rằng số đó là số lần lặp.

Nhìn từ một quan điểm tối ưu hóa nó không thành vấn đề.

Nhìn từ quan điểm kiểu mã tôi thích <. Lý do:

for ( int i = 0; i < array.size(); i++ )

dễ đọc hơn nhiều

for ( int i = 0; i <= array.size() -1; i++ )

cũng <cung cấp cho bạn số lần lặp lại ngay lập tức.

Một phiếu bầu khác cho <là bạn có thể ngăn chặn rất nhiều lỗi vô ý.

@Chris, Tuyên bố của bạn về. Bước sóng tốn kém trong .NET thực sự không đúng sự thật và trong trường hợp các loại đơn giản thì hoàn toàn ngược lại.

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

thực sự chậm hơn

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

Sau này là một trường hợp được tối ưu hóa bởi thời gian chạy. Vì thời gian chạy có thể đảm bảo i là một chỉ mục hợp lệ vào mảng, không có kiểm tra giới hạn nào được thực hiện. Trước đây, thời gian chạy không thể đảm bảo rằng tôi đã không được sửa đổi trước vòng lặp và buộc kiểm tra giới hạn trên mảng cho mỗi lần tra cứu chỉ mục.

Nó làm cho không có sự khác biệt hiệu quả khi nói đến hiệu suất. Do đó tôi sẽ sử dụng bất cứ điều gì dễ hiểu hơn trong bối cảnh của vấn đề bạn đang giải quyết.

Tôi thích:

for (int i = 0; i < 7; i++)

Tôi nghĩ rằng dịch dễ dàng hơn để "lặp qua vòng lặp 7 lần".

Tôi không chắc chắn về ý nghĩa hiệu suất - Tôi nghi ngờ bất kỳ sự khác biệt nào sẽ được biên dịch.

Trong Java 1.5 bạn chỉ có thể làm

for (int i: myArray) {
    ...
}

Vì vậy, đối với trường hợp mảng, bạn không cần phải lo lắng.

Tôi không nghĩ có sự khác biệt về hiệu suất. Hình thức thứ hai chắc chắn dễ đọc hơn, tuy nhiên, bạn không cần phải trừ đi một cách tinh thần để tìm số lần lặp cuối cùng.

EDIT: Tôi thấy những người khác không đồng ý. Đối với cá nhân tôi, tôi muốn xem các số chỉ mục thực tế trong cấu trúc vòng lặp. Có lẽ bởi vì nó gợi nhớ nhiều hơn về 0..6cú pháp của Perl , mà tôi biết là tương đương với (0,1,2,3,4,5,6). Nếu tôi thấy số 7, tôi phải kiểm tra toán tử bên cạnh để thấy rằng, trên thực tế, chỉ số 7 không bao giờ đạt được.

Tôi muốn sử dụng phiên bản "<7" bởi vì đó là những gì mà phần lớn mọi người sẽ đọc - vì vậy nếu mọi người đọc lướt qua mã của bạn, họ có thể hiểu sai.

Tôi sẽ không lo lắng về việc "<" có nhanh hơn "<=" hay không, chỉ cần đọc.

Nếu bạn muốn tăng tốc độ, hãy xem xét những điều sau:

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

Để tăng hiệu suất, bạn có thể sắp xếp lại một chút để:

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

Lưu ý loại bỏ GetCount () khỏi vòng lặp (vì điều đó sẽ được truy vấn trong mỗi vòng lặp) và thay đổi "i ++" thành "++ i".

Trong C ++, tôi thích sử dụng hơn !=, có thể sử dụng được với tất cả các thùng chứa STL. Không phải tất cả các trình vòng lặp container STL đều ít hơn so sánh.

Edsger Dijkstra đã viết một bài báo về điều này vào năm 1982, nơi ông lập luận cho mức thấp hơn <= i <trên:

Có một số tự nhiên nhỏ nhất. Loại trừ các nhóm ràng buộc thấp hơn trong b) và d) - các lực cho một chuỗi con bắt đầu từ số tự nhiên nhỏ nhất, giới hạn dưới như được đề cập trong vương quốc của các số không tự nhiên. Điều đó là xấu, vì vậy đối với giới hạn dưới, chúng tôi thích như trong a) và c). Bây giờ hãy xem xét các chuỗi con bắt đầu từ số tự nhiên nhỏ nhất: bao gồm giới hạn trên sau đó sẽ buộc cái sau trở nên không tự nhiên vào thời điểm chuỗi bị thu hẹp thành số rỗng. Điều đó là xấu, vì vậy đối với giới hạn trên, chúng tôi thích <như trong a) và d). Chúng tôi kết luận rằng quy ước a) sẽ được ưu tiên.

Đầu tiên, không sử dụng 6 hoặc 7.

Sử dụng tốt hơn:

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

Trong trường hợp này tốt hơn là sử dụng

for (int day = 0; day <= numberOfDays  - 1; day++){

}

Thậm chí tốt hơn (Java / C #):

for(int day = 0; day < dayArray.Length; i++){

}

Và thậm chí tốt hơn (C #)

foreach (int day in days){// day : days in Java

}

Vòng lặp ngược thực sự nhanh hơn nhưng vì nó khó đọc hơn (nếu không phải bởi bạn bởi các lập trình viên khác), tốt hơn hết là tránh. Đặc biệt là trong C #, Java ...

Tôi đồng ý với đám đông nói rằng số 7 có ý nghĩa trong trường hợp này, nhưng tôi sẽ nói thêm rằng trong trường hợp số 6 là quan trọng, hãy nói rằng bạn muốn làm rõ rằng bạn chỉ hành động trên các đối tượng lên đến chỉ số 6, sau đó là <= là tốt hơn vì nó làm cho 6 dễ nhìn hơn.

Quay trở lại trường đại học, tôi nhớ một vài điều về hai hoạt động này giống nhau về thời gian tính toán trên CPU. Tất nhiên, chúng tôi đang nói chuyện ở cấp độ lắp ráp.

Tuy nhiên, nếu bạn đang nói về C # hoặc Java, tôi thực sự không nghĩ rằng một thứ sẽ tăng tốc độ so với cái kia, Vài nano giây bạn đạt được rất có thể không đáng để bạn nhầm lẫn.

Cá nhân, tôi sẽ tác giả mã có ý nghĩa từ quan điểm triển khai kinh doanh và đảm bảo nó dễ đọc.

Điều này thuộc trực tiếp trong danh mục "Làm sai mã nhìn sai" .

Trong các ngôn ngữ lập chỉ mục dựa trên zero, chẳng hạn như Java hoặc C #, mọi người đã quen với các biến thể của index < countđiều kiện. Do đó, tận dụng quy ước defacto này sẽ làm cho các lỗi khác nhau trở nên rõ ràng hơn.

Về hiệu suất: bất kỳ trình biên dịch tốt nào có giá trị bộ nhớ của nó sẽ hiển thị, chẳng hạn như không có vấn đề.

Như một chút, khi lặp qua một mảng hoặc bộ sưu tập khác trong .Net, tôi thấy

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

để dễ đọc hơn vòng lặp số. Tất nhiên, điều này giả định rằng bộ đếm Int thực tế không được sử dụng trong mã vòng lặp. Tôi không biết nếu có một sự thay đổi hiệu suất.

Có nhiều lý do tốt để viết i <7. Có số 7 trong một vòng lặp lặp lại 7 lần là tốt. Hiệu suất là hiệu quả giống hệt nhau. Hầu như mọi người đều viết i <7. Nếu bạn đang viết để dễ đọc, hãy sử dụng biểu mẫu mà mọi người sẽ nhận ra ngay lập tức.

Tôi luôn luôn thích:

for ( int count = 7 ; count > 0 ; -- count )

Tạo thói quen sử dụng <sẽ làm cho nó phù hợp cho cả bạn và người đọc khi bạn lặp qua một mảng. Nó sẽ đơn giản hơn cho mọi người để có một quy ước tiêu chuẩn. Và nếu bạn đang sử dụng ngôn ngữ có mảng dựa trên 0, thì <là quy ước.

Điều này gần như chắc chắn quan trọng hơn bất kỳ sự khác biệt hiệu suất giữa <và <=. Nhằm mục đích cho chức năng và khả năng đọc đầu tiên, sau đó tối ưu hóa.

Một lưu ý khác là sẽ tốt hơn nếu bạn có thói quen thực hiện ++ i hơn là i ++, vì việc tìm nạp và tăng yêu cầu tạm thời và tăng và tìm nạp không. Đối với số nguyên, trình biên dịch của bạn có thể sẽ tối ưu hóa tạm thời, nhưng nếu kiểu lặp của bạn phức tạp hơn, nó có thể không thể.

Đừng sử dụng số ma thuật.

Tại sao lại là 7? (hoặc 6 cho vấn đề đó).

sử dụng ký hiệu chính xác cho số bạn muốn sử dụng ...

Trong trường hợp đó tôi nghĩ tốt hơn là sử dụng

for ( int i = 0; i < array.size(); i++ )

Các toán tử '<' và '<=' chính xác có cùng chi phí hiệu năng.

Toán tử '<' là một tiêu chuẩn và dễ đọc hơn trong một vòng lặp dựa trên zero.

Sử dụng ++ i thay vì i ++ giúp cải thiện hiệu năng trong C ++, nhưng không phải trong C # - Tôi không biết về Java.

Như mọi người đã quan sát, không có sự khác biệt trong một trong hai lựa chọn bạn đã đề cập. Chỉ để xác nhận điều này, tôi đã thực hiện một số điểm chuẩn đơn giản trong JavaScript.

Bạn có thể xem kết quả ở đây . Điều không rõ ràng ở đây là nếu tôi hoán đổi vị trí của các bài kiểm tra thứ 1 và thứ 2, kết quả cho 2 bài kiểm tra đó hoán đổi, đây rõ ràng là một vấn đề về bộ nhớ. Tuy nhiên, bài kiểm tra thứ 3, một trong đó tôi đảo ngược thứ tự lặp lại rõ ràng nhanh hơn.

Như mọi người nói, thông thường sử dụng các trình lặp 0 chỉ mục ngay cả đối với những thứ nằm ngoài mảng. Nếu mọi thứ bắt đầu tại 0và kết thúc tại n-1, và giới hạn luôn luôn <=và giới hạn luôn luôn <, sẽ có ít suy nghĩ mà bạn phải làm khi xem lại mã.

Câu hỏi tuyệt vời. Câu trả lời của tôi: sử dụng loại A ('<')

• Bạn thấy rõ bạn có bao nhiêu lần lặp (7).
• Sự khác biệt giữa hai điểm cuối là chiều rộng của phạm vi
• Ít ký tự làm cho nó dễ đọc hơn
• Bạn thường có tổng số phần tử i < strlen(s)hơn là chỉ số của phần tử cuối cùng nên tính đồng nhất là quan trọng.

Một vấn đề khác là với toàn bộ cấu trúc này. ixuất hiện 3 lần trong đó, vì vậy nó có thể bị nhầm lẫn. Cấu trúc for-loop cho biết cách làm thay vì phải làm gì . Tôi đề nghị áp dụng điều này:

BOOST_FOREACH(i, IntegerInterval(0,7))

Điều này rõ ràng hơn, biên dịch thành exaclty cùng các hướng dẫn asm, v.v. Hãy hỏi tôi mã của IntegerInterval nếu bạn muốn.

Rất nhiều câu trả lời ... nhưng tôi tin rằng tôi có một cái gì đó để thêm vào.

Sở thích của tôi là cho các số theo nghĩa đen để hiển thị rõ ràng các giá trị "i" sẽ lấy trong vòng lặp . Vì vậy, trong trường hợp lặp lại mặc dù mảng dựa trên zero:

for (int i = 0; i <= array.Length - 1; ++i)

Và nếu bạn chỉ lặp, không lặp qua một mảng, đếm từ 1 đến 7 là khá trực quan:

for (int i = 1; i <= 7; ++i)

Khả năng đọc vượt qua hiệu năng cho đến khi bạn cấu hình nó, vì có thể bạn không biết trình biên dịch hoặc thời gian chạy sẽ làm gì với mã của bạn cho đến lúc đó.

Bạn cũng có thể sử dụng !=thay thế. Bằng cách đó, bạn sẽ nhận được một vòng lặp vô hạn nếu bạn gặp lỗi khi khởi tạo, khiến lỗi được chú ý sớm hơn và bất kỳ vấn đề nào gây ra bị hạn chế bị mắc kẹt trong vòng lặp (thay vì gặp sự cố nhiều sau đó và không tìm thấy nó).

Tôi nghĩ một trong hai đều ổn, nhưng khi bạn đã chọn, hãy bám lấy cái này hay cái khác. Nếu bạn đã quen sử dụng <=, thì hãy thử không sử dụng <và ngược lại.

Tôi thích <=, nhưng trong trường hợp bạn làm việc với các chỉ mục bắt đầu từ 0, có lẽ tôi nên thử và sử dụng <. Đó là tất cả sở thích cá nhân mặc dù.

Theo quan điểm logic, bạn phải nghĩ rằng nó < countsẽ hiệu quả hơn là <= countvì lý do chính xác <=sẽ kiểm tra sự bình đẳng.