“Sadece bir dönüş” kavramı nereden geldi?

Sık sık söylemek programcılar konuşmak " aynı yöntemle birden fazla dönüş ifadeleri koymayın. " Bana, benim hemen hepsi bu nedenleri anlatmak için onlara sorduğunuzda " kodlama standardı. Öyle diyor " "veya Kafa karıştırıcı. " Bana bir geri dönüş ifadesi olan çözümler gösterdiklerinde, kod bana daha çirkin görünüyor. Örneğin:

if (condition)
   return 42;
else
   return 97;

" Bu çirkin, yerel bir değişken kullanman gerekiyor! "

int result;
if (condition)
   result = 42;
else
   result = 97;
return result;

Bu% 50 kod kısıtlaması, programın daha kolay anlaşılmasını nasıl sağlar? Şahsen daha zor buluyorum, çünkü devlet alanı daha kolay önlenebilecek başka bir değişkenle arttı.

Tabii ki normalde sadece şunu yazardım:

return (condition) ? 42 : 97;

Ancak birçok programcı şartlı işletmeciden kaçınır ve uzun biçimi tercih eder.

Bu “sadece bir dönüş” nosyonu nereden geldi? Bu konvansiyonun ortaya çıkmasının tarihsel bir nedeni var mı?

Çoğu programlama dili, FORTRAN veya COBOL'de yapıldığında "Tek Giriş, Tek Çıkış" yazılmıştır. Yaygın olarak yanlış yorumlandı, çünkü modern diller Dijkstra'nın uyardığı uygulamaları desteklemiyor.

"Tek Giriş", "işlevler için alternatif giriş noktaları oluşturma" anlamına geliyordu. Assembly dilinde, elbette, her talimatta bir fonksiyon girmek mümkündür. FORTRAN ENTRYifadesiyle işlevler için birden fazla girişi destekledi :

      SUBROUTINE S(X, Y)
      R = SQRT(X*X + Y*Y)
C ALTERNATE ENTRY USED WHEN R IS ALREADY KNOWN
      ENTRY S2(R)
      ...
      RETURN
      END

C USAGE
      CALL S(3,4)
C ALTERNATE USAGE
      CALL S2(5)

"Tek Çıkış" bir işlev yalnızca dönmelidir anlamına geliyordu için açıklamalar derhal çağrı aşağıdadır: tek bir yerde. O did değil bir işlev yalnızca dönmelidir anlamına gelen tek bir yerde. Ne zaman Yapısal Programlama yazılmıştır bir işlev farklı bir konuma geri dönerek bir hata belirtmek için, bu yaygın bir uygulama oldu. FORTRAN bunu "alternatif getiri" ile destekledi:

C SUBROUTINE WITH ALTERNATE RETURN.  THE '*' IS A PLACE HOLDER FOR THE ERROR RETURN
      SUBROUTINE QSOLVE(A, B, C, X1, X2, *)
      DISCR = B*B - 4*A*C
C NO SOLUTIONS, RETURN TO ERROR HANDLING LOCATION
      IF DISCR .LT. 0 RETURN 1
      SD = SQRT(DISCR)
      DENOM = 2*A
      X1 = (-B + SD) / DENOM
      X2 = (-B - SD) / DENOM
      RETURN
      END

C USE OF ALTERNATE RETURN
      CALL QSOLVE(1, 0, 1, X1, X2, *99)
C SOLUTION FOUND
      ...
C QSOLVE RETURNS HERE IF NO SOLUTIONS
99    PRINT 'NO SOLUTIONS'

Her iki teknik de yüksek oranda hata eğilimli idi. Alternatif girişlerin kullanımı genellikle bazı değişkenleri başlatılmamış olarak bıraktı. Alternatif geri dönüşlerin kullanılması, bir GOTO ifadesinin tüm sorunlarına sahipti, ek olarak dallanma koşulunun dalın bitişiğinde değil, alt rutinde bir yerde olması ek bir komplikasyona sahipti.

