Boolean temizleyici ile nasıl arama yapabilirim? Boole Tuzağı

@ Benjamin-gruenbaum tarafından yapılan yorumlarda belirtildiği gibi, buna Boolean tuzağı denir:

Diyelim ki böyle bir işleve sahibim.

UpdateRow(var item, bool externalCall);

ve denetleyicimde, bu değer externalCallher zaman TRUE olacaktır. Bu işlevi çağırmanın en iyi yolu nedir? Ben genellikle yazarım

UpdateRow(item, true);

Ama kendime soruyorum, sadece 'gerçek' değerin ne anlama geldiğini göstermek için bir boolean ilan etmeli miyim? İşlevin bildirgesine bakarak bunu biliyorsunuz, ancak bunun gibi bir şey gördüyseniz çok daha hızlı ve net.

bool externalCall = true;
UpdateRow(item, externalCall);

PD: Bu soru gerçekten buraya uyup uymadığından emin değil, eğer değilse, bu konuda nereden daha fazla bilgi alabilirim?

PD2: Hiçbir dili etiketlemediğim için bunun çok genel bir sorun olduğunu düşündüm. Neyse, ben c # ile çalışıyorum ve kabul edilen cevap c # için çalışıyor

Her zaman mükemmel bir çözüm yoktur, ancak aralarından seçim yapabileceğiniz birçok alternatifiniz vardır:

