कैसे जांचें कि enum पैटर्न से मेल नहीं खाता है?

Question

ध्यान दें कि मैंने यह post पढ़ा है लेकिन वह पोस्ट एक स्विच स्टेटमेंट का उपयोग करती है और पैटर्न मिलान होने पर इसे कुछ करना (सत्य वापस करना) माना जाता है। दूसरी तरफ, यदि पैटर्न मिलान करता है और if-case कथन का उपयोग करता है, तो मैं कुछ भी नहीं करना चाहता हूं।

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

यहाँ यह का एक उदाहरण है::

let myEnum: MyEnum = .a 

अब मैं कुछ करने के लिए करता है, तो myEnum.b नहीं है चाहता हूँ

मैं इस enum है। चूंकि .b एक संबद्ध महत्व है, मैं बस एक अगर बयान की जांच का उपयोग नहीं कर सकते हैं:

if case .b(_) = myEnum { 

} else { 
    // do my thing here 
} 

लेकिन मैं सच में नफरत:

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

तो मैं पैटर्न मैच इसे करने के लिए एक है, तो दर-मामला बयान का उपयोग करना चाहिए खंड अगर खाली का उपयोग करें। यह सिर्फ मेरे लिए बेकार दिखता है। मैंने यह करने की कोशिश की:

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

क्या खंड के खाली होने के अलावा इसे करने का कोई बेहतर तरीका है?

मेरे पास अभी भी कोड है जो पैटर्न के मिलान के बावजूद चलाना चाहिए, इसलिए guard कथन काम नहीं करेगा।

Answer 1

यह विशुद्ध रूप से अपने खुद के कोड के न्यूनतम अर्थ परिवर्तन है, लेकिन ध्यान दें कि आप बस "त्यागने" कर सकते हैं case पैटर्न मिलान के साथ खाली if खंड इनलाइन:

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

या, बाहर अनावश्यक पैटर्न मिलान छोड़ने मामले b के जुड़े मूल्य के लिए:

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

यह लग रहा है कुछ हद तक एक guard खंड की तरह, लेकिन गुंजाइश से बाहर निकले बिना।

Answer 2

आप इस्तेमाल कर सकते हैं एक guard:

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

नकारात्मक पक्ष यह है कि आप दायरे से बाहर निकलने के लिए है कि है ...

Answer 3

आप एक गणना संपत्ति लिख सकते हैं और यह मामला के आधार पर एक bool मान है

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

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

तो अपने कोड में

सफाई से जाँच:

if !enumVal.isCaseB { 

} 

मैंने आपके प्रश्न में उल्लिखित उत्तर की जांच की लेकिन मुझे यकीन नहीं था कि क्या आप का मतलब है कि आप स्विच कथन का उपयोग नहीं करना चाहते थे या बस आप इसे अपने अन्य कोड से मिश्रण नहीं करना चाहते थे । मुझे लगता है कि मामले के आधार पर आपको जो भी कार्यान्वयन करना है, उसे लिखने से पहले यह जांचने का एक अच्छा और साफ तरीका है।

Answer 4

के बारे में क्या:

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

Answer 5

enum जो गणना करता है पर एक वर बनाएं यदि आपके मूल्य .b(_) नहीं है:

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 

नहीं सबसे बड़ी जवाब वहाँ अभी भी कोड का एक बहुत कुछ करने के लिए है, क्योंकि चेक, लेकिन कम से कम चेक केवल एक पंक्ति है जब आप वास्तव में इसका उपयोग करते हैं।