Enum bir desenle eşleşmiyorsa nasıl kontrol edilir?

Question

Bu post numaralı kitabı okudum ama bu yazının bir anahtar deyimi kullandığını ve desen eşleştiğinde bir şey yapması gerektiğini (true değerini döndürmesi) gerektiğini unutmayın. Öte yandan, eğer desen eşleşirse ve bir if-case ifadesi kullanırsa ben hiçbir şey yapmak istemiyorum.

enum MyEnum { 
    case a 
    case b(Int) 
    case c 
    case d 
} 

İşte bunun bir örneği var: myEnum.b değilse

let myEnum: MyEnum = .a 

Şimdi bir şey yapmak istiyorum

Bu enum var.

if case .b(_) = myEnum { 

} else { 
    // do my thing here 
} 

Ama gerçekten nefret:

if myEnum != .b { // compiler error 
    // do my thing here 
} 

yüzden desen maçı bunun için eğer durum deyimini kullanmanız gerekir: .b ilişkili bir değere sahip olduğu için, ben sadece bir if deyimi çeki kullanamazsınız boş if maddenin kullanılması. Bu sadece bana yanlı gözüküyor. Bunu yapmayi denedim:

if case .b(_) != myEnum { // compiler error! 
    // do my thing here 
} 

Bunu, boş bir deyim kullanmaktan başka yapmak için daha iyi bir yolu var mı?

Modelin eşleşip eşleşmediğine bakılmaksızın çalışması gereken bir kodum hala var, bu nedenle guard ifadesi çalışmayacak.

Answer 1

Bu tamamen kendi kod minimal semantik değişim olmakla birlikte, sadece case desen eşleştirme ile boş if fıkra inline "atmak" unutmayın: gereksiz desen denk dışarıda bırakarak,

if case .b(_) = myEnum {} else { 
    // do your thing here 
} 

veya durumda b ilişkili değeri:

if case .b = myEnum {} else { 
    // do your thing here 
} 

Bu biraz guard maddesi gibi ama kapsamını çıkmadan görünüyor.

Answer 2

Sen kullanabileceği bir guard:

guard case .b = myEnum else { 
    // do your stuff here 
    return 
} 

olumsuz kapsamını çıkmak zorunda olmasıdır

...

Answer 3

Bir bilgisayarlı özelliği yazabilir ve duruma bağlı bir bool değeri döndürmek var kodunuzdaki sonra

enum MyEnum { 
    case a 
    case b(Int) 
    case c 

var isCaseB: Bool { 
    switch self { 
     case .b(_): 
     return true 
     default: 
     return false 
     } 
    } 
} 

temiz bir şekilde kontrol edin:

if !enumVal.isCaseB { 

} 

Sorunuzda bahsettiğiniz cevabı kontrol ettim ama hiç bir anahtar deyimi kullanmak istemediyseniz veya diğer kodunuzla karıştırmak istemediğinizden emin değildim . Bence bu, davaya bağlı olarak yapmanız gereken her türlü uygulamayı yazmadan önce kontrol etmenin güzel ve temiz bir yoludur.

Answer 4

Ne hakkında:

enum MyEnum { 

    case a 
    case b(Int) 
    case c 
    case d 

    var notB: Bool { 
     switch self { 
     case .b(_): 
      return false 
     default: 
      return true 
     } 
    } 
} 

MyEnum.a.notB // true 
MyEnum.b(1).notB // false 
MyEnum.c // true 
MyEnum.d // true 

Değil yapmak kod bir sürü hala var beri en büyük cevap: değeriniz .b(_) değilse

switch myEnum { 
case .b(_): 
    break 
default: 
    // do your thing here 
} 

Answer 5

hesaplar enum üzerinde bir var oluştur Çek, ama en azından kontrol aslında kullandığınızda sadece bir satırdır.