Bu Tekli Giriş, Tekli Çıkış (SESE) kavramı, C ve montaj gibi açık kaynak yönetimi olan dillerden gelir . C kodunda bunun gibi kodlar sızıntı yapacak:

void f()
{
  resource res = acquire_resource();  // think malloc()
  if( f1(res) )
    return; // leaks res
  f2(res);
  release_resource(res);  // think free()
}

Bu tür dillerde, temel olarak üç seçeneğiniz vardır:

• Temizleme kodunu çoğaltın.
  Ugh. Artıklık her zaman kötüdür.

• gotoTemizleme koduna atlamak için a kullanın .
  Bu, temizleme kodunun işlevdeki son şey olmasını gerektirir. (Ve bu yüzden bazıları gotoonun yerini aldığını iddia ediyor . Ve gerçekten de - C.'de)

• Yerel bir değişken tanıtın ve bunun içinden kontrol akışını değiştirin.
  Dezavantajı (düşünmek sözdizimi aracılığıyla manipüle o kontrol akışı break, return, if, whiledeğişkenlerin devlet aracılığıyla manipüle kontrol akışı (eğer algoritma baktığınızda bu değişkenlerin hiçbir devlet var çünkü) daha takip etmek çok daha kolaydır).

Montajda daha da tuhaf, çünkü o fonksiyonu çağırdığınızda bir fonksiyondaki herhangi bir adrese atlayabilirsiniz, bu da herhangi bir fonksiyon için neredeyse sınırsız sayıda giriş noktasına sahip olduğunuz anlamına gelir. (Bazen bu yararlıdır. Bu tür parçalar , C ++ 'da çoklu kalıtım senaryolarında işlevleri thisçağırmak için gerekli olan işaretçi ayarını uygulamak için derleyiciler için yaygın bir tekniktir virtual.)

Kaynakları manuel olarak yönetmeniz gerektiğinde, herhangi bir yere bir işleve girme veya çıkma seçeneklerinden yararlanmak, daha karmaşık kodlara ve dolayısıyla hatalara yol açar. Bu nedenle, daha temiz kodlar ve daha az hata elde etmek için SESE'yi geliştiren bir düşünce okulu ortaya çıktı.

Bununla birlikte, bir dil istisnalar içerdiğinde, (neredeyse) herhangi bir işlev herhangi bir noktada (neredeyse) herhangi bir noktada erken çıkar, bu nedenle erken dönüş için gerekli hükümleri yapmanız gerekir. (Sanırım finallybaşta Java bunun için kullanılır ve usinguygularken ( IDisposable, finallyaksi) C # C ++ yerine istihdam RAII .) Bunu yaptıktan sonra, olamaz nedeniyle erken üzere kendinize temizlemek için başarısız returnaçıklamada, peki muhtemelen SESE lehine en güçlü argüman ortadan kayboldu.

Bu okunabilirliği bırakır. Tabii ki, returnüzerine rastgele serpilen yarım düzine ifadeli 200 LoC işlevi iyi bir programlama stili değildir ve okunabilir kodlar yapmaz. Ancak böyle bir işlev, bu erken dönüşler olmadan da anlaşılması kolay olmaz.

Kaynakların manuel olarak yönetilemediği veya yönetilmemesi gereken dillerde, eski SESE sözleşmesine bağlı kalmanın değeri yoktur veya çok azdır. OTOH, yukarıda belirttiğim gibi, SESE sıklıkla kodu daha karmaşık hale getirir . (C hariç) günümüz dillerinin çoğuna tam olarak uymayan bir dinozor. Kodun anlaşılabilirliğine yardım etmek yerine, onu engeller.

Java programcıları neden buna bağlı? Bilmiyorum ama (dışardan) POV’mdan Java, C’den (mantıklı oldukları yer) birçok konvansiyon aldı ve onları OO dünyasına uyguladı (nerede işe yaramazlar ya da tamamen kötüler) Onları, ne pahasına olursa olsun. (Tüm değişkenlerinizi kapsamın başlangıcında tanımlama sözleşmesi gibi)

Programcılar irrasyonel sebeplerle her türlü garip gösterime sadık kalırlar. (Derinden iç içe geçmiş yapısal ifadeler - "ok uçları" - Pascal gibi dillerde bir zamanlar güzel kodlar olarak görüldü.) Buna mantıklı bir mantıksal akıl yürütmek, çoğunluğunu yerleşik yollarından sapmaya ikna etmekte başarısız görünüyor. Bu tür alışkanlıkları değiştirmenin en iyi yolu muhtemelen geleneksel olanı değil, en iyisini yapmayı öğretmektir. Siz, bir programlama öğretmeni olarak, elinizde tutun.:)

Bir yandan, tek dönüş ifadeleri günlüğe kaydetmeyi ve günlüğe kaydetmeye dayanan hata ayıklama biçimlerini kolaylaştırır. Dönüş değerini tek bir noktadan yazdırmak için işlevi tek dönüşe dönüştürmek zorunda kaldığımı hatırlıyorum.

  int function() {
     if (bidi) { print("return 1"); return 1; }
     for (int i = 0; i < n; i++) {
       if (vidi) { print("return 2"); return 2;}
     }
     print("return 3");
     return 3;
  }

Öte yandan, function()bu çağrıları yeniden değerlendirebilir _function()ve sonucu kaydedebilirsiniz.

"Tek Giriş, Tek Çıkış" 1970'lerin başlarında Yapılandırılmış Programlama devrimi ile ortaya çıktı ve Edsger W. Dijkstra'nın " GOTO Bildirimi Zarar Gördüğünü Gördü" yazısına yazdı . Yapılandırılmış programlamanın arkasındaki kavramlar, Ole Johan-Dahl, Edsger W. Dijkstra ve Charles Anthony Richard Hoare tarafından yazılmış “Yapısal Programlama” adlı klasik kitapta ayrıntılı olarak ortaya kondu.

"GOTO'nun Zarar Gördüğü Beyanı" bugün bile okunmak zorunda. “Yapısal Programlama” tarihli, ancak yine de çok, çok faydalıdır ve örneğin Steve McConnell'den çok daha fazla olan herhangi bir geliştiricinin “Okunması Gerekenler” listesinin başında yer almalıdır. (Dahl'ın bölümü, C ++ ve tüm nesne yönelimli programlamanın teknik temeli olan Simula 67'deki sınıfların temelini çizer.)

Fowler'ı bağlamak her zaman kolaydır.

SESE'ye karşı çıkan ana örneklerden biri, koruyucu maddelerdir:

Yuvalanmış Koşulları Koruma Cümleleriyle Değiştirme

Tüm özel durumlar için Guard Cümleleri kullanın.

double getPayAmount() {
    double result;
    if (_isDead) result = deadAmount();
    else {
        if (_isSeparated) result = separatedAmount();
        else {
            if (_isRetired) result = retiredAmount();
            else result = normalPayAmount();
        };
    }
return result;
};  

                                                                                                        

double getPayAmount() {
    if (_isDead) return deadAmount();
    if (_isSeparated) return separatedAmount();
    if (_isRetired) return retiredAmount();
    return normalPayAmount();
};  

Daha fazla bilgi için Yeniden Düzenleme sayfasının 250. sayfasına bakın ...

Bir süre önce bu konuyla ilgili bir blog yazısı yazdım.

Sonuç olarak, bu kuralın çöp toplama veya istisna işlemesi olmayan dillerin yaşından gelmesidir. Bu kuralın modern dillerde daha iyi kodlara yol açtığını gösteren resmi bir çalışma yoktur. Bu, daha kısa veya daha okunaklı kodlara yol açacağı zaman bunu görmezden gelmekten çekinmeyin. Bu konuda ısrar eden Java adamları modası geçmiş, anlamsız bir kuralı izleyerek kör ve tartışmasız davranıyorlar.

Bu soru Stackoverflow'ta da sorulmuştur.

Bir dönüş, yeniden düzenlemeyi kolaylaştırır. "Döndürme yöntemi", bir dönüş, ara veya devam içeren bir for döngüsünün iç gövdesine gerçekleştirmeyi deneyin. Kontrol akışınızı kırdığınız için bu başarısız olacaktır.

Mesele şu ki: Kimse mükemmel kod yazıyormuş gibi davranmıyor. Bu yüzden kod düzenli olarak "iyileştirilmesi" ve genişletilmesi için yeniden düzenleme altındadır. Bu yüzden hedefim, kodumu mümkün olduğunca dostça yeniden düzenlemeye devam etmektir.

Sık sık, kontrol akışı kesicileri içeriyorsa ve yalnızca çok az işlevsellik eklemek istersem, işlevleri tamamen yeniden biçimlendirmek zorunda olduğum sorunuyla karşılaşıyorum. İzole yuvalara yeni yollar eklemek yerine tüm kontrol akışını değiştirdiğiniz için bu çok yanlıştır. Sonunda yalnızca bir dönüşünüz varsa veya bir döngüden çıkmak için koruma kullanıyorsanız, elbette daha fazla yuvalama ve daha fazla kodunuz olur. Ancak derleyici ve IDE destekli yeniden düzenleme yetenekleri kazanıyorsunuz.

Birden fazla return ifadesinin GOTO'ların tek bir return ifadesine sahip olmasına eşdeğer olduğunu düşünün. Bu, break ifadeleriyle aynı durumdur. Bu nedenle, bazıları benim gibi, GOTO’yu tüm amaç ve amaçlara yönelik olarak kabul eder.

Ancak, bu GOTO türlerinin zararlı olduğunu düşünmüyorum ve bunun için iyi bir neden bulursam kodumda gerçek bir GOTO kullanmaktan çekinmeyeceğim.

Genel kuralım, GOTO'nun yalnızca akış kontrolü için olmasıdır. Asla herhangi bir döngü için kullanılmamalıdırlar ve asla 'yukarı' ya da 'geriye' GOTO olmamalıdır. (bu, molaların / iadelerin nasıl çalıştığıdır)

Diğerlerinin de belirttiği gibi, aşağıdakiler bir zorunluluktur: GOTO'nun Zarar Gördüğü GOTO Bildirimi'ni okumak zorunludur.
Ancak, bunun 1970’lerde GOTO’nun fazla kullanıldığı durumlarda yazıldığını unutmayın. Her GOTO zararlı değildir ve normal yapılar yerine kullanmadığınız sürece kullanımlarını caydırmayacağım, fakat normal durumlarda normal yapılar kullanmanın son derece elverişli olamayacağı bir durumda.

Onları, normal durumlarda asla kullanılmaması gereken bir arıza nedeniyle bir alandan kaçmanız gereken hata durumlarında kullanmanın yeterli olduğunu düşünüyorum. Ancak bu kodu ayrı bir işleve koymayı da düşünmelisiniz, böylece bir GOTO kullanmak yerine sadece erken dönebilirsiniz ... ama bu bazen de sakıncalıdır.

Cyclomatic karmaşıklık

SonarCube'ün döngüsel karmaşıklığı belirlemek için çoklu geri dönüş ifadesi kullandığını gördüm. Böylece geri dönüş ifadeleri daha fazla, döngüsel karmaşıklık artar.

İade Tipi Değişimi

Çoklu iadeler, geri dönüş tipimizi değiştirmeye karar verdiğimizde, fonksiyonun çoklu yerlerinde değişmemiz gerektiği anlamına gelir.

Birden Çok Çıkış

Mantığın döndürülen değere neyin neden olduğunu anlamak için koşullu ifadelerle birlikte dikkatlice çalışılması gerektiğinden, hata ayıklamak daha zordur.

Refaktörlü Çözüm

Birden fazla geri dönüş ifadesine çözüm, gerekli uygulama nesnesini çözdükten sonra bunları tek biçimli bir polimorfizmle değiştirmektir.