नहीं 'यदि यह मामला' बयान

Question

में हालत मैं एक enum है:

enum E { 
    case A, B, C(Int) 
} 

let a: E = .A 

यहाँ अगर a के बराबर होती है .B

if case .B = a { 
    // works fine 
} 

लेकिन यह कैसे मैं विपरीत स्थिति की जांच कि मैं कैसे की जाँच करेगा है? (a बराबर .B)? यहाँ मैं क्या करने की कोशिश की है:

if case .B != a { // Variable binding in a condition requires an initializer 
    // ... 
} 

if !(case .B = a) { // Expected ',' separator 
    // ... 
} 

बेशक

, मैं इसे इस तरह से कर सकता है:

if case .B = a { 
    // ... 
} else { 
    // put your code here 
} 

लेकिन यह अजीब है, साथ ही switch कथन का उपयोग है। क्या कोई बेहतर विकल्प हैं?

---

संपादित करें: समाधान @Greg काम करता है का सुझाव दिया है, तो मामलों मूल्यों संबद्ध कर दिया है नहीं है, लेकिन == ऑपरेटर अतिभारित होने की जरूरत है अगर वे करते हैं। इसे पहली जगह में स्पष्ट करने के लिए खेद है।

Answer 1

आप एकल = चिह्न का उपयोग कर रहे हैं जो एक असाइनमेंट ऑपरेटर है। आप जो एक तुलना एक है डबल == उपयोग करने के लिए है और मामले का उपयोग नहीं करते ए, का उपयोग ईए कि करने के लिए सही तरीका है:

if E.A == a { 
    // works fine 
    print("1111") 
} 

if E.B != a { 
    // works fine 
    print("2222") 
} 

if E.B == a { 
    // works fine 
    print("3333") 
} 

विस्तारित:

यह संबद्ध के साथ काम करता बनाने के महत्व देता है आप Equatable प्रोटोकॉल को लागू करने के लिए है, उदाहरण के लिए:

extension E: Equatable {} 
func ==(lhs: E, rhs: E) -> Bool { 
    switch (lhs, rhs) { 
     case (let .C(x1), let .C(x2)): 
      return x1 == x2 
     case (.A, .A): 
     return true 

    default: 
     return false 
    } 
} 

बेशक आप संभावनाओं के सभी संभाल करने के लिए है के

लेकिन मुझे लगता है कि आप एक विचार है।

विस्तारित:

मैं अपनी टिप्पणी नहीं मिलता है, लेकिन यह मेरे लिए ठीक काम करता है:

enum E { 
    case A, B, C(Int) 
} 

extension E: Equatable {} 
func ==(lhs: E, rhs: E) -> Bool { 
    switch (lhs, rhs) { 
     case (let .C(x1), let .C(x2)): 
      return x1 == x2 
     case (.A, .A): 
      return true 
     case (.B, .B): 
      return true 

    default: 
     return false 
    } 
} 

let a: E = .A 
let b: E = .B 
let c: E = .C(11) 

if E.A == a { 
    // works fine 
    print("aaa true") 
} 
if E.A != a { 
    // works fine 
    print("aaa false") 
} 

if E.B == b { 
    // works fine 
    print("bbb true") 
} 

if E.B == b { 
    // works fine 
    print("bbb false") 
} 

if E.C(11) == c { 
    // works fine 
    print("ccc true") 
} 

if E.C(11) != c { 
    // works fine 
    print("1 ccc false") 
} 

if E.C(22) != c { 
    // works fine 
    print("2 ccc false") 
} 

Answer 2

यह "जवाब" एक अधिक कॉम्पैक्ट तरीके से अपने अजीब समाधान लिखने की तुलना में ज्यादा कुछ नहीं है । आप केवल मामले के बारे में परवाह है, जब एक मूल्य एक निश्चित enum मूल्य का नहीं है, आप इसे तुरंत खाली तो खंड निम्नलिखित else के साथ इस सब में एक पंक्ति लिख सकते हैं:

enum E { 
    case A, B(String), C(Int) 
} 

let a: E = .B("Hello") 

if case .A = a {} else { 
    print("not an A") 
} 

if case .B = a {} else { 
    print("not a B") 
} 

if case .C = a {} else { 
    print("not a C") 
} 

Answer 3

वहाँ नहीं किसी भी कर रहे हैं उत्तर अभी तक guard कथन का उल्लेख करते हैं, जो स्विफ्ट 2 द्वारा पेश किया गया है, जो ऊपर दिए गए टूल्स के लिए एक साफ जोड़ है और यदि आप मुझसे पूछते हैं, तो सबसे साफ समाधान अगर आप को else -block में अपने फ़ंक्शन या बंद से आवश्यकता के साथ जी सकते हैं :

guard case .B = a else { 
    // a does not match .B 
    return 
} 

मोर के लिए Apple's "The Swift Programming Language (Swift 2.2): Statements" देखें ई जानकारी।

Answer 4

.case कथन को नकारात्मक करना संभव नहीं है।हालांकि आप सामान्य तुलना का उपयोग कर सकते हैं, जैसे:

if a != .B { 

} 

यह मेरी राय में लिखने का सबसे सीधा तरीका है।