== doğru büyük bir anlaşma yapmak?

Sürekli yazan bir meslektaşım var:

if (someBool == true)

Beni duvara sürükledi! Büyük bir şey yapmalı mıyım yoksa sadece düşürmeli miyim?

Bu sadece gereksiz kod, yaşam veya ölüm değil. Ancak....

Çok oluyorsa, nasıl someBooladlandırıldığına dair bir sorun olabilir . İyi bir isim, ihtiyacını ortadan kaldırmak için uzun bir yol kat edebilir.==true

if(IsSomeCondition)

veya

if(hasCondition)

veya

if(somethingExists)

Örneğin.

Ben gördüğümde someBool == true, ben yardım edemem ama programcı fikrini içselleştirilmiş değildir hissetmeye değerlendirmede oldukça temel eksikliktir.

Bununla birlikte, bakış açım çarpıtıldı çünkü üniversiteye öğretim programlarında birkaç yaz geçirdim, çünkü çocuklara sık sık böyle ifadeler yazdılar çünkü bir ifadeyi değerlendirmenin zihinsel egzersizinde ustalaşmamışlardı. Kavramı karıştırdıklarında, artıklık belirgin hale geldi.

Başka türlü yetkin bir profesyonel programcı için, bu muhtemelen durum böyle değil. Muhtemelen, programlamanın ilk günlerinde geliştirdikleri kötü bir alışkanlıktı ve asla sarsılmadı. Ama birisinin röportajda yaptığını ilk gördüğüm şey olsaydı, yine de beni biraz korkuturdu.

Bu da beni çıldırtıyor, ancak yapıcı bir şekilde kendilerine fazlalıktan bahsettiğimi ve sonra da aynı fikirde olmasalar bile bıraktıklarını söyleyebilirim.

Alternatif olarak bu yaklaşımı deneyebilirsiniz:
Siz: Boolean'leri değerlendirmek için aşağıdaki kod kurallarını kullanmaya başlayabilir misiniz?

if (someBool==true)&&(true==true) {}

Onlar: Neden bunu yapalım? Bu ifadenin ikinci yarısı gereksizdir, her zaman doğru olarak değerlendirilirdi.

Sen: George, haklısın. Aptal ben. O zaman tüm yedeklilik olmadan bir sürümle gidelim. Peki ya

if (someBool) {}

Bence, çok önemsiz bir şey iş arkadaşlarınızla en büyük probleminizse, kendinizi çok şanslı saymalısınız.

Bu kötü alışkanlığı kesinlikle durdurmalısın. Nazikçe...

İkili eşit işaretler yazarak, kodun içine dönüştüğünü unutmak kolaydır:

if (someBool = true)

Örneğin C # 'da bu sadece bir uyarı üretecektir, bir hata üretmeyecektir. Bu nedenle, uyarıları hatalar gibi işlemezseniz, değişkeni true değerine ayarlayın ve her zaman koşulu girin.

Seninle aynı fikirdeyim ama burada şeytanın avukatı oynayacağım:

Dile ve değişkenin adına bağlı olarak, x == true uygundur:

İntegral tipler için statik yazım ve zorlama türü olan bir dilde aşağıdaki durumu göz önünde bulundurun:

if (actionsAllowed){
    //do actions, since they are allowed
    //...
}

Kodun bu bölümünü okuyan bir kişi, actionsAllowed öğesinin bir boolean değişkeni olduğunu hemen fark etmeyebilir - aynı zamanda izin verilen işlemlerin sayısını temsil eden bir tam sayı da olabilir. Yani == true ekleyerek, x'in bir boole olduğu ve bir boole zorlanan bir tamsayı olmadığı anlaşılır:

if (actionsAllowed == true){
    //do actions, since they are allowed
    //...
}

Null bools?

bool? MyFlag = null;

if (MyFlag == true)
    ;  

if (MyFlag)  // error, doesn't compile!
    ; 

Genelde, söz konusu sözleşme bir şekilde projeyi önemli ölçüde engellemediği sürece, kodlama sözleşmelerinden çok fazla bir şey yapmak istemezsiniz. Birçoğunun, kod bölgeleri ve öncü alt çizgiler kadar küçük olan şeylerin üzerinde arttığını gösteren bir argüman gördüm.

Söyleniyor, == trueşartlı bir ifadeye ekleme ile ilgili herhangi bir sorun görmüyorum . Nitekim, == falseolumsuz koşullar için test yaparken önde gelen bir ünlem işaretinin aksine kullanma alışkanlığım var . Bence daha okunaklı.

Yerleşmiş bir kongre varsa, değişmek için bir neden olmadığı sürece onu takip ediyorum derim. Ancak, hakkında büyük bir kıyameti arttırmaya değmez.

Ack. Ben o adamım Utanç, utanç. Bu şekilde öğrendim ve kafamda “otomatik biçimlendirme” yapıyorum. Joel'in tercih edilen sözdizimini kullandığım tek zaman, bool değişkeninin "is" gibi bir fiil önekine sahip olmasıdır. Fiilene ihtiyacım var, "olabilir," "olabilir," "yaptı" ya da "eşit" fiilini sağlamak için == 'ye ihtiyacım var. Asla bu alışkanlığı bozmayacağım, o yüzden sokakta bana 'merhaba' demiyorsanız anlayacağım.

