Bir for-loop içinde, eğer mümkünse, mola durumunu koşul alanına taşımalı mıyım? [kapalı]

Bazen böyle bir mola gerektiren döngülere ihtiyacım var:

for(int i=0;i<array.length;i++){
    //some other code
    if(condition){
        break;
    }
}

Yazarken kendimi rahatsız hissediyorum

if(condition){
    break;
}

çünkü 3 satır kod tüketiyor. Ve ben döngü olarak yeniden yazılabilir buldum:

                                   ↓
for(int i=0;i<array.length && !condition;i++){
    //some other code
}

Öyleyse benim sorum şu, eğer mümkünse kod satırlarını azaltmak için koşulu koşul alanına taşımak iyi bir uygulama mıdır?

Verdiğiniz bu iki örnek işlevsel olarak eşdeğer değil. Orijinalde, durum testi "başka bir kod" bölümünden sonra yapılır, oysaki değiştirilmiş versiyonda, ilk önce döngü gövdesinin başlangıcında yapılır.

Kod asla satır sayısını azaltmak amacıyla yeniden yazılmamalıdır. Açıkçası, bu şekilde çalıştığında güzel bir bonus, ancak hiçbir zaman okunabilirlik veya doğruluk pahasına yapılmaması gerekir.

"3 satır kod tüketiyor" argümanı almıyorum ve bu nedenle kötü. Sonuçta, sadece şöyle yazabilirsiniz:

if (condition) break;

ve sadece bir satır tüketin.

Eğer ifdöngü yoluyla yarım görünür, tabii ki ayrı bir test olarak varolması gerekir. Ancak, bu test bloğun sonunda görünüyorsa, döngünün her iki ucunda da devam testine sahip olan ve muhtemelen kodun karmaşıklığına eklenmiş bir döngü oluşturdunuz. Yine de, bazen if (condition)testin yalnızca blok yürütüldükten sonra mantıklı olabileceğini unutmayın.

Ancak, bunun başka bir yaklaşımı benimseyerek, böyle olmadığını varsayalım:

for(int i=0;i<array.length && !condition;i++){
    //some other code
}

Çıkış koşulları bir arada tutulur ve bu durum işleri basitleştirebilir (özellikle " başka bir kod " uzunsa).

Elbette burada doğru cevap yok. Bu nedenle, dilin deyimlerinin, ekibinizin kodlama sözleşmelerinin vs. ne olduğunun farkında olun.

Bu tür bir soru, neredeyse programlandığı sürece tartışmaya neden oldu. Şapkamı ringe atmak için, breakkoşulu olan sürüme giderdim ve işte bu yüzden (bu özel durum için):

forDöngü döngü içinde yineleme değerleri belirtmek için sadece var. Bunun içindeki kırılma koşulunu kodlamak sadece mantık IMO'sunu karıştırır.

Ayrı olması break, normal işlem sırasında, değerlerin fordöngüde belirtildiği gibi olduğunu ve işlemin , koşulun geldiği yer dışında devam etmesi gerektiğini açıkça göstermektedir.

