Bir işlevden erken dönmeli miyim yoksa bir if ifadesi mi kullanmalıyım? [kapalı]

Bu tür bir işlevi her iki formatta da sıklıkla yazdım ve bir formatın diğerine göre tercih edilip edilmediğini ve nedenini merak ediyordum.

public void SomeFunction(bool someCondition)
{
    if (someCondition)
    {
        // Do Something
    }
}

veya

public void SomeFunction(bool someCondition)
{
    if (!someCondition)
        return;

    // Do Something
}

Genellikle birinciyi kodluyorum çünkü kodlama sırasında beynimin çalışma şekli budur, sanırım 2. olanı tercih ediyorum, çünkü derhal herhangi bir hata işleme ile ilgileniyor ve okumayı daha kolay buluyorum.

İkinci stili tercih ederim. İlk önce geçersiz durumlardan kurtulun, uygun şekilde istisnalardan yalnızca çıkma veya yükseltme yapma, buraya boş bir satır koyun ve ardından yöntemin "gerçek" gövdesini ekleyin. Okumasını daha kolay buluyorum.

Kesinlikle sonuncusu. Eski şu anda kötü görünmüyor, ancak daha karmaşık bir kod aldığınızda, kimsenin bunu düşüneceğini düşünemiyorum:

public int SomeFunction(bool cond1, string name, int value, AuthInfo perms)
{
    int retval = SUCCESS;
    if (someCondition)
    {
        if (name != null && name != "")
        {
            if (value != 0)
            {
                if (perms.allow(name)
                {
                    // Do Something
                }
                else
                {
                    reval = PERM_DENY;
                }
            }
            else
            {
                retval = BAD_VALUE;
            }
        }
        else
        {
            retval = BAD_NAME;
        }
    }
    else
    {
        retval = BAD_COND;
    }
    return retval;
}

daha okunabilir

public int SomeFunction(bool cond1, string name, int value, AuthInfo perms)
{
    if (!someCondition)
        return BAD_COND;

    if (name == null || name == "")
        return BAD_NAME;

    if (value == 0)
        return BAD_VALUE;

    if (!perms.allow(name))
        return PERM_DENY;

    // Do something
    return SUCCESS;
}

Tamamen kabul ediyorum ki tek çıkış noktalarının avantajını hiç anlamadım.

Bu duruma bağlı olarak - Genel olarak, işlevden erken çıkmak için bir grup kodun yerini değiştirmeye çalışmaktan çıkmayacağım - derleyici genellikle benim için bunu halleder. Bununla birlikte, tepede ihtiyacım olan ve başka türlü devam edemem gereken bazı temel parametreler varsa, erken kırılacağım. Aynı şekilde, eğer bir koşul iffonksiyonda dev bir blok oluşturursa , bunun bir sonucu olarak erken kopmasını sağlayacağım.

Bununla birlikte, bir işlev çağrıldığında bazı veriler gerektiriyorsa, sadece geri dönmenin aksine bir istisna (örneğin örneğe bakınız) atacağım.

public int myFunction(string parameterOne, string parameterTwo) {
  // Can't work without a value
  if (string.IsNullOrEmpty(parameterOne)) {
    throw new ArgumentNullException("parameterOne");
  } 
  if (string.IsNullOrEmpty(parameterTwo)) {
    throw new ArgumentNullException("parameterTwo");
  }

  // ...      
  // Do some work
  // ...

  return value;
}

Erken dönüşü tercih ederim.

Bir giriş noktanız ve bir çıkış noktanız varsa, kafanızdaki kodun tamamını çıkış noktasına kadar her zaman izlemeniz gerekir (aşağıdaki başka bir kod parçasının sonuç için başka bir şey yapıp yapmadığını asla bilemezsiniz. var olana kadar onu izlemek zorunda). Nihai sonucu belirleyen hiçbir branş materyali yapmazsınız. Bunu takip etmek zor.

Bir giriş ve çoklu girişlerle, sonucunuzu aldığınızda geri dönersiniz ve sonuçta kimsenin başka bir şey yapmadığını görmek için uğraşmazsınız (çünkü geri döndüğünüzden beri başka bir şey olmaz). Yöntem gövdesinin daha fazla adıma bölünmesi gibi, ki her bir sonuç sonucu geri döndürme veya bir sonraki adımın şansını denemesine izin veriyor.

Manuel olarak temizlenmesi gereken C programlamada, bir puan geri dönüş için söylenecek çok şey var. Şu anda bir şeyi temizlemeye gerek olmasa bile, birisi işlevinizi düzenleyebilir, bir şey tahsis edebilir ve geri dönmeden önce temizlemesi gerekebilir. Bu olursa, tüm iade beyanlarını inceleyen bir kabusluk olacaktır.

C ++ programlamasında yıkıcılar var ve şimdi kapsam koruma görevlileri de var. Tüm bunların, kodun ilk başta istisna güvenli olduğundan emin olmak için burada olması gerekir, bu nedenle kod erken çıkışa karşı iyi korunur ve bu nedenle bunu yapmak için mantıklı bir olumsuzluk yoktur ve tamamen bir stil sorunudur.

Java hakkında yeterince bilgili değilim, "nihayet" blok kodunun çağrılıp çağrılmayacağı ve sonuçlandırıcıların bir şeyin olmasını sağlamak için gereken durumu ele alıp alamayacağı.

C # Kesinlikle cevap veremem.

D dili size uygun dahili kapsam çıkış korumaları sağlar ve bu nedenle erken çıkış için iyi hazırlanmıştır ve bu nedenle stil dışında bir sorun sunmamalıdır.

İşlevler elbette ilk başta çok uzun olmamalı ve eğer çok büyük bir anahtar ifadeniz varsa, kodunuz muhtemelen çok kötü bir faktördür.

Kazanmak için erken iadeler. Çirkin görünebilirler, ancak büyük ifpaketleyicilere göre çok daha az çirkinler , özellikle de kontrol edilmesi gereken çok sayıda koşul varsa.

İkisini de kullanırım.

DoSomething3-5 kod satırı varsa , kod ilk biçimlendirme yöntemini kullanarak sadece güzel görünüyorsun.

Fakat bundan çok daha fazla satır varsa, o zaman ikinci formatı tercih ederim. Açma ve kapama braketlerinin aynı ekranda olmaması hoşuma gitmiyor.

Tek giriş-tek çıkış için klasik bir neden, aksi halde biçimsel anlambilimin açıkça çirkinleşmesidir (GOTO’nun zararlı olduğu düşünülmekteydi).

Başka bir deyişle, yalnızca 1 iadeniz varsa, yazılımınızın rutinden ne zaman çıkacağını bilmek daha kolaydır. Bu da istisnalara karşı bir argümandır.

Genellikle erken dönüş yaklaşımını en aza indiririm.

Şahsen, başlangıçta başarılı / başarısız durum kontrolleri yapmayı tercih ederim. Bu, fonksiyonun üstündeki en yaygın hataların çoğunu, takip edilecek mantığın geri kalanıyla birlikte gruplamama izin veriyor.

Değişir.

İşlevin geri kalanını anlamsız bir şekilde yürütecek derhal kontrol etmek için belirgin bir çıkmaz durumu varsa erken dönüş. *

İşlev daha karmaşıksa ve aksi takdirde birden fazla çıkış noktasına sahipse Retval + single return değerini ayarlayın (okunabilirlik sorunu).

* Bu genellikle bir tasarım problemini gösterebilir. Metodlarınızın çoğunun, kodun geri kalanını çalıştırmadan önce bazı harici / paramer durumlarını veya benzerlerini kontrol etmesi gerektiğini düşünüyorsanız, bu muhtemelen arayan tarafından ele alınması gereken bir şeydir.

Bir If kullanın

Don Knuth'un GOTO'yla ilgili kitabında, onu her zaman en muhtemel koşulun if if ifadesinde gelmesi için bir sebep verdiğini okudum. Bunun hala makul bir fikir olduğu varsayımı altında (ve o dönemin hızı için saf bir düşünce değil). Erken iadelerin iyi bir programlama uygulaması olmadığını söyleyebilirim, özellikle de, kodunuzun başarısız olmama ihtimalinden daha fazla başarısız olmadıkça, hata işleme için kullanılmadıklarından daha sık oldukları gerçeğini göz önünde bulundurarak :-)