• Dilinizde varsa adlandırılmış değişkenleri kullanın . Bu çok iyi çalışıyor ve özel bir dezavantajı yok. Bazı dillerde, herhangi bir argüman, örneğin updateRow(item, externalCall: true)( C # ) veya update_row(item, external_call=True)(Python) gibi adlandırılmış bir argüman olarak geçirilebilir .

  Ayrı bir değişken kullanma öneriniz, adlandırılmış argümanları simüle etmenin bir yoludur, ancak ilişkili güvenlik avantajlarına sahip değildir (bu argüman için doğru değişken adını kullandığınızın garantisi yoktur).

• Genel arabiriminiz için daha iyi adlarla farklı işlevler kullanın . Bu, parametreyi adına koyarak, adlandırılmış parametreleri simüle etmenin başka bir yoludur.

  Bu çok okunaklı, ancak bu işlevleri yazan sizin için bir çok kazana yol açıyor. Ayrıca, birden fazla boolean argümanı olduğunda, kombinasyonsal patlama ile de başa çıkamaz. Önemli bir dezavantajı, istemcilerin bu değeri dinamik olarak ayarlayamaması, ancak doğru işlevi çağırmak için if / else kullanmaları gerektiğidir.

• Enum kullanın . Booleanlarla ilgili problem, “doğru” ve “yanlış” olarak adlandırılmasıdır. Öyleyse, daha iyi adlara sahip bir tür tanıtın (örneğin enum CallType { INTERNAL, EXTERNAL }). Ek bir avantaj olarak, bu , programınızın tür güvenliğini arttırır (eğer diliniz farklı türler veriyorsa). Enums dezavantajı, herkes tarafından görülebilen API'nize bir tür eklemeleridir. Tamamen iç fonksiyonlar için, bu önemli değil ve numaralandırmaların önemli dezavantajları yoktur.

  Enums olmayan dillerde, bunun yerine bazen kısa dizeler kullanılır. Bu işe yarar ve ham booleanlardan bile daha iyi olabilir, ancak yazım hatalarına karşı çok hassastır. Ardından fonksiyon hemen argümanın bir dizi olası değer ile eşleştiğini iddia etmelidir.

Bu çözümlerin hiçbiri engelleyici bir performans etkisine sahip değildir. Adlandırılmış parametreler ve numaralamalar derleme zamanında (derlenmiş bir dil için) tamamen çözülebilir. Dizelerin kullanılması bir dizge karşılaştırması içerebilir, ancak bunun maliyeti küçük dize değişmezleri ve çoğu uygulama için önemsizdir.

Doğru çözüm, önerdiğiniz şeyi yapmaktır, ancak bir mini cepheye paketleyin:

void updateRowExternally() {
  bool externalCall = true;
  UpdateRow(item, externalCall);
}

Okunabilirlik, mikro optimizasyondan kaynaklanıyor. Ekstra işlev çağrısı, Boolean bayrağının anlambilimine bir kez bile bakma zorunluluğunu gösterebildiğinizden daha iyi olabilir.

UpdateRow (var item, bool externalCall);

Neden böyle bir işlevin var?

Hangi koşullar altında , farklı değerlere ayarlanmış externalCall argümanı ile çağırırsınız?

Biri harici bir istemci uygulamasından geliyorsa, diğeri aynı programın içinde ise (yani farklı kod modülleri), o zaman her durumda bir tane olmak üzere iki ayrı yönteme sahip olmanız gerektiğini düşünüyorum , muhtemelen ayrı ayrı tanımlanmış olsa bile Arabirimler.

Bununla birlikte, aramayı program dışı bir kaynaktan alınan bazı verileri temel alarak yapıyorsanız (örneğin, bir yapılandırma dosyası veya veritabanı okundu), Boole geçiş yöntemi daha mantıklı olur.

Hem okunabilirliği hem de değer güvenliğini güçlendirmek için bir dil özelliği kullanmanın ideal olduğunu kabul etmeme rağmen , pratik bir yaklaşımı da tercih edebilirsiniz : arama zamanı yorumları. Sevmek:

UpdateRow(item, true /* row is an external call */);

veya:

UpdateRow(item, true); // true means call is external

veya (haklı olarak, Frax tarafından önerildiği gibi):

UpdateRow(item, /* externalCall */true);

1. Göletlerini 'adlandırabilirsin'. Aşağıda OO diline bir örnek (sınıfta ifade edilebildiği yerde UpdateRow()), ancak kavramın kendisi herhangi bir dilde uygulanabilir:

   class Table
   {
   public:
       static const bool WithExternalCall = true;
       static const bool WithoutExternalCall = false;
   

   ve çağrı sitesinde:

   UpdateRow(item, Table::WithExternalCall);
   

2. Öğe # 1'in daha iyi olduğuna inanıyorum, ancak işlevi kullanırken kullanıcıyı yeni değişkenler kullanmaya zorlamıyor. Tip güvenliği sizin için önemliyse, bir enumtür oluşturabilir ve UpdateRow()bunu yerine aşağıdakileri kabul edebilirsiniz bool:

   UpdateRow(var item, ExternalCallAvailability ec);

3. Fonksiyonun ismini bir şekilde boolparametrenin anlamını daha iyi yansıtacak şekilde değiştirebilirsiniz . Çok emin değil ama belki:

   UpdateRowWithExternalCall(var item, bool externalCall)

Burada henüz okumadım başka bir seçenek: Modern bir IDE kullanın.

Örneğin IntelliJ IDEA siz bir hazır böyle geçerken eğer aradığınız yönteminde değişkenlerin değişken adı basar trueya nullya username + “@company.com. Bu küçük bir yazı tipinde yapılır, böylece ekranınızda çok fazla yer kaplamaz ve gerçek koddan çok farklı görünür.

Hala her yere boolean atmanın iyi bir fikir olduğunu söylemiyorum. Yazdığınızdan çok daha sık kod okuduğunuzu belirten argüman çoğu zaman çok güçlüdür, ancak bu özel durum için işinizi desteklemek için kullandığınız teknolojiye (ve iş arkadaşlarınıza!) Büyük ölçüde bağlıdır. Bir IDE ile, örneğin vim'den çok daha az problem olur.

Test kurulumumun bir bölümünün değiştirilmiş örneği:

2 gün ve hiç kimse polimorfizmden bahsetmedi mi?

target.UpdateRow(item);

Bir öğeyi içeren bir satırı güncellemek isteyen bir müşteriyken, veritabanının adı, mikro hizmetin URL'si, iletişim kurmak için kullanılan protokol veya harici bir aramanın olup olmadığı hakkında düşünmek istemiyorum. Bunun gerçekleşmesi için kullanılması gerek. Bu detayları üzerime çekmeyi bırak. Sadece eşyamı al ve git bir yerden bir yere git.

Bunu yapın ve inşaat sorununun bir parçası haline gelir. Bu birçok yolla çözülebilir. Işte bir tane:

Target xyzTargetFactory(TargetBuilder targetBuilder) {
    return targetBuilder
        .connectionString("some connection string")
        .table("table_name")
        .external()
        .build()
    ; 
}

Eğer buna bakıyor ve "Ama benim dilimin argümanları var, buna ihtiyacım yok" diye düşünüyorsan. Güzel, harika, git onları kullan. Sadece bu saçmalığı, neyle konuştuğunu bile bilmemesi gereken arayan müşteriden uzak tutun.

Bunun anlamsal bir problemden daha fazlası olduğu belirtilmelidir. Aynı zamanda bir tasarım problemi. Bir boole geçmek ve onunla başa çıkmak için dallanma kullanmak zorunda kalırsınız. Nesne yönelimli değil. İçeri girmek için iki veya daha fazla boole var mı? Dilinizin birden fazla gönderimi olmasını ister misiniz? Yuvalarken koleksiyonların neler yapabileceğini araştırın. Doğru veri yapısı hayatınızı çok daha kolaylaştırabilir.

updateRowİşlevi değiştirebiliyorsanız , belki de iki işleve yeniden uygulayabilirsiniz . İşlev boolean bir parametre aldığında, şöyle gözüktüğünden şüpheleniyorum:

function updateRow(var item, bool externalCall) {
  Database.update(item);

  if (externalCall) {
    Service.call();
  }
}

Biraz kod kokusu olabilir. İşlev, externalCalldeğişkenin ne olduğuna bağlı olarak, önemli ölçüde farklı davranışlara sahip olabilir , bu durumda iki farklı sorumluluğu vardır. Yalnızca bir sorumluluğu bulunan iki işleve yeniden yerleştirmek okunabilirliği artırabilir:

function updateRowAndService(var item) {
  updateRow(item);
  Service.call();
}

function updateRow(var item) {
  Database.update(item);
}

Şimdi, bu işlevleri çağırdığınız her yerde, harici servisin aranıp aranmadığını bir bakışta anlayabilirsiniz.

Elbette bu her zaman böyle değildir. Durumsal ve zevk meselesi. Bir boolean parametresini iki işleve alan bir işlevi yeniden düzenlemek genellikle göz önünde bulundurmaya değerdir, ancak her zaman en iyi seçenek değildir.

UpdateRow kontrollü bir kod tabanında ise, strateji modelini düşünürdüm:

public delegate void Request(string query);    
public void UpdateRow(Item item, Request request);

İsteğin bir tür DAO'yu temsil ettiği (önemsiz durumlarda geri arama).

Gerçek durum:

UpdateRow(item, query =>  queryDatabase(query) ); // perform remote call

Yanlış dava:

UpdateRow(item, query => readLocalCache(query) ); // skip remote call

Genellikle, uç nokta uygulaması daha yüksek bir soyutlama seviyesinde yapılandırılır ve burada sadece kullanırdım. Yararlı bir serbest yan etki olarak, bu bana kodda herhangi bir değişiklik yapmadan uzaktaki verilere erişmek için başka bir yol kullanma seçeneği sunar:

UpdateRow(item, query => {
  var data = readLocalCache(query);
  if (data == null) {
    data = queryDatabase(query);
  }
  return data;
} );

Genel olarak, bu tür bir kontrolün ters çevrilmesi, veri depolama alanınız ve modeliniz arasında daha az bağlantı sağlar.