Hata değişkenleri bir model mi yoksa iyi bir tasarım mı?

Yürütmeyi durdurmaması gereken olası birkaç hatayla başa çıkmak için error, istemcilerin istisnalar atmak için denetleyebileceği ve kullanabileceği bir değişkenim var. Bu bir Anti-Pattern mi? Bununla baş etmenin daha iyi bir yolu var mı? Bunun bir örneği olarak PHP'nin mysqli API'sini görebilirsiniz. Görünürlük sorunlarının (erişimciler, genel ve özel kapsam, bir sınıftaki veya global değişkenin ne olduğunu?) Doğru ele alındığını varsayalım.

Bir dil istisnaları doğal olarak destekliyorsa, istisnalar atılması tercih edilir ve istemciler bir başarısızlıkla sonuçlanmasını istemiyorlarsa istisnayı yakalayabilirler. Aslında, kodunuzun müşterileri istisnalar bekler ve dönüş değerlerini kontrol etmeyeceklerinden birçok hatayla karşılaşırlar.

Bir seçeneğiniz varsa, istisnaları kullanmanın bir kaç avantajı vardır.

Mesajlar

İstisnalar, geliştiricilerin hata ayıklama amacıyla kullanabileceği veya istenirse kullanıcılara bile gösterebileceği, kullanıcı tarafından okunabilen hata mesajları içerir. Tüketici kod istisnayı idare edemiyorsa, bunu her zaman kaydedebilir, böylece geliştiriciler, geri dönüş değerinin ne olduğunu bulmak için diğer izlerde durmak zorunda kalmadan günlükleri gözden geçirebilir ve geri dönüşün ne olduğunu bulmak için bir tabloda eşleyebilirler. gerçek istisna.

Dönüş değerleri ile kolayca sağlanabilecek ek bilgi yoktur. Bazı diller son hata mesajını almak için yöntem çağrısı yapmayı destekleyecektir, bu nedenle bu endişe biraz ortadan kalkar, ancak arayan kişi fazladan arama yapmayı gerektirir ve bazen bu bilgiyi taşıyan 'özel bir nesneye' erişim gerektirir.

İstisna mesajları durumunda, mümkün olduğunca fazla içerik sağlıyorum:

Kullanıcı profilinde referans verilen "bar" adlı kullanıcı için "foo" adında bir politika alınamadı.

Bunu bir dönüş kodu -85 ile karşılaştırın. Hangisini tercih edersiniz?

Çağrı yığınları

İstisnalar genellikle ayrıca, hata ayıklama kodunun daha hızlı ve daha hızlı hata ayıklamasına yardımcı olan ayrıntılı arama yığınlarına sahiptir ve istenirse arama kodu tarafından da kaydedilebilir. Bu, geliştiricilerin sorunu genellikle tam çizgiye göre belirlemelerini sağlar ve bu nedenle çok güçlüdür. Bir kez daha, bunu geri dönüş değerleri olan bir günlük dosyasıyla (-85, 101, 0 vb. Gibi) karşılaştırın, hangisini tercih edersiniz?

Hızlı önyargılı yaklaşım başarısız

Bir yöntem başarısız olan bir yere çağrılırsa, bir istisna atar. Çağıran kodun istisnayı açıkça bastırması gerekir, aksi halde başarısız olur. Bunu gerçekten şaşırtıcı buldum çünkü geliştirme ve test sırasında (ve hatta üretim sırasında) kod hızlı bir şekilde başarısız oluyor ve geliştiricilerin bunu düzeltmesi için zorluyor. Dönüş değerleri söz konusu olduğunda, bir dönüş değeri kontrolü kontrolünün kaçırılması durumunda, hata sessizce göz ardı edilir ve hata beklenmeyen bir yere çıkar ve genellikle hata ayıklama ve düzeltme maliyeti çok daha yüksek olur.

Sarma ve Açma İstisnaları