Yukarıdaki tavsiyeye uyursanız, bu iadeyi işlevin altına koymanız gerekir, o zaman bir geri dönüş bile denemez, hata kodunu ayarlayın ve iki satır döndürün. Böylece 1 giriş 1 çıkış idealine ulaşılır.

Delphi'ye Özel ...

Deliller olmasa da, bunun Delphi programcıları için iyi bir programlama uygulaması olduğunu düşünüyorum. D2009 öncesi, bir değer döndürmek için atomik bir yolumuz yok, sahip olduk exit;ve result := foo;ya da sadece istisnalar atabiliriz.

Eğer ikame etmek zorundaysan

if (true) {
 return foo;
} 

için

if true then 
begin
  result := foo; 
  exit; 
end;

Bunu fonksiyonlarınızın her birinin tepesinde görmekten bıkmış olabilirsiniz.

if false then 
begin
  result := bar;

   ... 
end
else
   result := foo;

ve sadece exittamamen kaçının .

Aşağıdaki ifadeye katılıyorum:

Şahsen ben, fonksiyonun girintisini azalttığı için, koruma cümlelerinin hayranıyım (ikinci örnek). Bazı insanlar onlardan hoşlanmıyor çünkü fonksiyondan çok sayıda geri dönüş noktasına yol açıyor, ancak bence onlarla daha açık.

