Yöntemin hatalı girdiyi geri getiremediğini bilsem bile, bir yöntem çağrısının dönüş değerini doğrulamalı mıyım?

Aradığım yöntemin bu beklentileri karşılayacağını bilsem bile beklentilerimi karşıladığını doğrulayarak bir yöntem çağrısının dönüş değerine karşı savunmam gerekip gerekmediğini merak ediyorum.

VERİLEN

User getUser(Int id)
{
    User temp = new User(id);
    temp.setName("John");

    return temp;
}

YAPMALI MIYIM

void myMethod()
{
    User user = getUser(1234);
    System.out.println(user.getName());
}

VEYA

void myMethod()
{
    User user = getUser(1234);

    // Validating
    Preconditions.checkNotNull(user, "User can not be null.");
    Preconditions.checkNotNull(user.getName(), "User's name can not be null.");

    System.out.println(user.getName());
}

Bunu kavramsal düzeyde soruyorum. Metodun iç işleyişini bilirsem ararım. Ya yazdığım için ya da kontrol ettiğim için. Ve döndürdüğü değerlerin mantığı benim önkoşullarıma uyuyor. Doğrulamayı atlamak "daha iyi" mi, yoksa "daha uygun mu" mı, yoksa her zaman geçmesi gerekse bile uygulayacağım yönteme geçmeden önce hala yanlış değerlere karşı mı savunmalı mıyım?

Tüm cevaplardan aldığım sonuç (kendinize gelmekten çekinmeyin):

• Yöntem geçmişte yaramazlık göstermiştir.
• Yöntem güvenilmeyen bir kaynaktan geliyor
• Yöntem, diğer yerlerden kullanılır ve açıkça koşullarını belirtmez

• Bu yöntem sizinkilerle yakından ilgilidir (ayrıntılar için seçilen cevaba bakınız)
• Metot açıkça uygun doktor, tip güvenliği, ünite testi veya şartlı kontrol gibi bir şeyle sözleşmesini tanımlar.
• Performans kritiktir (bu durumda, bir hata ayıklama modu iddiası hibrit bir yaklaşım olarak çalışabilir)

Bu, GetUser ve myMethod'un değişme ihtimaline ve daha da önemlisi birbirlerinden bağımsız olarak değişme olasılıklarına bağlıdır .

Herhangi bir şekilde getUser'ın gelecekte hiçbir zaman, asla, asla değişmeyeceğinden emin olursanız, evet, ibir i = 3;ifadeden hemen sonra 3 değerine sahip olduğunu doğrulamak için harcadığınız zaman, bunun doğrulanması zaman kaybıdır . Gerçekte, bunu bilmiyorsun. Fakat bildiğiniz bazı şeyler var:

• Bu iki işlev "birlikte yaşar mı"? Başka bir deyişle, onları koruyan aynı kişiler var mı, aynı dosyanın bir parçası mı ve dolayısıyla birbirleriyle kendi başlarına "senkronize" kalmaları olası mı? Bu durumda, validasyon kontrolleri eklemek büyük olasılıkla mümkündür, çünkü bu sadece iki fonksiyon her değiştiğinde veya farklı fonksiyonlara yeniden yerleştirildiğinde değişmesi (ve potansiyel olarak ortaya çıkması gereken) daha fazla kod anlamına gelir.

• GetUser işlevi, belirli bir sözleşmeyle belgelenmiş bir API'nin parçası mı ve myMethod, yalnızca söz konusu API'nin başka bir kod tabanında müşterisi mi? Öyleyse, dönüş değerlerini doğrulamak mı (yoksa giriş parametrelerini önceden onaylamak!) Mı yoksa gerçekten mutlu yolu takip etmenin güvenli olup olmadığını öğrenmek için bu belgeleri okuyabilirsiniz. Dokümantasyon bunu netleştirmezse, tamirciden düzeltmesini isteyin.

• Son olarak, eğer bu belirli fonksiyon aniden ve beklenmedik bir şekilde geçmişte davranışını değiştirmişse, kodunuzu kıran bir şekilde, paranoyak olma konusunda her hakkınız vardır. Hatalar kümelenme eğilimindedir.

Her iki işlevin orijinal yazarı olsanız bile, yukarıdakilerin hepsinin geçerli olduğunu unutmayın. Bu iki fonksiyonun yaşamlarının geri kalanında “birlikte yaşaması” mı bekleniyor, yoksa yavaş yavaş ayrı modüllere ayrılıp ayrılmayacaklarını, ya da bir şekilde kendinizi daha yaşlı bir böcekle birlikte vurduysanız bilmiyoruz. getUser'ın sürümleri. Ama muhtemelen oldukça iyi bir tahminde bulunabilirsiniz.