İstisnalar diğer istisnaların içine sarılabilir ve ardından gerekirse açılabilir. Örneğin, kodunuz ArgumentNullException, arama kodunda hangi UnableToRetrievePolicyExceptionişlemin başarısız olacağını , çünkü arama kodunda başarısız olan kodu atabilir . Kullanıcıya yukarıda verdiğim örneğe benzer bir mesaj gösterilse de, bazı tanı kodları istisnayı çözebilir ve bir ArgumentNullExceptionsoruna neden olduğunu bulabilir; bu, tüketicinin kodunda kodlama hatası olduğu anlamına gelir. Bu, geliştiricinin kodu düzeltebilmesi için bir uyarı verebilir. Bu gibi gelişmiş senaryoların geri dönüş değerleri ile uygulanması kolay değildir.

Kodun basitliği

Bunu açıklamak biraz zor, ama bu kodlama yoluyla hem istisnalar hem de dönüş değerleri ile birlikte öğrendim. Dönüş değerleri kullanılarak yazılan kod genellikle bir çağrı yapar ve ardından dönüş değerinin ne olduğu konusunda bir dizi kontrol yapar. Bazı durumlarda, başka bir metoda çağrı yapar ve şimdi bu metodun geri dönüş değerleri için başka bir dizi kontrol yapar. İstisnalarda, istisnasızlık çoğu durumda olmasa da çoğu zaman daha kolaydır. Bir try / catch / finally bloklarına sahipsiniz, çalışma zamanı, nihayet temizlik için kodu engellemek için elinden gelenin en iyisini yapmaya çalışıyor. İç içe geçmiş try / catch / nihayet blokları takip etmek ve sürdürmek, iç içe geçmiş if / else ve ilişkili dönüş değerlerini çoklu yöntemlerden nispeten kolaydır.

Sonuç

Kullandığınız platform istisnaları destekliyorsa (özellikle Java veya .NET gibi), o zaman kesinlikle istisnalar atmanın dışında başka bir yol olmadığını varsaymalısınız, çünkü bu platformlarda istisnalar atmak için kurallar vardır ve müşterileriniz bekleyecektir. yani. Kütüphanenizi kullanıyor olsaydım, geri dönüş değerlerini kontrol etmeye zahmet etmeyeceğim çünkü istisnaların atılmasını bekliyorum, bu platformlardaki dünya böyle.