Alındığı stackoverflow bu soruya .

Erken dönüşleri neredeyse sadece bu günlerde aşırı derecede kullanıyorum. Bunu yazıyorum

self = [super init];

if (self != nil)
{
    // your code here
}

return self;

gibi

self = [super init];
if (!self)
    return;

// your code here

return self;

ama bu gerçekten önemli değil. İşlevlerinizde bir veya ikiden fazla iç içe geçme düzeyine sahipseniz, yakalanmaları gerekir.

Yazmayı tercih ederim:

if(someCondition)
{
    SomeFunction();
}

Senin gibi, genelde ilkini ben yazarım, ama sonunu tercih ederim. Çok fazla iç içe çekim varsa, genellikle ikinci yönteme başvururum.

Hata işlemenin kontrolden nasıl uzaklaştırılmasından hoşlanmıyorum.

if not error A
  if not error B
    if not error C
      // do something
    else handle error C
  else handle error B
else handle error A

Bunu tercih ederim:

if error A
  handle error A; return
if error B
  handle error B; return
if error C
  handle error C; return

// do something

Tepedeki koşullara "önkoşullar" denir. Koyarak if(!precond) return;, tüm ön koşulları görsel olarak listeliyorsunuz.

Büyük "if-else" bloğunun kullanılması ek yükü arttırabilir (3 düzeydeki girintiler hakkında teklifi unuttum).

Eğer ifadeleri küçükse saklamayı tercih ederim.

Yani, arasında seçim yapma:

if condition:
   line1
   line2
    ...
   line-n

ve

if not condition: return

line1
line2
 ...
line-n

"Erken dönüş" olarak tanımladığın şeyi seçerdim.

Unutma, erken dönüşleri umursamıyorum ya da her neyse, sadece kodları basitleştirmeyi, if ifadelerinin vücutlarını kısaltmayı gerçekten seviyorum.

Olursa olsun ve olmasın ve içindeyken iç içe geçmişse , ne pahasına olursa olsun, kaçının.

Diğerlerinin dediği gibi, buna bağlı. Değer döndüren küçük işlevler için erken getirileri kodlayabilirim. Ama büyük boyutta fonksiyonlar için, kodda her zaman dönmeden önce çalıştırılacak bir şey koyabileceğimi bildiğim bir yere sahip olmayı seviyorum.

Fonksiyon seviyesinde hızlı çalışıyorum. Kodu tutarlı ve temiz tutar (bana ve birlikte çalıştığım kişiye). Bu yüzden her zaman erken dönüyorum.

Sık sık kontrol edilen koşullar için, AOP kullanıyorsanız bu kontroller için yönleri uygulayabilirsiniz.