bana "boolean delilik kodunu" hatırlat, bunun gibi

if(someBool == true)
   otherBool = false;
else
   otherBool = true

Onun yerine:

 otherBool = !someBool

Şahsen C tabanlı dillerde "hayır" deme şeklinden kesinlikle hoşlanmıyorum. Bu küçük ünlem işareti göz ardı etmek çok kolaydır.

Bu yüzden tam olarak yazıyorum:

if (someCondition == false) {

Bunu bir süre okuduktan sonra, ben de simetri istiyorum.

if (someCondition == true) {

Öyleyse !bunun yerine C kullanarak bir yapı olarak düşünün not.

Dile bağlı, ama genellikle kötü bir fikir ...

C de, bunu asla yapma. Test ettiğiniz değerin yanlış olmadığı (sıfır olmayan), aynı zamanda "true" olarak tanımlanan tek değere eşit olmadığı bir durum bulmak çok kolaydır.

Ruby'de, bunu yalnızca Boolean true dışındaki her şeyde başarısız olmak istediğinizden eminseniz yapın.

C ++ ve bool türü ile diğer statik dillerde, gereksiz, ve sen yanlış yazan zaman programlama hatalarına yol açabilir =yerine ==, veya promosyon hataları yorumlarda belirtildiği gibi.

Sence bu kötü mü? Peki ya:

if(someCondition) {
  return true;
} else {
  return false;
}

tercih ederim

if (bVal)

veya

if (!bVal)

Ben de, onu büyütmenin insanları kızdıracağından korkuyorum, bu yüzden tavsiyem unutmak. Üzgünüm!

Ona yanlış yaptığını söylemelisin.

onun

if (true == someBool) {

}

eğer birini unutursa = yazma stilinde büyük sıkıntıda.

Peki ya

if (x == "true")

Neden bu kadar zor ?!

Aslında, null ise, x == true için test etmek gerekli olacaktır. :)

Böyle bir kod yazıyorum!

İşte nedeni:

"if bla == true" bir cümle gibi okur, burada "if bla" birçok durumda böyle olmaz. Sadece gerçek kodu OKUYOR yanlış sesler.

Ayrıca derleyici eğer bloklar halinde yapılan ödevler hakkında uyarır, bu yüzden == true komutunu kullanmanın hiçbir tehlikesi yoktur. (= ile karıştırarak)

Ayrıca "== true" yazamayanlar, "== false" için şunu kullanın! Gerçekten çok çirkin buluyorum. Ve eğer "== false" kullanırsanız, gerçeği doğrulamak için iki farklı yol kullanmak yerine, "== true" ifadesini kullanmak sadece çok tutarlıdır.

Bir takımın parçası olarak çalıştığınızı unutmayın, bu yüzden birlikte çalışmanız gerekir. "Başkalarıyla iyi oynar" ilkokuldan sonra bile hala önemli bir kişilik özelliğidir :)

Genel olarak '== true' ifadesini çıkarır, ancak ekibinizin kodlama standartlarına dahil etmediğiniz sürece tartışmaya bile bir dakika değmez.

Temel olarak C # geliştiricisi olarak hemfikir olsam da, bunun her zaman böyle olduğunu söyleyemem. Örneğin, Javascript'te, === tür birleşimini gerçekleştirir. Öyleyse var x = 3 varsayılırsa :

if(x) --> true

süre

if (x === true) --> false

Sanırım bu == 'den farklı. Çünkü JS’de bile kullanmam. (X == true) .

Ofisimde ortaya çıkan bu tür başka bir noktada dokunuşlar:

bool b = false;

C # 'de, bool; yeterli olacağını ve initalize ediyorum b için yanlış . Bununla birlikte, yukarıdaki satırı yazmak daha açıktır ve yine de optimizasyon sırasında derleyici tarafından sökülmelidir.

Bu yüzden, benim açımdan her şeyin çok açık olmadığı ve iyi uygulamaların ne olduğu ve ne kadar olmadığı açık olduğunu tahmin ediyorum.

Ah evet, fakat değişken null ise? (Bool?)

Bazı diller (C #) 'true' dilini seçmeli ve kullanmalıdır.

bool? isAccepted = true;

if((bool)isAccepted)
{...}

if(isAccepted == true)
{...}

Genç kuralları biliyor, ama yaşlı istisnaları biliyor;)

Sonunda C#, bir ile başa null-able boolçıkıyorsanız, o zaman yapmanız gereken:

bool? x = null;
bool? y = true;
bool? z = false;
if (x == true || y == true || z == true) {
    // That was the only way that is reasonably readable that I know of
    // to accomplish this expression.
}

Tristat sorun değilse, genellikle true/ ile karşılaştırmak için bir sebep olmamalıdır True. Bununla birlikte, içinde Pythonve C/C++sizin gibi birkaç başka dilde ifbir bool olmayan ifadede gerçekleştirebilirsiniz. Bu dillerin tamsayıları, işaretçileri, listeleri vb. Doğru ya da yanlış olarak yorumlaması için benzersiz kuralları vardır. Bazen bunu istemezsin. Örneğin, bu Python kod parçasında:

x = True
y = 'abcdef'
z1 = x and y
z2 = (x == True) and (y == True)

Burada zolmalı True, fakat z2olmalıdır False. Şimdi, bir Clojuredil buna başka bir yoldan yaklaşır - orada andişlev mutlaka bir a'ya göre değerlendirilmez bool, bununla ifbaşa çıkabilir.

Ne olursa olsun dilin, her zaman kendinizi bir şeyler karşılaştırarak bulmak Trueya False, muhtemelen yorumlama değer.

Böyle bir kodlama beni daha önce yanlış bir şekilde ovalardı. Örnek tanımlayıcınız "someBool" olarak adlandırılsa da, bu kodlama stilini yanlışlıkla bir boolean olduğu garanti edilmeyen bir değişkende yanlışlıkla kullanmak, istenmeyen davranışlara neden olabilir. "SomeBool" değeri tam olarak "true" veya "false" değilse, sonuç yanlış olur.

Geçen yıl tanımlanması zor olan bir kodlama tarzının neden olduğu çok ince bir hatayla karşılaştım çünkü birinin gözleri bu tür yapılar üzerinde parlıyordu. "Nasıl yanlış olabilir?" Diye düşünürdünüz. Aynısı, davranışlarını doğrulamadan okuduğunuz veya kodladığınız "(var)" veya "(! Var)" gibi iyi anlaşılmış ifadeler için de geçerlidir.

Bu nedenle kodbasedeki bu tür böceklerin varlığını azaltmak ve bu ince böceklerin gelecekte bir anda yanlışlıkla sürünme ihtimalini azaltmak için birkaç kodlama standardı getirdim.

1. Tüm ifadeler, amaçlarına göre parantez içine alınmalıdır.
2. Tüm boolean testleri "suchBool! = False" gibi negatif olarak ifade edilmelidir.

Yeni stile uygun olmayan kodu temizleyerek, bu tür ince hataların birkaç örneğini tanımladım ve düzelttim.

Bunu her zaman ActionScript 2'de kullanmak zorunda kaldım (kuşkusuz şimdi ölü bir dil), çünkü:

var something:Boolean = org.black.box.unknown.ThisMightNotExistYet();

// this is slightly ambiguous
if(something)
{
}

// because if you allow undefined you might actually mean
if(false != something)
{
}

// which can mean something different than
if(true == something)
{
}

// and comparing against what you actually MEAN is less script than
if(undefined != value && value)
{
}

Bu yüzden spesifik olmak neredeyse her zaman en iyisiydi.

Katılıyorum. Özellikle güçlü yazı dillerinde gereksiz bir yapıdır.

Booleanların başka bir suistimalini eklemek için, bu tür bir inşaatı Javascript'te (özellikle 100'den fazla satırda olduğu gibi spagetti benzeri canavar fonksiyonlarında) birkaç kez buldum:

//create the variable, not initializing it
var flag;
//...
//assing a value to the var, by the example 
flag=$("mycheckbox").selected;
//...

//and at the moment of use it:
if(flag!=true) {
   //code to execute when the checkbox is unchecked
}

Görünüşe göre, bu dilde katı bir tür tanımın bulunmamasından dolayı, bazı programcılar false|undefineddeğerlerle uğraşmak zorunda kalmamayı tercih ediyorlar .

Bunun gibi bir kodu olacak bir meslektaşım var:

if(something == true)

Ve sonra, bir çeşit test / hata ayıklama için, bu bloğu çağırmak istemeyecek, böylece onu değiştirecek:

if(something == true && false)

Ve sonra ara sıra değiştirecek:

if(false)

En kötüsü, bu tür hata ayıklama, zaman zaman üzerime sürtündü ve diğer geliştiricilerin okuması gerçekten kötü!

Tutarlılığın bir kod tabanında kral olduğunu söyleyebilirim. Bu nedenle, çoğunlukla kuruluşunuzda kullanılan stili kullanmalısınız . Tercih ettiğiniz stili resmi şirket kodlama kurallarının bir parçası yapmaya çalışın. Zaten kurallara uygunsa, sadece onu takip et.

(Bu söyleniyor, beni de gerçekten sinirlendiriyordu - ama büyük bir anlaşma yapmak için muhtemelen yeterli değil).

Ekstra == doğru yerleştirmeyi tercih etmiyorum, ancak bazen yanlışlıkla ekliyorum ve farketmiyorum. Kişi onları fark etmemiş ve yanlışlıkla yerleştirmemiş olabilir. Kodumu yeniden okudum ve bazen ekstra == true koyduğumu fark ettim, bu yüzden şunu kaldırdım == true. Bazen bunu fark etmiyorum ve mutlu bir şekilde bana gereksiz yere yerleştirdiğimi söyler.

peki ya:

int j = 1;
for (int i=1; i>=j; i++) ...

Evet, gördüm.