Bir parça arka plan olarak, kodlamaya başladım break, durumu foryıllarca döngüye koydum (istisnai bir programcının yönetiminde) ve daha sonra breakstile döndüm, çünkü çok daha temiz hissettim (ve geçerli stil kullandığım çeşitli kod tome'leri).

Günün sonunda bu kutsal savaşlardan bir diğeri - bazıları yapay olarak bir döngüden asla kopmamanız gerektiğini söylüyor , yoksa gerçek bir döngü değil. Okunabilir olduğunu düşündüğünüzü yapın (hem kendiniz hem de başkaları için). Tuş vuruşlarını azaltmak gerçekten sizin için ise, hafta sonları golf isteğinize - isteğe bağlı bira.

fordöngüler ¹ üzerinde yineleme içindir - sadece lol-haydi-bazı-rasgele-onlardan-vücuttan-ve-to-on-the-the-the-loop-başlığı-koymak-şeyler değildir - üç ifadeleri çok özel anlamlar:

• İlki yineleyiciyi başlatmak içindir . Bir indeks, işaretçi, bir yineleme nesnesi veya her neyse - yineleme için kullanıldığı sürece olabilir .
• İkincisi, sona ulaşıp ulaşmadığımızı kontrol etmek içindir.
• Üçüncüsü, yineleyiciyi ilerletmek içindir.

Fikir, yineleme işlemlerini ( nasıl yinelemeli) döngü içindeki mantıktan ayırmaktır ( her yinelemede ne yapılır). Çoğu dilde, sizi yinelemenin ayrıntılarından kurtaracak her bir forma sahiptir, ancak dilinizde bu yapı olmasa veya senaryoda kullanılamıyorsa bile - hala döngü başlığını sınırlamanız gerekir. yineleme işleme.

Öyleyse, kendinize sormanız gerekir - yineleme yönetimi veya döngü içindeki mantık hakkındaki durumunuz mu? Muhtemelen, döngü içindeki mantıkla ilgilidir - bu yüzden başlıktan çok döngü içindeki kontrol edilmelidir.

¹ Diğer döngüler karşısında, bir şeyin olmasını "beklemektedir". A for/ foreachdöngü yinelenecek öğelerin bir "listesi" kavramına sahip olmalıdır - bu liste tembel ya da sonsuz ya da soyut olsa bile.

İle sürümünü kullanmanızı öneririm if (condition). Daha okunaklı ve hata ayıklamak daha kolaydır. Fazladan 3 kod satırı yazmak parmaklarınızı kırmaz ancak bir sonraki kişinin kodunuzu daha kolay anlamasını sağlar.

Belirli öğelerin atlanması gereken bir koleksiyonu yineliyorsanız, yeni bir seçenek öneriyorum:

• Koleksiyonunuzu yinelemeden önce filtreleyin

Hem Java hem de C #, bunu göreceli olarak önemsiz kılıyor. C ++ geçerli olmayan bazı öğeleri atlamak için süslü bir yineleyici yapmanın bir yolu olsaydı şaşırmam. Ancak, bu yalnızca, seçtiğiniz dil destekliyorsa ve kullanmanızın nedeni, breakbir öğeyi işleyip işlemediğinizle ilgili şartlar olduğu için gerçekten bir seçenektir .

Aksi halde, durumunuzu for döngüsünün bir parçası yapmak için çok iyi bir neden vardır - bunun ilk değerlendirmenin doğru olduğunu varsaymak.

• Bir döngünün ne zaman erken bittiğini görmek daha kolay

For loop'ınızın birkaç koşulu ve bazı karmaşık matematik işlemlerinin yapıldığı birkaç yüz satır aldığı kod üzerinde çalıştım. Bununla karşılaştığınız sorunlar:

• break mantık gömülü komutları bulmak zor ve bazen şaşırtıcı
• Hata ayıklama, neler olduğunu gerçekten anlamak için döngünün her yinelemesinde adım atmayı gerektirir
• Kodun birçoğu, kolayca yeniden yazılabilir yeniden yapılandırmaya sahip değildir veya yeniden yazma işleminden sonra fonksiyonel denkliği sağlamak için birim testleri yoktur.

Bu durumda tercih sırasına göre aşağıdaki yönergeleri tavsiye ederim :

• Bir breakmümkünse ihtiyacı ortadan kaldırmak için koleksiyonu filtreleyin
• For loop koşullarının koşullu bölümünü yapın
• Koşullu breakolanları mümkünse döngünün üst kısmına yerleştirin
• Molaya dikkat çeken çok satırlı bir yorum ekleyin ve neden orada?

Bu kurallar her zaman kodunuzun doğruluğuna tabidir . Niyeti en iyi şekilde temsil edebilecek ve kodunuzun netliğini artırabilecek seçeneği seçin.

Aksi takdirde önemli bir kazanç elde edemediğiniz sürece en az sürpriz yaklaşımını kullanmanızı şiddetle tavsiye ederim .

İnsanlar bir kelimeyi okurken her mektubu okumazlar ve bir kitabı okurken her kelimeyi okumazlar - eğer okumaya yatkınlarsa, kelimelerin ve cümlelerin ana hatlarına bakarlar ve beyninin gerisini doldurmasına izin verirler. .

Bu nedenle, zaman zaman geliştirici bunun bunun döngü için bir standart olduğunu varsayacağına ve buna bakmayacağına dair bir ihtimal olduğunu düşünüyor:

for(int i=0;i<array.length&&!condition;i++)

Ne olursa olsun bu stili kullanmak istiyorsanız, ben parçaları değiştirerek tavsiye for(int i=0;i<ve ;i++)bu döngü için standart olduğunu o okuyucunun beynine söyle.

Birlikte gitmek için başka bir neden de if- breakyaklaşımınızı her zaman for-konisyonla kullanamamanızdır . Kullanmanız gerekir if- breakbreak koşulu bir fordeyim içinde gizlenemeyecek kadar karmaşık olduğunda veya yalnızca fordöngü içinde erişilebilen değişkenlere güvenir .

for(int i=0;i<array.length&&!((someWidth.X==17 && y < someWidth.x/2) || (y == someWidth.x/2 && someWidth.x == 18);i++)

Birlikte gitmeye karar Yani eğer if- break, kapalı konum. Ancak, forşartlara uymaya karar verirseniz , if- breakve-koşullarının bir karışımını kullanmak zorundasınız for. Tutarlı olmak amacıyla ileri geri koşullarını taşımak zorunda kalacak arasındaki forKOŞUL VE if- breakher koşulları değiştikçe.

Dönüşümünüz, döngüye girerken neyin conditiondeğerlendirildiğini varsayar true. Bu durumda bunun doğruluğu hakkında yorum yapamayız, çünkü tanımlanmadı.

Burada "kod satırlarını azaltmak" konusunda başarılı olmak, sonra bakmaya devam edebilirsiniz

for(int i=0;i<array.length;i++){
    // some other code
    if(condition){
        break;
    }
    // further code
}

ve aynı dönüşümü uygulayarak

for(int i=0;i<array.length && !condition;i++){
    // some other code
    // further code
}

Bu, further codedaha önce yapmadığınız bir şeyi koşulsuz olarak yaptığınız gibi geçersiz bir dönüşümdür .

Daha güvenli bir dönüşüm şeması, ayrı bir işleve sahip çıkarıp some other codedeğerlendirme yapmaktır condition.

bool evaluate_condition(int i) // This is an horrible name, but I have no context to improve it
{
     // some other code
     return condition;
}

for(int i=0;i<array.length && !evaluate_condition(i);i++){
    // further code
}

TL; DR Özel durumunuzda en iyi ne varsa onu yapın

Bu örneği ele alalım:

for ( int i = 1; i < array.length; i++ ) 
{
    if(something) break;
    // perform operations
}

Bu durumda, for döngüsündeki herhangi bir kodun somethingdoğru olması durumunda çalıştırılmasını istemeyiz , bu nedenle testi somethingkoşul alanına taşımak makul olur.

for ( int i = 1; i < array.length && !something; i++ )

Sonra tekrar, döngünün somethingönüne ayarlanıp ayarlanmamasına bağlı olarak true, ancak bunun içinde olmazsa, daha fazla netlik sunabilir:

if(!something)
{
    for ( int i = 1; i < array.length; i++ )
    {...}
}

Şimdi şunu hayal et:

for ( int i = 1; i < array.length; i++ ) 
{
    // perform operations
    if(something) break;
    // perform more operations
}

Orada çok net bir mesaj gönderiyoruz. somethingDizi işlenirken true olursa , bu noktada tüm işlemi iptal edin. Kontrolü durum alanına taşımak için yapmanız gerekenler:

for ( int i = 1; i < array.length && !something; i++ ) 
{
    // perform operations
    if(!something)
    {
        // perform more operations
    }
}

Muhtemelen, "mesaj" çamurlu hale geldi ve iki durumda arıza durumunu kontrol ediyoruz - ya da başarısızlık durumu değişirse ve bu yerlerden birini unutursak?

Elbette, her birinin kendi nüansları ile bir döngü ve koşul için olabilecek daha birçok farklı şekil vardır.

Kodu iyi okunması için yazın (bu açıkça özneldir) ve net bir şekilde. Bir draconian kodlama kuralları dışında, tüm "kuralların" istisnaları vardır. Neler hissettiğinizi yazdığınızı yazın ve gelecekteki hata olasılığını en aza indirin.

Her ne kadar döngü başlığındaki tüm koşulları gördüğünüz ve breakbüyük blokların içinde kafa karıştırıcı olabileceği için çekici olsa da , bir fordöngü çoğu programcının bir aralıkta döngü yapmayı beklediği bir kalıptır.

Özellikle bunu yaptığınızdan, ek bir mola durumu eklemek karışıklığa neden olabilir ve işlevsel olarak eşdeğer olup olmadığını görmek daha zordur .

Genellikle iyi bir alternatif, dizinizin en az bir öğeye sahip olduğunu varsayarak her iki koşulu da kontrol eden bir whileveya do {} whiledöngü kullanmaktır .

int i=0
do {
    // some other code
    i++; 
} while(i < array.length && condition);

Sadece bir koşulu kontrol eden ve döngü başlığından kod çalıştırmayan bir döngü kullanmak, koşul kontrol edildiğinde, gerçek koşulun ve yan etkileri olan kodun ne olduğunu açıkça belirtirsiniz.

Bu kod, insanlar tarafından okunması gerektiği için kötüdür - deyimsiz fordöngüler sık ​​sık okumak için kafa karıştırıcıdır, yani böceklerin burada saklanma olasılığı daha yüksektir, ancak orijinal kodun her ikisini de korurken iyileştirilmesi mümkün olabilir kısa ve okunabilir.

İstediğiniz şey bir dizide bir değer bulmaksa (verilen kod örneği biraz geneldir, ancak bu model de olabilir), özel olarak bir programlama dili tarafından özel olarak bu amaç için sağlanan bir işlevi kullanmayı deneyebilirsiniz. Örneğin (sözde kod, bir programlama dili belirtilmediğinden, çözümler belirli bir dile bağlı olarak değişir).

array.find(item -> item.valid)

Bu, kodunuzun özellikle neye ihtiyacınız olduğunu söylediği gibi sadeleştirirken çözümü de kısaltır.

Bence birkaç neden olduğunu söylüyor, yapmamalısın.

1. Bu okunabilirliği azaltır.
   
2. Çıkış aynı olmayabilir. Bununla birlikte, bir kod yürütme işleminden sonra durum kontrol edildiğinden bir do...whiledöngü (değil while) ile yapılabilir .
   

Ama bunun üzerine, bunu düşün,

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

    // Some other code
    if(condition1){
        break;
    }

    // Some more code
    if(condition1){
        break;
    }

    // Some even more code
}

Şimdi, bu koşulları bu duruma ekleyerek gerçekten başarabilir misiniz for?

Bence bu breakkodun kaldırılması iyi bir fikir olabilir ama kod satırlarından tasarruf etmemeliyim.

Onsuz yazmanın avantajı break, döngünün post-koşulunun açık ve net olmasıdır. Döngüyü bitirdiğinizde ve programın bir sonraki satırını çalıştırdığınızda, döngü koşulunuzun i < array.length && !conditionyanlış olması gerekir. Bu nedenle, idizi uzunluğunuzdan büyük veya ona eşit veya conditiondoğruydu.

Sürümünde break, gizli bir gotcha var. Döngü koşulu , her geçerli dizi dizini için başka bir kod çalıştırdığınızda döngünün sona erdiğini , ancak gerçekte breakbundan önce döngüyü sonlandırabilecek bir ifade olduğunu ve döngü kodunu gözden geçirmediğiniz sürece göremeyeceğinizi söyler. çok dikkatli. Ayrıca, derleyicileri optimize etmek de dahil olmak üzere otomatik statik analizörler, döngünün post-koşullarının ne olduğunu belirlemekte zorluk çekebilir.

Edgar Dijkstra'nın “Goto Zararlı Olarak Görülüyor” yazmasının asıl sebebi buydu. Bu bir tarz meselesi değildi: bir döngüyü koparmak programın durumu hakkında resmi olarak mantıklı olmayı zorlaştırıyor. Hayatımda birçok ifade yazdım break;ve bir yetişkin olarak bir tane bile yazdım goto(performans açısından kritik bir iç döngüden birden fazla seviyeden ayrılmak ve daha sonra arama ağacının başka bir dalına devam etmek için). Ancak, returnbir döngüden koşullu bir ifade yazma ihtimalim çok yüksektir (bu döngüden sonra asla kodu çalıştırmaz ve bu nedenle post-koşullarını alamaz) break.

dipnot

Aslında, kodu aynı davranışı vermek için yeniden düzenlemek aslında daha fazla kod satırına ihtiyaç duyabilir. Yeniden düzenlemeniz, başka bir kod için veya bunun conditionyanlış başlatacağını ispatlayabilirsek geçerli olabilir . Ancak, örneğiniz genel durumla aynıdır:

if ( array.length > 0 ) {
  // Some other code.
}
for ( int i = 1; i < array.length && !condition; i++ ) {
  // Some other code.
}

Eğer diğer bazı kod tek liner değil, daha sonra kendini tekrar olmamak için bir işleve taşımak olabilir ve o zaman neredeyse bir kuyruk özyinelemeli fonksiyonu içine döngü refactored ettik.

Bunun, sorunun asıl amacı olmadığını biliyorum, ve sen de basit tutuyordun.

Evet, ancak sözdiziminiz alışılmadık ve dolayısıyla kötü (tm)

Umarım diliniz gibi bir şeyi destekler

while(condition) //condition being a condition which if true you want to continue looping
{
    do thing; //your conditionally executed code goes here
    i++; //you can use a counter if you want to reference array items in order of index
}

Aşırı karmaşık bir forifadenin okunması zor olduğundan endişe ediyorsanız , bu kesinlikle geçerli bir husustur. Dikey alanı boşa harcamak da bir konudur (daha az kritik olsa da).

(Şahsen ben bu kuralı sevmediğim ififadeleri hep burada büyük ölçüde boşa dikey boşluk nedeni olan diş telleri olması gerekir. Sorun olduğunu Not israf dikey alan. Kullanma bir sorun olmamalı anlamlı çizgilerle dikey boşluk.)

Bir seçenek, onu birden çok satıra bölmektir. forÇok değişkenli ve koşullu gerçekten karmaşık ifadeler kullanıyorsanız kesinlikle yapmanız gereken budur . (Bu benim için düşey alanı daha iyi kullanmak, mümkün olduğunca anlamlı bir şeyler vermek.)

for (
   int i = 0, j = 0;
   i < array.length && !condition;
   i++, j++
) {
   // stuff
}

Daha bildirici ve daha az zorunlu bir form kullanmaya çalışmak daha iyi bir yaklaşım olabilir. Bu, dile bağlı olarak değişecektir veya bu tür bir şeyi etkinleştirmek için kendi işlevlerinizi yazmanız gerekebilir. Aynı zamanda conditiongerçekte ne olduğuna da bağlıdır . Muhtemelen dizideki içeriğe bağlı olarak bir şekilde değişebilmelidir.

array
.takeWhile(condition)  // condition can be item => bool or (item, index) => bool
.forEach(doSomething); // doSomething can be item => void or (item, index) => void

Unutulan bir şey: Bir döngüden koptuğumda (tüm olası yinelemeleri yapma, nasıl yapıldığına bakılmaksızın), genellikle sadece döngüden çıkmak istememekle kalmaz, bunun neden olduğunu bilmek isterim. . Örneğin, bir X öğesini ararsam, yalnızca döngüden koparmakla kalmaz, X'in bulunduğunu ve nerede olduğunu da bilmek isterim.

Bu durumda, döngü dışında bir koşul olması oldukça doğaldır. Bu yüzden başla

bool found = false;
size_t foundIndex;

ve döngüde yazacağım

if (condition) {
    found = true;
    foundIndex = i;
    break;
}

for döngüsü ile

for (i = 0; i < something && ! found; ++i)

Şimdi döngüdeki durumu kontrol etmek oldukça doğal. Bir "break" ifadesinin olup olmadığı, döngüde kaçınmak istediğiniz işlemlerin olup olmamasına bağlıdır. Bazı işlem gerekliyse ve diğer işlem gerekli değilse, gibi bir işleminiz olabilir.

if (! found) { ... }

bir yere döngüde.