स्विफ्ट में संबंधित मानों के साथ enums के फ़िल्टर सरणी को फ़िल्टर करने के लिए एक predicate कैसे बनाएँ?

Question

enum EnumType { 
    case WithString(String) 
} 

var enums = [EnumType]() 

enums.append(EnumType.WithString("A")) 
enums.append(EnumType.WithString("B")) 
enums.append(EnumType.WithString("C")) 
enums.append(EnumType.WithString("D")) 
enums.append(EnumType.WithString("E")) 
enums.append(EnumType.WithString("F")) 

संबंधित 0 बराबर C के साथ एक को खोजने के लिए मेरे enums सरणी को फ़िल्टर करने के लिए कैसे करें। भविष्यवाणी क्या मुझे उपयोग करने की आवश्यकता है?

Answer 1

फ़िल्टर फ़ंक्शन को या तो सरणी पर वैश्विक फ़ंक्शन के रूप में या एक उदाहरण विधि के रूप में शामिल किया जा सकता है (मैं बाद में इसे अधिक ओओ पसंद करता हूं)।

यह एक पैरामीटर (तत्व का मूल्यांकन किया जा रहा है) के साथ एक बंद करने को स्वीकार करता है जो एक बूलियन लौटाता है (यह दर्शाता है कि तत्व आवश्यक स्थिति से मेल खाता है या नहीं)।

चूंकि यह स्पष्ट स्थिति में एक साधारण बंद है, संक्षिप्त रूप का उपयोग करना ठीक है।

मुझे लगता है कि अन्य मामलों में, अपने enum में जोड़ा जाएगा, ताकि आप की तरह कुछ के साथ जा सकते हैं "के साथ":

let filteredArray = enums.filter { 
    switch $0 { 
     case let .WithString(value): 
     return value == "C" 
     default: 
     return false 
    } 
} 

कि अपने उदाहरण में चाल करना चाहिए।

Answer 2

var filteredArray = enums.filter { element in 
    switch element { 
    case EnumType.WithString(let string): 
     return string == "A" 
    default: 
     return false 
    } 
} 

यह शायद स्विफ्ट 2.0 if बयान में assosciated मूल्यों के बंधन के साथ सरल किया जा सकता।

Answer 3

किसी के रूप में पहले ही उल्लेख किया> स्विफ्ट के लिए, 2.0 वहाँ अगर मामले स्टेटमेंट उपलब्ध:

enums.filter { 
    if case .WithString("C") = $0 { 
    return true 
    } 
    return false 
} 

लेकिन, यह अच्छा नहीं लग रहा है, खासकर यदि आप एक ही तर्क फिर से दोहराने के लिए जा रहे हैं। क्या हम यहाँ कर सकते हैं EnumType Equatable के अनुरूप बनाने के लिए है:

extension EnumType: Equatable { 
} 

func ==(lhs: EnumType, rhs: EnumType) -> Bool { 
    switch (lhs, rhs) { 
    case (.WithString(let lStr), .WithString(let rStr)): 
     return lStr == rStr 
    } 
} 

और अब तुम सिर्फ कर सकते हैं:

enums.filter { $0 == .WithString("C") } 

Answer 4

आप अपने enum करने के लिए एक गणना संपत्ति के साथ एक सरल विस्तार जोड़ने की कोशिश कर सकता है और है कि संपत्ति के लिए फ़िल्टर:

extension EnumType { 
    var isC: Bool { 
    switch self { 
    case .WithString(let message): return message == "C" 
    default: return false 
    } 
    } 
} 

इस के बाद, आप simpy हमेशा की तरह छानने इस्तेमाल कर सकते हैं:

enums.filter { $0.isC }