Bununla birlikte, eğer C ++ ise, dönüş kodlarıyla zaten büyük bir kod temeli bulunduğundan ve çok sayıda geliştiricinin istisnaların aksine değerleri döndürmek için ayarlandığı için (örneğin, Windows HRESULT'larla doludur) belirlenmesi daha zor olacaktır. . Ayrıca, birçok uygulamada, bu da bir performans sorunu olabilir (veya en azından öyle algılanan).

Hata değişkenleri, istisnalar bulunmayan C gibi dillerden gelen bir kalıntıdır. Bugün, potansiyel olarak bir C programından (veya istisna işlemesi olmayan benzer bir dilden) kullanılan bir kütüphane yazmanız dışında, bunlardan kaçınmalısınız.

Elbette, daha iyi "uyarı" olarak sınıflandırılabilecek bir hata türünüz varsa (= kitaplığınız geçerli bir sonuç verebilir ve eğer önemli olmadığını düşünürse arayan, uyarıyı görmezden gelebilir) Bir değişkenin istisnaları olan dillerde bile mantıklı gelebilir. Ama dikkat et. Kütüphanenin arayanları, olmasalar bile bu tür uyarıları görmezden gelme eğilimindedir. Öyleyse, bu tür bir kurumu kütüphanenize eklemeden önce iki kez düşünün.

Bir hatayı işaret etmenin birden fazla yolu vardır:

• kontrol etmek için bir hata değişkeni: C , Go , ...
• bir istisna: Java , C # , ...
• "durum" işleyicisi: Lisp (yalnızca?), ...
• polimorfik bir dönüş: Haskell , ML , Rust , ...

Hata değişkeninin sorunu, kontrol etmeyi unutmanın kolay olmasıdır.

İstisnaların sorunu, gizli yürütme yolları yaratmasıdır ve deneme / yakalamanın yazılması kolay olmasına rağmen, yakalama maddesinde uygun bir kurtarmanın sağlanması gerçekten zor olmaktadır (tip sistemlerinden / derleyicilerden destek alınmaz).

Koşul işleyicileri sorunu, iyi oluşturulmadıklarıdır: dinamik kod yürütme işleminiz (sanal işlevler) varsa, hangi koşulların ele alınması gerektiğini tahmin etmek imkansızdır. Ayrıca, aynı koşul birkaç noktada ortaya çıkarsa, her seferinde tek tip bir çözelti uygulanabileceği söylenemez ve hızlı bir şekilde dağınık hale gelir.

Polimorfik dönüşler ( Either a bHaskell'de) şu ana kadar en sevdiğim çözüm:

• açık: gizli yürütme yolu yok
• açık: tamamen işlev türü imzasında belgelenmiştir (sürpriz yoktur)
• ihmal edilmesi zor: İstenen sonucu elde etmek için kalıp eşleşmesi gerekir ve hata durumuyla başa çıkmanız gerekir.

Tek sorun, potansiyel olarak aşırı denetime yol açabilecekleri; Onları kullanan diller, onları kullanan fonksiyonların çağrılarını zincirlemek için deyimlere sahiptir, ancak yine de biraz daha fazla yazma / karışıklık gerektirebilir. Haskell'de bu monadlar olurdu ; Ancak, bu göründüğünden çok daha korkunç, bkz. Demiryolu Yönelimli Programlama .

Bence korkunç. Şu anda istisnalar yerine return değerleri kullanan bir Java uygulamasını yeniden gözden geçiriyorum. Java ile hiç çalışmıyor olsanız da, bunun yine de geçerli olduğunu düşünüyorum.

Bunun gibi bir kodla bitirdiniz:

String result = x.doActionA();
if (result != null) {
  throw new Exception(result);
}
result = x.doActionB();
if (result != null) {
  throw new Exception(result);
}

Veya bu:

if (!x.doActionA()) {
  throw new Exception(x.getError());
}
if (!x.doActionB()) {
  throw new Exception(x.getError());
}

Eylemlerin kendilerine istisnalar atmasını tercih ederim, sen de böyle bir şeyle bitirdin:

x.doActionA();
x.doActionB();

Bunu bir denemeye alabilirsiniz ve istisnadan mesaj alabilirsiniz veya istisnayı yok saymayı seçebilirsiniz, örneğin daha önceden gitmiş olabilecek bir şeyi silerken. Ayrıca, varsa, yığın izinizi korur. Yöntemlerin kendileri de kolaylaşıyor. İstisnaları kendileri halletmek yerine, sadece yanlış olanı atıyorlar.

Geçerli (korkunç) kod:

private String doActionA() {
  try {
    someOperationThatCanGoWrong1();
    someOperationThatCanGoWrong2();
    someOperationThatCanGoWrong3();
    return null;
  } catch(Exception e) {
    return "Something went wrong!";
  }
}

Yeni ve geliştirilmiş:

private void doActionA() throws Exception {
  someOperationThatCanGoWrong1();
  someOperationThatCanGoWrong2();
  someOperationThatCanGoWrong3();
}

Çatlak izi korunur ve yararsız "Bir şeyler ters gitti!" Yerine mesaj istisna dışında bulunur.

Elbette daha iyi hata mesajları sağlayabiliyorsunuz ve almalısınız. Ancak bu yazı burada üzerinde çalışıyorum çünkü şu an üzerinde çalıştığım kod bir acı ve aynısını yapmamalısınız.

"Birkaç olası hatayla başa çıkmak için, bu yürütmeyi durdurmamalıdır"

Hataların mevcut işlevin yürütülmesini durdurmaması gerektiğini, ancak arayana bir şekilde bildirilmesi gerektiğini kastediyorsanız - o zaman gerçekten bahsedilmeyen birkaç seçeneğiniz vardır. Bu dava gerçekten bir hatadan çok bir uyarıdır. Atma / Geri Dönme, mevcut işlevi sona erdiren bir seçenek değildir. Tek bir hata mesajı parametresi veya dönüşü, bu hatalardan yalnızca birinin gerçekleşmesine izin verir.

Kullandığım iki kalıp:

• Bir hata / uyarı koleksiyonu ya geçti ya da üye değişkeni olarak tutuldu. Hangi şeyleri eklersiniz ve işlemeye devam edersiniz. Ben şahsen bu yaklaşımı pek sevmiyorum çünkü arayanı rahatsız ediyor.

• Bir hata / uyarı işleyici nesnesini iletin (veya onu bir üye değişkeni olarak ayarlayın). Ve her hata işleyicinin bir üye işlevini çağırır. Bu şekilde arayan kişi, bu gibi sonlandırmayan hatalarla ne yapılacağına karar verebilir.

Bu koleksiyonlara / işleyicilere aktardıklarınız, "doğru" bir şekilde işlenecek hatanın yeterince bağlamı içermelidir - Bir dize genellikle çok azdır, bir istisna örneğini iletmek çoğu zaman mantıklıdır - ancak bazen kaşlarını çatmıştır (İstisnalar kötüye kullanımı olarak) .

Bir hata eylemcisi kullanan tipik kod şöyle görünebilir

class MyFunClass {
  public interface ErrorHandler {
     void onError(Exception e);
     void onWarning(Exception e);
  }

  ErrorHandler eh;

  public void canFail(int i) {
     if(i==0) {
        if(eh!=null) eh.onWarning(new Exception("canFail shouldn't be called with i=0"));
     }
     if(i==1) {
        if(eh!=null) eh.onError(new Exception("canFail called with i=1 is fatal");
        throw new RuntimeException("canFail called with i=2");
     }
     if(i==2) {
        if(eh!=null) eh.onError(new Exception("canFail called with i=2 is an error, but not fatal"));
     }
  }
}

Herkesin kullandığı deseni kullandığınız sürece, bu deseni veya bu deseni kullanmakta genellikle yanlış bir şey yoktur. Gelen Amaç-Cı geliştirme, çok tercih edilen bir model olarak adlandırılan metot, NSError nesne yatırmak bir işaretçi geçmektir. İstisnalar programlama hataları için ayrılmıştır ve bir çökmeye yol açar (Java veya .NET programcılarını ilk iPhone uygulamalarını yazmadığınız sürece ). Ve bu oldukça iyi çalışıyor.

Soru çoktan cevaplandı ama kendime yardımcı olamıyorum.

İstisna'nın tüm kullanım durumları için bir çözüm sunmasını gerçekten bekleyemezsiniz. Kimseyi çekiçle?

İstisnaların her şeyin sonu olmadığı ve hepsinin olabileceği durumlar vardır, örneğin, bir yöntem bir istek alırsa ve geçen tüm alanları doğrulamaktan sorumluysa ve yalnızca birincisini değil, bunun mümkün olacağını düşünmeniz gerekir. Birden fazla alan için hatanın nedenini belirtin. Doğrulamanın niteliğinin kullanıcının daha ileri gitmesini engelleyip engellemediğini de belirtmek mümkün olmalıdır. Buna bir örnek, güçlü olmayan bir şifre olabilir. Kullanıcıya girilen parolanın çok güçlü olmadığını, ancak yeterince güçlü olduğunu belirten bir mesaj gösterebilirsiniz.

Bütün bu validasyonların validasyon modülünün sonunda bir istisna olarak atılabileceğini, ancak adından başka bir şeyde hata kodları olacağını iddia edebilirsiniz.

Yani buradaki ders: İstisnalar, hata kodları gibi kendi yerlerine sahiptir. Akıllıca seçti.

İstisnalara göre hata kodlarının tercih edilebileceği durumlar vardır.

Hataya rağmen kodunuz devam ederse, ancak bildirilmesi gerekiyorsa, istisnalar akışı sonlandırdığı için istisnalar kötü bir seçimdir. Örneğin, bir veri dosyasında okuyorsanız ve terminalde olmayan bazı kötü veriler bulunduğunu keşfederseniz, dosyanın geri kalanında okumak ve hatayı düpedüz yerine rapor etmek daha iyi olabilir.

Diğer cevaplar, istisnaların neden genel olarak hata kodları olarak tercih edilmesi gerektiğini ele almıştır.

İstisnalar uygun olmadığında istisnalar kullanmamakta kesinlikle yanlış bir şey yoktur.

Kod yürütme kesintiye olmamalı zaman (örneğin derlemeye bir program veya sürecine formu gibi, birden fazla hatalar içerebilir kullanıcı girişi üzerinde hareket eden), ben gibi hata değişkenleri hataları toplama bulmak has_errorsve error_messagesgerçekten atma çok daha zarif bir tasarım ilk hatada bir istisna. Kullanıcının gereksiz yere yeniden göndermeye zorlamadan kullanıcı girişindeki tüm hataları bulmasını sağlar.

Bazı dinamik programlama dillerinde her iki kullanabilirsiniz hata değerlerini ve durum işleme . Bu, bir hata değeri gibi kontrol edilebilecek normal geri dönüş değerinin yerine çıkarılmamış istisna nesnesi döndürülerek yapılır , ancak kontrol edilmezse istisna atar.

Gelen Perl 6 ile yapılıyor failWithing halinde, bu no fatal;kapsamı özel unthrown durum döner Failurenesne.

In Perl 5 kullanabileceğiniz İçeriğe :: İade sen ile yapabilirsiniz return FAIL.

Çok özel bir şey olmadığı sürece, doğrulama için bir hata değişkenine sahip olmanın kötü bir fikir olduğunu düşünüyorum. Amaç doğrulama için harcanan zamanı kaydetmemek gibi görünüyor (sadece değişken değerini geri döndürebilirsiniz)

Fakat bir şeyi değiştirirseniz, yine de bu değeri yeniden hesaplamanız gerekir. Durma ve İstisna atma hakkında daha fazla şey söyleyemem.

EDIT: Bunun belirli bir durum yerine yazılım paradigması meselesi olduğunun farkında değildim.

Cevabımın mantıklı olacağı belirli bir madende durumumu daha da açıklığa kavuşturayım

1. Bir varlık nesneleri koleksiyonum var
2. Bu varlık nesnelerle çalışan ussal stil web hizmetlerine sahibim

İki tür hata vardır:

1. İşlemin servis katmanında meydana geldiği hatalar
2. Varlık nesnelerinde tutarsızlıklar olduğu için hatalar

Servis katmanında, Result nesnesini, hata değişkeninin eşdeğeri olan sarıcı olarak kullanmaktan başka bir seçenek yoktur. Bir istisnayı http gibi protokol üzerinden servis çağrısı yoluyla simüle etmek mümkündür, ancak kesinlikle yapılması gereken iyi bir şey değildir. Bu tür bir hatadan bahsetmiyorum ve bunun bu soruda sorulmakta olan bir hata olduğunu düşünmedim.

İkinci tür hatayı düşünüyordum. Ve cevabım bu ikinci tür hatalarla ilgili. Varlık nesnelerinde, bizim için seçenekler var, bazıları

• doğrulama değişkeni kullanma
• bir alan ayarlayıcıdan yanlış ayarlandığında hemen bir istisna atmak

Doğrulama değişkenini kullanmak, her varlık nesnesi için tek bir doğrulama yöntemine sahip olmakla aynıdır. Özellikle, kullanıcı, ayarlayıcıyı tamamen ayarlayıcı olarak tutacak şekilde ayarlayabilir, hiçbir yan etkisi olmaz (bu genellikle iyi bir uygulamadır) veya biri onaylayıcıyı her ayarlayıcıya dahil edebilir ve ardından sonucu bir doğrulama değişkenine kaydedebilir. Bunun avantajı zamandan tasarruf sağlamaktır, doğrulama sonucu doğrulama değişkenine önbelleğe alınır, böylece kullanıcı validation () birden fazla kez aradığında, çoklu doğrulama yapmaya gerek kalmaz.

Bu durumda yapılacak en iyi şey, doğrulama hatasını önbelleğe almak için herhangi bir doğrulama kullanmadan tek bir doğrulama yöntemi kullanmaktır. Bu, ayarlayıcıyı yalnızca ayarlayıcı olarak tutmanıza yardımcı olur.