Geçiş ifadesi düşüşü… buna izin verilmeli mi? [kapalı]

Hatırlayabildiğim sürece, anahtar deyimi düşüşünü kullanmaktan kaçındım. Aslında, bunun anahtar ifadesindeki bir hatadan başka bir şey olmadığı için başıma delindiği için, bir şeyler yapmanın olası bir yolu olarak bilincime girdiğini hiç hatırlayamıyorum. Ancak bugün, onu tasarım gereği kullanan bir kodla karşılaştım ve bu da beni hemen topluluktaki herkesin switch deyiminin düşmesi hakkında ne düşündüğünü merak etmeye itti.

Bu, bir programlama dilinin açıkça izin vermemesi gereken bir şey mi (bir geçici çözüm sağlasa da C # gibi) ya da programcının eline bırakacak kadar güçlü herhangi bir dilin özelliği mi?

Düzenleme: Düşüş ile ne demek istediğime yeterince spesifik değildim. Bu türü çok kullanıyorum:

    switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something
            break;
        case 2:
        case 3:
        case 4:
            // Do something
            break;
   }

Ancak bunun gibi bir şeyle ilgileniyorum.

   switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something, but fall through to the other cases
            // after doing it.

        case 2:
        case 3:
        case 4:
            // Do something else.
            break;
   }

Bu şekilde, vaka 0, 1 olduğunda, switch ifadesindeki her şeyi yapacaktır. Bunu tasarım gereği gördüm ve switch ifadelerinin bu şekilde kullanılması konusunda hemfikir olup olmadığımı bilmiyorum. İlk kod örneğinin çok kullanışlı ve güvenli olduğunu düşünüyorum. İkincisi biraz tehlikeli görünüyor.

Düşüş olarak düşündüğünüz şeye bağlı olabilir. Bu tür şeylerde sorun yok:

switch (value)
{
  case 0:
    result = ZERO_DIGIT;
    break;

  case 1:
  case 3:
  case 5:
  case 7:
  case 9:
     result = ODD_DIGIT;
     break;

  case 2:
  case 4:
  case 6:
  case 8:
     result = EVEN_DIGIT;
     break;
}

Ancak bir kasa etiketiniz ve ardından başka bir kasa etiketine düşen kodunuz varsa, hemen hemen her zaman bu kötülüğü düşünürdüm. Belki de ortak kodu bir işleve taşımak ve her iki yerden çağırmak daha iyi bir fikir olabilir.

Ve lütfen C ++ SSS'nin "kötülük" tanımını kullandığımı unutmayın

İki ucu keskin bir kılıç. Bazen çok yararlıdır, ancak genellikle tehlikelidir.

Ne zaman iyidir? 10 davanın hepsinin aynı şekilde işlenmesini istediğinizde ...

switch (c) {
  case 1:
  case 2:
            ... Do some of the work ...
            /* FALLTHROUGH */
  case 17:
            ... Do something ...
            break;
  case 5:
  case 43:
            ... Do something else ...
            break;
}

Sevdiğim tek kural, molayı hariç tuttuğunuz bir şey yaparsanız, niyetinizin bu olduğunu belirtmek için net bir yoruma / * FALLTHROUGH * / ihtiyacınız olmasıdır.

Duff'un cihazını duydun mu? Bu, anahtar düşüşü kullanmanın harika bir örneğidir.

Neredeyse tüm dil özellikleri gibi kullanılabilen ve kötüye kullanılabilen bir özelliktir.

Düşüş, ne yaptığınıza bağlı olarak gerçekten kullanışlı bir şeydir. Seçenekleri düzenlemenin bu düzgün ve anlaşılır yolunu düşünün:

switch ($someoption) {
  case 'a':
  case 'b':
  case 'c':
    // Do something
    break;

  case 'd':
  case 'e':
    // Do something else
    break;
}

Bunu if / else ile yaptığınızı hayal edin. Bir karmaşa olurdu.

Birkaç kez çok faydalı olabilir, ancak genel olarak, istenen davranış hiçbir düşüş değildir. Düşmeye izin verilmelidir, ancak örtük olmamalıdır.

Bazı verilerin eski sürümlerini güncellemek için bir örnek:

switch (version) {
    case 1:
        // Update some stuff
    case 2:
        // Update more stuff
    case 3:
        // Update even more stuff
    case 4:
        // And so on
}

Anahtarlardaki geri dönüşler için farklı bir sözdizimi istiyorum, örneğin, errr ..

switch(myParam)
{
  case 0 or 1 or 2:
    // Do something;
    break;
  case 3 or 4:
    // Do something else;
    break;
}

Not: Bu, numaralandırmalarla zaten mümkün olurdu, eğer numaralandırmanızdaki tüm durumları bayrakları kullanarak bildirirseniz, değil mi? O kadar da kötü görünmüyor; vakalar zaten numaranızın bir parçası olabilir (olmalı?).

