Swift Language
enums

टिप्पणियों

बुनियादी गणनाएँ

एक एनम संबंधित मूल्यों का एक सेट प्रदान करता है:

enum Direction {
    case up
    case down
    case left
    case right
}

enum Direction { case up, down, left, right }

Enum मानों का उपयोग उनके पूरी तरह से योग्य नाम से किया जा सकता है, लेकिन आप इस प्रकार के नाम को छोड़ सकते हैं जब इसका अनुमान लगाया जा सकता है:

let dir = Direction.up
let dir: Direction = Direction.up
let dir: Direction = .up

// func move(dir: Direction)...
move(Direction.up)
move(.up)

obj.dir = Direction.up
obj.dir = .up

एनम मूल्यों की तुलना / निकालने का सबसे मौलिक तरीका एक switch स्टेटमेंट है:

switch dir {
case .up:
    // handle the up case
case .down:
    // handle the down case
case .left:
    // handle the left case
case .right:
    // handle the right case
}

सरल enums स्वचालित रूप से कर रहे हैं Hashable , Equatable और स्ट्रिंग रूपांतरण हैं:

if dir == .down { ... }

let dirs: Set<Direction> = [.right, .left]

print(Direction.up)  // prints "up"
debugPrint(Direction.up)  // prints "Direction.up"

संलग्न मूल्यों के साथ

Enum मामलों में एक या अधिक पेलोड ( संबंधित मूल्य ) हो सकते हैं:

enum Action {
    case jump
    case kick
    case move(distance: Float)  // The "move" case has an associated distance
}

पेलोड प्रदान किया जाना चाहिए जब एनम मूल्य को तत्काल करते हुए:

performAction(.jump)
performAction(.kick)
performAction(.move(distance: 3.3))
performAction(.move(distance: 0.5))

switch स्टेटमेंट संबंधित मूल्य को निकाल सकता है:

switch action {
case .jump:
    ...
case .kick:
    ...
case .move(let distance):  // or case let .move(distance):
    print("Moving: \(distance)") 
}

if case का उपयोग करके एकल केस निष्कर्षण किया जा सकता है:

if case .move(let distance) = action {
    print("Moving: \(distance)") 
}

guard case सिंटैक्स का उपयोग बाद में निष्कर्षण के लिए किया जा सकता है:

guard case .move(let distance) = action else {
    print("Action is not move")
    return
}

संबद्ध मान वाले Enums डिफ़ॉल्ट रूप से Equatable नहीं हैं। == ऑपरेटर का कार्यान्वयन मैन्युअल रूप से किया जाना चाहिए:

extension Action: Equatable { }

func ==(lhs: Action, rhs: Action) -> Bool {
    switch lhs {
    case .jump: if case .jump = rhs { return true }
    case .kick: if case .kick = rhs { return true }
    case .move(let lhsDistance): if case .move (let rhsDistance) = rhs { return lhsDistance == rhsDistance }
    }
    return false
}

अप्रत्यक्ष पेलोड

आम तौर पर, एनमर्स पुनरावर्ती नहीं हो सकते हैं (क्योंकि उन्हें अनंत भंडारण की आवश्यकता होगी):

enum Tree<T> {
    case leaf(T)
    case branch(Tree<T>, Tree<T>)  // error: recursive enum 'Tree<T>' is not marked 'indirect'
}

indirect कीवर्ड इनलाइन को इनलाइन संचय करने के बजाय अप्रत्यक्ष की परत के साथ अपने पेलोड को स्टोर करता है। आप इस कीवर्ड का उपयोग किसी एक मामले पर कर सकते हैं:

enum Tree<T> {
    case leaf(T)
    indirect case branch(Tree<T>, Tree<T>)
}

let tree = Tree.branch(.leaf(1), .branch(.leaf(2), .leaf(3)))

indirect पूरे एनुम पर भी काम करता है, किसी भी मामले को आवश्यक होने पर अप्रत्यक्ष बनाता है:

indirect enum Tree<T> {
    case leaf(T)
    case branch(Tree<T>, Tree<T>)
}

कच्चा और हैश मान

पेलोडों के बिना किसी भी शाब्दिक प्रकार के कच्चे मान हो सकते हैं:

enum Rotation: Int {
    case up = 0
    case left = 90
    case upsideDown = 180
    case right = 270
}

किसी भी विशिष्ट प्रकार के बिना शंकु कच्चे माल की संपत्ति को उजागर नहीं करते हैं

enum Rotation {
    case up
    case right
    case down
    case left
}

let foo = Rotation.up
foo.rawValue //error

कच्चे कच्चे मानों को 0 से शुरू करने और नीरस रूप से बढ़ाने के लिए माना जाता है:

enum MetasyntacticVariable: Int {
    case foo  // rawValue is automatically 0
    case bar  // rawValue is automatically 1
    case baz = 7
    case quux  // rawValue is automatically 8
}

स्ट्रिंग कच्चे मूल्यों को स्वचालित रूप से संश्लेषित किया जा सकता है:

