Enum sa Swift — ano ito, syntax at paggamit

Ano ang enum sa Swift?

Enum (enumeration) — ay isang uri ng data na tinukoy ng gumagamit na pinagsasama ang isang may hangganang set ng mga variant na magkakahiwalay. Sa Swift, ang enum ay hindi lamang numeric constants, kundi isang ganap na uri na may sariling lohika.

Ang bawat variant ng enumeration ay tinatawag na case. Hindi tulad ng Objective-C, kung saan ang enum ay nababawasan sa isang uri ng integer, pinapayagan ng Swift ang bawat case na mag-imbak ng sarili nitong data at magkaroon ng mga pamamaraan.

Ayon sa Apple, ang enum sa Swift ay sumusuporta sa generics, initializer, computed properties at pagpapatupad ng mga protocol — ginagawa itong naaangkop para sa pagmomodelo ng mga estado, error, opsyon at finite state machine.

Gamitin ang enum saanman kailangan mong kumatawan sa isang may hangganang set ng mga variant na magkakahiwalay: mga estado ng screen, mga uri ng error, mga direksyon, mga opsyon sa filter.

Syntax ng deklarasyon ng enum

Enum ay idineklara gamit ang keyword na enum na sinusundan ng pangalan at katawan sa mga kulot na braket.

enum CompassDirection {
    case north
    case south
    case east
    case west
}

Ang mga case ay maaaring ideklara sa isang linya gamit ang kuwit:

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

Para ma-access ang isang case, ginagamit ang dot syntax pagkatapos ng kilalang uri:

let direction = CompassDirection.north
// Kilala ang uri — available ang shorthand syntax:
var currentPlanet = .earth

Pagkatapos magtalaga sa isang variable ng kilalang uri ng enum, Swift ay awtomatikong nag-deduce ng uri at maaaring alisin ang pangalan ng enumeration kapag ina-access ang mga case.

Raw Values sa mga enumeration

Raw Values — ay mga halaga ng isang uri na itinalaga sa bawat case ng enum. Hindi tulad ng associated values, ang raw values ay magkapareho sa uri para sa lahat ng case at itinakda sa deklarasyon.

enum HTTPStatusCode: Int {
    case ok = 200
    case notFound = 404
    case internalServerError = 500
}

let code = HTTPStatusCode.notFound
print(code.rawValue) // 404

Para sa integer raw values, awtomatikong tinaasan ng Swift ang mga halaga kung ang una lamang ang tahasang tinukoy:

enum Status: Int {
    case pending = 1
    case active      // 2
    case completed   // 3
}

Ang raw values ay maaaring uri ng Int, String, Character o anumang uri na umaayon sa protocol na RawRepresentable. Awtomatikong bumubuo ang Swift ng initializer na init? para gumawa ng enum mula sa raw value — ito ay kapaki-pakinabang kapag nagpa-parse ng data mula sa API.

Associated Values sa enum

Associated Values ay nagpapahintulot na mag-attach ng iba't ibang uri ng data sa bawat case ng enumeration nang paisa-isa. Hindi tulad ng raw values, ang associated values ay maaaring magkaiba sa uri at dami.

enum NetworkError {
    case timeout(seconds: Int)
    case httpError(code: Int, message: String)
    case noConnection
    case unknown(error: Error)
}

Kapag pinoproseso sa pamamagitan ng switch, ang associated values ay kinukuha sa pamamagitan ng pag-binding sa mga variable o constant:

let error = NetworkError.httpError(code: 403, message: "Forbidden")

switch error {
case .timeout(let seconds):
    print("Timeout pagkatapos ng \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Walang koneksyon")
case .unknown(let err):
    print("Hindi kilala: \(err.localizedDescription)")
}

Ayon sa dokumentasyon ng Apple, ginagawa ng associated values ang enum na isang mapagpahayag na kasangkapan para sa pagmomodelo ng mga kumplikadong estado nang hindi gumagawa ng hiwalay na wrapper type. Gamitin ang mga ito para sa Result-like na mga sitwasyon at pagmomodelo ng error na may konteksto.

Recursive enum (indirect)

Recursive enum — enumeration na ang mga case ay tumutukoy sa mismong uri ng enum. Ang mga naturang case ay minamarkahan ng keyword na indirect.

indirect enum LinkedList<T> {
    case empty
    case node(value: T, next: LinkedList<T>)
}

Ang keyword na indirect bago ang enum ay minamarkahan ang lahat ng case bilang recursive. Bilang alternatibo, maaari lamang markahan ang isang partikular na case ng indirect:

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

Ginagamit ng Swift ang indirect para iimbak ang recursive case bilang mga reference (reference semantics) sa halip na mga halaga — iniiwasan nito ang walang hangganang laki ng enum sa stack. Ang recursive enum ay malawakang ginagamit sa pagbuo ng mga puno, linked list at AST.

Enum at mga protocol

Enum ay maaaring magpatupad ng mga protocol tulad ng mga structure at class. Ito ay isang pangunahing kakayahan ng protocol-oriented programming sa Swift.

protocol Describable {
    var description: String { get }
}

enum PaymentMethod: Describable {
    case creditCard(last4: String)
    case applePay
    case bankTransfer

    var description: String {
        switch self {
        case .creditCard(let last4):
            return "Card ending in \(last4)"
        case .applePay:
            return "Apple Pay"
        case .bankTransfer:
            return "Bank Transfer"
        }
    }
}

Ang enum ay maaari ring magpatupad ng Cocoa protocol — halimbawa, CaseIterable para sa awtomatikong pagbuo ng koleksyon ng lahat ng case o Codable para sa serialization. Ginagawa nito ang enum na isang unibersal na bloke ng gusali sa mga Swift application.