Belki de bu, uzantı yöntemlerini kullanan akıcı bir arayüz için güzel bir durum (kelime oyunu değildir) olabilir mi? Şey gibi bir şey ...

int value = 10;
value.Switch()
  .Case(() => { /* Do something; */ }, new {0, 1, 2})
  .Case(() => { /* Do something else */ } new {3, 4})
  .Default(() => { /* Do the default case; */ });

Muhtemelen daha az okunabilir olmasına rağmen: P

Her şeyde olduğu gibi: Dikkatli kullanılırsa zarif bir araç olabilir.

Ancak, ben daha çok dezavantajları haklı düşünüyorum değil kullanmak ve nihayet (C #) artık izin vermeyecek. Sorunlar arasında:

• bir molayı "unutmak" kolaydır
• kod geliştiriciler için atlanmış bir molanın kasıtlı olduğu her zaman açık değildir

Anahtar / kasa düşüşünün iyi kullanımı:

switch (x)
{
case 1:
case 2:
case 3:
 Do something
 break;
}

Baaaaad bir anahtar / durum düşüşünün kullanımı:

switch (x)
{
case 1:
    Some code
case 2:
    Some more code
case 3:
    Even more code
    break;
}

Bu, bence hiç kayıpsız if / else yapıları kullanılarak yeniden yazılabilir.

Son sözüm: Bu stilin kullanıldığı ve iyi anlaşıldığı yerlerde eski kodu sürdürmediğiniz sürece , kötü örnekte olduğu gibi düşme durum etiketlerinden uzak durun .

Güçlü ve tehlikelidir. Düşüşle ilgili en büyük sorun, açık olmamasıdır. Örneğin, sık sık düzenlenmiş, arızalı bir anahtarı olan bir kodla karşılaşırsanız, bunun kasıtlı olduğunu ve bir hata olmadığını nasıl anlarsınız?

Kullandığım her yerde, doğru şekilde yorumlanmasını sağlıyorum:

switch($var) {
    case 'first':
        // Fall-through
    case 'second':
        i++;
        break;
 }

İlk örneğinizdeki gibi düşüşü kullanmak açıkça tamamdır ve bunu gerçek bir hata olarak görmem.

İkinci örnek tehlikelidir ve (kapsamlı bir şekilde yorumlanmadıysa) açık değildir. Öğrencilerimin bu tür yapılar kullanmamayı öğretmek sürece onlar buna değer bu kasıtlı sonbahar-through olduğunu açıklar buna bir açıklama bloğu, ayırmaya çaba düşünün ve neden bu çözüm daha iyi alternatiflerinden daha olduğunu. Bu, özensiz kullanımı caydırır, ancak yine de bir avantaj için kullanıldığı durumlarda buna izin verir.

Bu, uzay projelerinde biri kodlama standardını ihlal etmek istediğinde yaptığımız şeye aşağı yukarı eşdeğer: muafiyet için başvurmak zorunda kaldılar (ve karar hakkında tavsiyede bulunmam istendi).

switchİfadelerimin düşmesini sevmiyorum - hataya çok açık ve okunması zor. Tek istisna, birden çok caseifadenin tamamen aynı şeyi yapmasıdır.

Bir switch ifadesinin birden çok dalının kullanmak istediği ortak bir kod varsa, bunu herhangi bir dalda çağrılabilecek ayrı bir ortak işleve çıkarırım.

Bazı durumlarda, hatalarını kullanmak programcı açısından bir tembellik eylemidir - bir dizi || ifadeler, ancak bunun yerine bir dizi 'tümünü yakala' anahtar durumu kullanın.

Bununla birlikte, nihayetinde seçeneklere yine de ihtiyacım olacağını bildiğimde (örneğin bir menü yanıtında), ancak tüm seçenekleri henüz uygulamadığımda özellikle yararlı buldum . Aynı şekilde, hem 'a' hem de 'A' için bir düşüş yapıyorsanız, anahtar geçişini kullanmayı bileşik if ifadesinden çok daha temiz buluyorum.

Muhtemelen bir stil meselesi ve programcıların nasıl düşündüğü meselesi, ancak genellikle 'güvenlik' adına bir dilin bileşenlerini kaldırmayı pek sevmiyorum - bu yüzden C'ye ve onun türevlerine / soyundan gelenlere, diyelim ki, Java. Hiçbir "nedenim" olmasa bile, işaretçiler ve benzerleriyle etrafta dolaşabilmeyi seviyorum.

Fall-through, yalnızca bir kod bloğuna atlama tablosu olarak kullanıldığında kullanılmalıdır. Kodun herhangi bir kısmı daha fazla vakadan önce koşulsuz bir kesintiye sahipse, tüm vaka grupları bu şekilde bitmelidir.

Başka her şey "kötüdür".