प्रोटोकॉल

Question

के साथ मौजूदा एनम में कोई केस जोड़ना मैं बनाना चाहता हूं जो के अनुरूप सभी enums पर एक निश्चित मामला लागू करता है।

उदाहरण के लिए, अगर मैं एक enum इस तरह है:

case Fuzz(Int) 

यह संभव है:

enum Foo{ 
    case bar(baz: String) 
    case baz(bar: String) 
} 

मैं एक कि एक अन्य मामले कहते हैं के साथ विस्तार करने के लिए करना चाहते हैं?

Answer 1

डिजाइन

काम के आसपास static चर के साथ एक struct उपयोग करने के लिए है।

नोट:

struct Car : RawRepresentable, Equatable, Hashable, Comparable { 

    typealias RawValue = String 

    var rawValue: String 

    static let Red = Car(rawValue: "Red") 
    static let Blue = Car(rawValue: "Blue") 

    //MARK: Hashable 

    var hashValue: Int { 
     return rawValue.hashValue 
    } 

    //MARK: Comparable 

    public static func <(lhs: Car, rhs: Car) -> Bool { 

     return lhs.rawValue < rhs.rawValue 
    } 

} 

प्रोटोकॉल

protocol CoolCar { 

} 

extension CoolCar { 

    static var Yellow : Car { 

     return Car(rawValue: "Yellow") 
    } 
} 

extension Car : CoolCar { 

} 

: यह क्या स्विफ्ट 3 में किया जाता है के लिए Notification.Name

नीचे है पर एक कार्यान्वयन स्विफ्ट 3

Struct है

लागू

let c1 = Car.Red 


switch c1 { 
case Car.Red: 
    print("Car is red") 
case Car.Blue: 
    print("Car is blue") 
case Car.Yellow: 
    print("Car is yellow") 
default: 
    print("Car is some other color") 
} 

if c1 == Car.Red { 
    print("Equal") 
} 

if Car.Red > Car.Blue { 
    print("Red is greater than Blue") 
} 

Answer 2

नहीं, क्योंकि आप enum के बाहर case घोषित नहीं कर सकते हैं।

Answer 3

एक extension एक नेस्टेड enum जोड़ सकते हैं, तो जैसे:

enum Plants { 
    enum Fruit { 
    case banana 
    } 
} 


extension Plants { 
    enum Vegetables { 
    case potato 
    } 
} 

Answer 4

यहां पर कुछ अतिरिक्त कर रहे हैं लेता है कि वहाँ किसी को मदद मिल सकती है:

अपने उदाहरण का उपयोग करना:

enum Foo { 
    case bar(baz: String) 
    case baz(bar: String) 
} 

आप समझ सकते हैं आर के "घोंसला" यह अपनी खुद की enum के case में:

enum FooExtended { 
    case foo(Foo) // <-- Here will live your instances of `Foo` 
    case fuzz(Int) 
} 

इस समाधान के साथ

, यह अधिक "छिपा" मामलों जुड़े प्रकार का उपयोग करने की श्रमसाध्य हो जाता है। लेकिन यह सरलीकरण वास्तव में कुछ अनुप्रयोगों में फायदेमंद हो सकता है।

बस द्वारा एक अन्य विकल्प गुजरता पुन: बनाने और इसे विस्तार करते हुए एक तरह से में Foo कन्वर्ट करने के लिए होने के लिए बढ़ाया enumFooExtended (जैसे एक कस्टम init साथ।):

enum FooExtended { 
    case bar(baz: String) 
    case baz(bar: String) 
    case fuzz(Int) 

    init(withFoo foo: Foo) { 
     switch foo { 
     case .bar(let baz): 
      self = .bar(baz: baz) 
     case .baz(let bar): 
      self = .baz(bar: bar) 
     } 
    } 
} 

कई स्थानों पर हो सकता है, जहां एक, अन्य, या इन दोनों समाधानों का बिल्कुल कोई मतलब नहीं है, लेकिन मुझे पूरा यकीन है कि वे किसी के लिए आसान हो सकते हैं (भले ही केवल व्यायाम के रूप में)।