Ixrec'in cevabı iyidir, fakat farklı bir yaklaşım benimsem çünkü buna değer. Bu tartışmanın amacı, iddialardan bahsedeceğim, çünkü Preconditions.checkNotNull()geleneksel olarak bilinen adınız bu.

Önermek istediğim, programcıların bir şeyin belirli bir şekilde davranacağından emin olma derecelerini abartmaları ve bu şekilde davranmamasının sonuçlarını küçümsemeleridir. Ayrıca, programcılar genellikle iddiaların dokümantasyon olarak gücünü anlamamaktadır. Daha sonra, benim deneyimlerime göre, programcılar işleri gereğinden çok daha az sıklıkla iddia ediyorlar.

Benim mottom:

Her zaman kendinize sormanız gereken soru "bunu iddia etmeli miyim?" Değil. ama "iddia etmeyi unuttuğum bir şey var mı?"

Doğal olarak, bir şeyin belirli bir şekilde davrandığından kesinlikle eminseniz , bunun aslında böyle davrandığını iddia etmekten kaçınacaksınız ve bu da çoğu için makul. Hiçbir şeye güvenemezseniz, yazılım yazmak gerçekten mümkün değildir.

Ancak bu kuralın bile istisnaları vardır. Meraklı bir şekilde, Ixrec'in örneğini alması int i = 3;için i, gerçekten de belli bir aralıkta olan bir iddiaya uymanın tamamen istendiği bir durum var . Bu, içeşitli senaryoları deneyen bir kişi tarafından değiştirilme yükümlülüğü olan bir durumdur ve izleyen kod i, belirli bir aralıkta bir değere sahip olmaya dayanır ve aşağıdaki koda hızlı bir şekilde bakarak ne olduğu hemen belli değildir. kabul edilebilir aralık Öyleyse, int i = 3; assert i >= 0 && i < 5;ilk başta saçma görünebilir, ancak bunu düşünürseniz, birlikte oynayabileceğinizi isöyler ve ayrıca içinde kalmanız gereken aralığı da söyler. İddia, en iyi dokümantasyon türüdür, çünkümakine tarafından zorlanır , bu nedenle mükemmel bir garantidir ve kodla birlikte yeniden biçimlendirilir , bu nedenle daima geçerli kalır.

Örneğiniz, getUser(int id)örneğin çok uzak bir kavramsal akrabası değildir assign-constant-and-assert-in-range. Görüyorsunuz, tanım gereği, işler beklediğimiz davranıştan farklı davranış sergilediğinde hatalar oluyor. Doğru, her şeyi iddia edemeyiz, bu yüzden bazen bir miktar hata ayıklama olur. Ancak, sektörde bir hatayı ne kadar çabuk yakalarsak o kadar az maliyeti olduğu iyi bilinen bir gerçektir. Sormanız gereken sorular sadece bunun getUser()asla boşa dönmeyeceğinden (ve bir kullanıcıyı asla boş bir adla döndürmeyeceğinizden) emin olmanız değil , aynı zamanda kodun geri kalanında ne tür kötü şeyler olacağını Aslında bir gün beklenmedik bir şey döndürür ve tam olarak ne beklendiğini bilmek için kodun geri kalanına hızlıca bakarak ne kadar kolaydır getUser().

Beklenmeyen davranış veritabanınızın bozulmasına neden olacaksa,% 101'in gerçekleşmeyeceğinden emin olsanız bile iddiada bulunmalısınız. Bir nullkullanıcı adı garip bir şifreli takip edilemez hataya yol açarsa, binlerce satır daha ileride ve milyarlarca saat döngüsü sonra, o zaman belki de en kısa zamanda başarısız olmak en iyisidir.

Bu yüzden, Ixrec'in cevabına katılmıyor olmama rağmen, iddiaların hiçbir ücrete mal olmadığı gerçeğini ciddiye almanızı öneririm, bu yüzden gerçekten özgürce kullanarak kazanılacak, ancak kazanılacak bir şey yok.

Kesin bir hayır.

Arayan, aradığı işlevin sözleşmesine uyup uymadığını asla kontrol etmemelidir. Nedeni basit: Potansiyel olarak çok sayıda arayan var ve her bir arayan için, diğer fonksiyonların sonuçlarını kontrol etme mantığını çoğaltmak için kavramsal bakış açısına göre pratik ve tartışmasız bile yanlış.

Herhangi bir kontrol yapılacaksa, her fonksiyon kendi post-koşullarını kontrol etmelidir. Post-koşullar, işlevi doğru uyguladığınızdan ve kullanıcılar işlevinizin sözleşmesine güvenebileceklerinden emin olur.

Belirli bir işlevin hiç boş bırakmayacak olması halinde, bunun belgelenmesi ve işlevin sözleşmesinin bir parçası haline gelmesi gerekir. Bu sözleşmelerin amacı budur: kullanıcılara güvenebilecekleri bazı değişmezler sunar, böylece kendi işlevlerini yazarken daha az engelle karşılaşırlar.