enum MarsMoon: String {
    case phobos  // rawValue is automatically "phobos"
    case deimos  // rawValue is automatically "deimos"
}

कच्ची-मूल्यवान एनम स्वचालित रूप से रॉरेपर्सेंटेबल के अनुरूप है। आप .rawValue साथ एक .rawValue मान के संगत कच्चे मान प्राप्त कर सकते हैं:

func rotate(rotation: Rotation) {
    let degrees = rotation.rawValue
    ...
}

आप init?(rawValue:) का उपयोग करके कच्चे मान से एक init?(rawValue:) भी बना सकते हैं init?(rawValue:) :

let rotation = Rotation(rawValue: 0)  // returns Rotation.Up
let otherRotation = Rotation(rawValue: 45)  // returns nil (there is no Rotation with rawValue 45)

if let moon = MarsMoon(rawValue: str) {
    print("Mars has a moon named \(str)")
} else {
    print("Mars doesn't have a moon named \(str)")
}

यदि आप एक विशिष्ट एनम के हैश मान प्राप्त करना चाहते हैं, तो आप इसके हैशवैल्यू का उपयोग कर सकते हैं, हैश मान शून्य से शुरू होने वाले एनम के सूचकांक को वापस कर देगा।

let quux = MetasyntacticVariable(rawValue: 8)// rawValue is 8
quux?.hashValue //hashValue is 3

initializers

Enums में कस्टम init विधियाँ हो सकती हैं जो डिफ़ॉल्ट init?(rawValue:) से अधिक उपयोगी हो सकती हैं init?(rawValue:) एनम भी मान स्टोर कर सकते हैं। यह उन मूल्यों को संग्रहीत करने के लिए उपयोगी हो सकता है जहां वे उस मूल्य के साथ आरंभ और पुनः प्राप्त करते हैं।

enum CompassDirection {
    case north(Int)
    case south(Int)
    case east(Int)
    case west(Int)

    init?(degrees: Int) {
        switch degrees {
        case 0...45:
            self = .north(degrees)
        case 46...135:
            self = .east(degrees)
        case 136...225:
            self = .south(degrees)
        case 226...315:
            self = .west(degrees)
        case 316...360:
            self = .north(degrees)
        default:
            return nil
        }
    }
    
    var value: Int = {
        switch self {
            case north(let degrees):
                return degrees
            case south(let degrees):
                return degrees
            case east(let degrees):
                return degrees
            case west(let degrees):
                return degrees
        }    
    }
}

उस इनिशलाइज़र का उपयोग करके हम यह कर सकते हैं:

var direction = CompassDirection(degrees: 0) // Returns CompassDirection.north
direction = CompassDirection(degrees: 90) // Returns CompassDirection.east
print(direction.value) //prints 90
direction = CompassDirection(degrees: 500) // Returns nil

गणनाएं कक्षाओं और संरचनाओं के साथ कई विशेषताएं साझा करती हैं

स्विफ्ट में Enums अन्य भाषाओं में उनके कुछ समकक्षों की तुलना में बहुत अधिक शक्तिशाली हैं, जैसे C। वे कक्षाओं और संरचनाओं के साथ कई विशेषताओं को साझा करते हैं, जैसे कि शुरुआती को परिभाषित करना , गणना किए गए गुण , उदाहरण के तरीके , प्रोटोकॉल अनुरूपता और विस्तार ।

protocol ChangesDirection {
    mutating func changeDirection()
}

enum Direction {
    
    // enumeration cases
    case up, down, left, right
    
    // initialise the enum instance with a case
    // that's in the opposite direction to another
    init(oppositeTo otherDirection: Direction) {
        self = otherDirection.opposite
    }
    
    // computed property that returns the opposite direction
    var opposite: Direction {
        switch self {
        case .up:
            return .down
        case .down:
            return .up
        case .left:
            return .right
        case .right:
            return .left
        }
    }
}

// extension to Direction that adds conformance to the ChangesDirection protocol
extension Direction: ChangesDirection {
    mutating func changeDirection() {
        self = .left
    }
}

var dir = Direction(oppositeTo: .down) // Direction.up

dir.changeDirection() // Direction.left

let opposite = dir.opposite // Direction.right

नेस्टेड एनुमरेशन्स

आप एक के बाद एक एन्यूमरेशन को घोंसला बना सकते हैं, इससे आप पदानुक्रमित एनमों को अधिक व्यवस्थित और स्पष्ट कर सकते हैं।

enum Orchestra {
    enum Strings {
        case violin
        case viola
        case cello
        case doubleBasse
    }
    
    enum Keyboards {
        case piano
        case celesta
        case harp
    }
    
    enum Woodwinds {
        case flute
        case oboe
        case clarinet
        case bassoon
        case contrabassoon
    }
}

और आप इसे इस तरह से उपयोग कर सकते हैं:

let instrment1 = Orchestra.Strings.viola
let instrment2 = Orchestra.Keyboards.piano