Bagaimana cara membandingkan enum dengan nilai terkait dengan mengabaikan nilai terkait di Swift?

Setelah membaca Cara menguji kesetaraan enum Swift dengan nilai terkait , saya menerapkan enum berikut:

enum CardRank {
    case Number(Int)
    case Jack
    case Queen
    case King
    case Ace
}

func ==(a: CardRank, b: CardRank) -> Bool {
    switch (a, b) {
    case (.Number(let a), .Number(let b))   where a == b: return true
    case (.Jack, .Jack): return true
    case (.Queen, .Queen): return true
    case (.King, .King): return true
    case (.Ace, .Ace): return true
    default: return false
    }
}

Kode berikut berfungsi:

let card: CardRank = CardRank.Jack
if card == CardRank.Jack {
    print("You played a jack!")
} else if card == CardRank.Number(2) {
    print("A two cannot be played at this time.")
}

Namun, ini tidak dapat dikompilasi:

let number = CardRank.Number(5)
if number == CardRank.Number {
    print("You must play a face card!")
}

... dan itu memberikan pesan kesalahan berikut:

Operator biner '==' tidak dapat diterapkan ke operan jenis 'CardRank' dan '(Int) -> CardRank'

Saya berasumsi ini karena mengharapkan tipe penuh dan CardRank.Numbertidak menentukan tipe keseluruhan, padahal CardRank.Number(2)itu. Namun, dalam kasus ini, saya ingin mencocokkan nomor apa pun ; bukan hanya yang spesifik.

Jelas saya dapat menggunakan pernyataan sakelar, tetapi inti penerapan ==operator adalah untuk menghindari solusi verbose ini:

switch number {
case .Number:
    print("You must play a face card!")
default:
    break
}

Apakah ada cara untuk membandingkan enum dengan nilai terkait sambil mengabaikan nilai yang terkait?

Catatan: Saya menyadari bahwa saya dapat mengubah kasus dalam ==metode menjadi case (.Number, .Number): return true, tetapi, meskipun itu akan mengembalikan true dengan benar, perbandingan saya masih akan terlihat seperti dibandingkan dengan nomor tertentu ( number == CardRank.Number(2); di mana 2 adalah nilai dummy) daripada angka apa pun ( number == CardRank.Number).

Sunting: Seperti yang Etan tunjukkan, Anda dapat menghilangkan (_)kecocokan wildcard untuk menggunakan ini lebih bersih.

Sayangnya, saya tidak percaya bahwa ada cara yang lebih mudah daripada switchpendekatan Anda di Swift 1.2.

Namun, di Swift 2, Anda dapat menggunakan if-casepencocokan pola baru :

let number = CardRank.Number(5)
if case .Number(_) = number {
    // Is a number
} else {
    // Something else
}

Jika Anda ingin menghindari verbositas, Anda dapat mempertimbangkan untuk menambahkan isNumberproperti yang dihitung ke enum Anda yang mengimplementasikan pernyataan switch Anda.

Sayangnya di Swift 1.x tidak ada cara lain sehingga Anda harus menggunakan switchyang tidak seanggun versi Swift 2 di mana Anda dapat menggunakan if case:

if case .Number = number {
    //ignore the value
}
if case .Number(let x) = number {
    //without ignoring
}

Di Swift 4.2 Equatableakan disintesis jika semua nilai terkait Anda sesuai Equatable. Yang perlu Anda lakukan hanyalah menambahkan Equatable.

enum CardRank: Equatable {
    case Number(Int)
    case Jack
    case Queen
    case King
    case Ace
}

https://developer.apple.com/documentation/swift/equatable?changes=_3

Berikut pendekatan yang lebih sederhana:

enum CardRank {
    case Two
    case Three
    case Four
    case Five
    case Six
    case Seven
    case Eight
    case Nine
    case Ten
    case Jack
    case Queen
    case King
    case Ace

    var isFaceCard: Bool {
        return (self == Jack) || (self == Queen) || (self == King)
    }
}

Tidak perlu membebani operator ==, dan memeriksa jenis kartu tidak memerlukan sintaks yang membingungkan:

let card = CardRank.Jack

if card == CardRank.Jack {
    print("You played a jack")
} else if !card.isFaceCard {
    print("You must play a face card!")
}

Anda tidak membutuhkan func ==atau Equatable. Cukup gunakan pola kasus pencacahan .

let rank = CardRank.Ace
if case .Ace = rank { print("Snoopy") }