Null, getUser yönteminin geçerli bir geri dönüş değeriyse, kodunuz bunu bir İstisna ile değil - İstisna değil - istisnai bir durum değildir.

Null, getUser yönteminin geçerli bir döndürme değeri değilse, getUser'da bir hata vardır - getUser yöntemi bir istisna atmalı veya başka türlü düzeltilmelidir.

GetUser yöntemi harici bir kütüphanenin parçasıysa veya başka türlü değiştirilemezse ve boş bir geri dönüş durumunda istisnaların atılmasını istiyorsanız, sınıfı ve yöntemi, çekleri gerçekleştirecek şekilde sarın ve istisnayı atması için getUser çağrısı kodunuzda tutarlıdır.

Sorunuzun dayanağının kapalı olduğunu savunuyorum: neden başlamak için boş bir başvuru kullanmalısınız?

Boş nesne model esasen hiçbir şey nesneleri döndürmek için bir yoldur: "Hiçbir kullanıcı" temsil eden bir nesneyi döndürmek yerine sizin kullanıcı için dönüş null dışında

Bu kullanıcı etkin değil, boş bir ada ve "burada hiçbir şey" i belirten boş olmayan değerlere sahip olacak. Başlıca yararı, programınızın denetlemelerini boşa çıkaracak, günlüğe kaydetme vb. İşlemlerini çöpe atmanıza gerek kalmamasıdır.

Bir algoritma neden boş bir değere dikkat etmeli? Adımlar aynı olmalı. Sıfır, boş dize, vb. Döndüren boş bir nesneye sahip olmak bu kadar kolay ve açıktır.

İşte null için bir kod kontrolü örneği:

User u = getUser();
String displayName = "";
if (u != null) {
  displayName = u.getName();
}
return displayName;

Boş bir nesne kullanan bir kod örneği:

return getUser().getName();

Hangisi daha net? İkincisinin olduğuna inanıyorum.

Soru java olarak etiketlenirken , referanslar kullanılırken boş nesne modelinin C ++ ' da gerçekten yararlı olduğunu belirtmekte fayda vardır . Java referansları C ++ işaretçilerine benzer ve boş değerlere izin verir. C ++ referansları tutamıyornullptr . Eğer biri C ++ 'da boş bir referansa benzer bir şeye sahip olmak isterse, boş nesne deseni bunu başarmayı bildiğim tek yoldur.

Genellikle, bunun temel olarak aşağıdaki üç konuya bağlı olduğunu söyleyebilirim:

1. sağlamlık: çağıran yöntem, nulldeğerle başa çıkabilir mi? Eğer bir nulldeğer bir sonuç verirse, RuntimeExceptionbir kontrol önerebilirim - karmaşıklık düşük ve çağrılmayan / çağrı yöntemleri aynı yazar tarafından yaratılmadığı ve nullbeklenmediği sürece (örn private. Aynı pakette).

2. kod sorumluluğu: A geliştiricisinin getUser()yönteminden sorumluysa ve B geliştiricisi onu kullanıyorsa (örneğin bir kütüphanenin parçası olarak) değerini doğrulamanızı şiddetle tavsiye ederim. Bunun nedeni B geliştiricisinin potansiyel bir nullgetiri değeriyle sonuçlanan bir değişikliği bilmemesidir .

3. karmaşıklık: programın veya ortamın genel karmaşıklığı ne kadar yüksekse, dönüş değerini doğrulamak için o kadar çok tavsiye ederim. nullArama yöntemi bağlamında bugün olamayacağından emin olsanız bile , getUser()başka bir kullanım durumu için değişiklik yapmanız gerekebilir . Birkaç ay veya yıl geçtikten ve birkaç bin satır kod eklendiğinde, bu bir tuzak olabilir.

Ek olarak, nullbir JavaDoc yorumunda potansiyel geri dönüş değerlerini belgelemenizi tavsiye ederim . Çoğu IDE'deki JavaDoc açıklamalarının vurgulanması nedeniyle, bu, kullananlar için yararlı bir uyarı olabilir getUser().

/** Returns ....
  * @param: id id of the user
  * @return: a User instance related to the id;
  *          null, if no user with identifier id exists
 **/
User getUser(Int id)
{
    ...
}

Kesinlikle zorunda değilsin.

Örneğin, bir geri dönüşün asla boş olamayacağını zaten biliyorsanız - Neden boş bir kontrol eklemek istersiniz? Boş bir çek eklemek hiçbir şeyi bozmayacak ama sadece gereksiz. Ve bundan kaçınabildiğiniz sürece gereksiz mantığı kodlamamanız daha iyi.