स्विफ्ट एनम्स में कई कच्चे मूल्य हो सकते हैं?

Question

मैं एक enum उदाहरण के लिए दो कच्चे मूल्यों संबद्ध करना चाहते हैं (एक enum त्रुटि प्रकारों का प्रतिनिधित्व करने की कल्पना, मैं Error.Teapot चाहते मूल्य 418 है, और एक स्ट्रिंग संपत्ति I'm a teapot करने के लिए सेट के साथ एक इंट प्रकार संपत्ति code है।)

नोट raw values और associated values के बीच का अंतर- मैं सभी Teapot उदाहरणों को 418 में code रखने के लिए चाहता हूं, मैं प्रत्येक Teapot उदाहरण के लिए एक अद्वितीय संबद्ध मूल्य नहीं चाहता हूं।

क्या switch पर self पर उचित मूल्य देखने के लिए गणना की गई गुणों को जोड़ने से बेहतर तरीका है?

Answer 1

नहीं, एक enum कई कच्चे मान हो सकते हैं नहीं है - यह एक एकल मूल्य होने की Equatable प्रोटोकॉल को लागू करने की है, और documentation में वर्णित के रूप शाब्दिक-परिवर्तनीय हो।

मुझे लगता है कि आपके मामले में सबसे अच्छा तरीका त्रुटि कोड को कच्चे मान के रूप में उपयोग करना है, और प्रीपॉप्लेटेड स्थिर शब्दकोश द्वारा समर्थित संपत्ति को कुंजी कोड के साथ कुंजी और टेक्स्ट के रूप में समर्थित किया गया है।

Answer 2

नहीं, आपके पास एक enum से जुड़े कई कच्चे मूल्य नहीं हो सकते हैं।

आपके मामले में, आपके पास कच्चे मूल्य को कोड के बराबर होना चाहिए, और विवरण के साथ एक संबद्ध मूल्य हो सकता है। लेकिन मुझे लगता है कि गणना गुणों का दृष्टिकोण यहां सबसे अच्छा विकल्प है।

Answer 3

यदि आप अपने एरर के लिए कई स्थिर गुण रखना चाहते हैं तो एक वर्कअराउंड एक संपत्ति सूची आयात करना हो सकता है; आप मूल ऑब्जेक्ट को प्रत्येक ऑब्जेक्ट के लिए कुंजी के रूप में अपने enum कच्चे मान के साथ एक शब्दकोश में सेट कर सकते हैं, जिससे आप ऑब्जेक्ट के लिए स्थिर संरचित डेटा को आसानी से पुनर्प्राप्त कर सकते हैं।

यह आयात और एक plist उपयोग का एक उदाहरण है: http://www.spritekitlessons.com/parsing-a-property-list-using-swift/

कि बस एक त्रुटि विवरण के लिए overkill हो सकता है, जिसके लिए आप सिर्फ अपने enum मूल्यों के लिए एक स्विच बयान के साथ एक हार्डकोडेड स्थिर समारोह इस्तेमाल कर सकते हैं, कि आपको आवश्यक त्रुटि स्ट्रिंग देता है। बस स्थिर कार्य को उसी enswift फ़ाइल में अपने enum के रूप में रखें।

उदाहरण के लिए,

static func codeForError(error : YourErrorType) -> Int { 
    switch(error) { 
     case .Teapot: 
      return "I'm a Teapot" 
     case .Teacup: 
      return "I'm a Teacup" 
     ... 
     default: 
      return "Unknown Teaware Error" 
    } 
} 

यह बेहतर मिलनसार स्थानीयकरण के लाभ (.plist समाधान की तुलना में) है। हालांकि, इस उद्देश्य के लिए, एक .plist में एक त्रुटि स्ट्रिंग के बजाय उचित स्थानीयकरण को पुनर्प्राप्त करने के लिए उपयोग की जाने वाली कुंजी शामिल हो सकती है।

Answer 4

मैंने इसे अनुकरण करने का एक तरीका बनाया (मार्कोस क्रिस्पिनो ने उसके उत्तर पर क्या सुझाव दिया उससे अलग नहीं)। एक आदर्श समाधान से बहुत दूर है, लेकिन हम उन अलग-अलग संपत्तियों के लिए उन गंदे स्विच मामलों से बचने की अनुमति देते हैं जिन्हें हम प्राप्त करना चाहते हैं।

चाल "गुण/डेटा" धारक के रूप में संरचना का उपयोग करना और इसे enum में RawValue के रूप में उपयोग करना है।

इसमें कुछ डुप्लिकेशंस है लेकिन यह अब तक मेरी सेवा कर रहा है। हर बार जब आप एक नया एनम केस जोड़ना चाहते हैं, तो संकलक आपको कच्चे वैल्यू गेटटर में अतिरिक्त केस भरने के लिए याद दिलाएगा, जो आपको init? को अपडेट करने के लिए याद दिलाएगा जो आपको संरचना पर नई स्थैतिक संपत्ति बनाने के लिए याद दिलाएगा।

Gist

सार करने के लिए कोड:

enum VehicleType : RawRepresentable { 

    struct Vehicle : Equatable { 
     let name: String 
     let wheels: Int 

     static func ==(l: Vehicle, r: Vehicle) -> Bool { 
      return l.name == r.name && l.wheels == r.wheels 
     } 

     static var bike: Vehicle { 
      return Vehicle(name: "Bicycle", wheels: 2) 
     } 

     static var car: Vehicle { 
      return Vehicle(name: "Automobile", wheels: 4) 
     } 

     static var bus: Vehicle { 
      return Vehicle(name: "Autobus", wheels: 8) 
     } 
    } 

    typealias RawValue = Vehicle 

    case car 
    case bus 
    case bike 

    var rawValue: RawValue { 
     switch self { 
     case .car: 
      return Vehicle.car 
     case .bike: 
      return Vehicle.bike 
     case .bus: 
      return Vehicle.bus 
     } 
    } 

    init?(rawValue: RawValue) { 
     switch rawValue { 
     case Vehicle.bike: 
      self = .bike 
     case Vehicle.car: 
      self = .car 
     case Vehicle.bus: 
      self = .bus 
     default: return nil 
     } 
    } 
} 

VehicleType.bike.rawValue.name 
VehicleType.bike.rawValue.wheels 
VehicleType.car.rawValue.wheels 

VehicleType(rawValue: .bike)?.rawValue.name => "Bicycle" 
VehicleType(rawValue: .bike)?.rawValue.wheels => 2 
VehicleType(rawValue: .car)?.rawValue.name => "Automobile" 
VehicleType(rawValue: .car)?.rawValue.wheels => 4 
VehicleType(rawValue: .bus)?.rawValue.name => "Autobus" 
VehicleType(rawValue: .bus)?.rawValue.wheels => 8