Swift-da Enum — bu nima, sintaksis va foydalanish

Swift-da enum nima?

Enum (enumeratsiya) — bu cheklangan o'zaro istisno variantlar to'plamini birlashtiruvchi foydalanuvchi ma'lumotlar turi. Swift-da enum oddiy sonli konstantalar emas, balki o'z mantiqiga ega to'liq huquqli turdir.

Enumeratsiyaning har bir varianti case deb ataladi. Objective-C dan farqli o'laroq, enum butun son turiga tushiriladi, Swift har bir case'ga o'z ma'lumotlarini saqlash va metodlarga ega bo'lish imkonini beradi.

Apple ma'lumotlariga ko'ra, Swift-da enum generics, init metodlari, hisoblangan xususiyatlar va protokol implementatsiyalarini qo'llab-quvvatlaydi — bu uni holatlar, xatolar, variantlar va chekli avtomatlarni modellashtirish uchun foydali qiladi.

Enum-ni cheklangan to'plamni ifodalash kerak bo'lgan hamma joyda ishlating: ekran holatlari, xato turlari, yo'nalishlar, filtrlash variantlari.

Enum e'lon qilish sintaksisi

Enum enum kalit so'zi bilan keyingi nom va jingalak qavslardagi tana bilan e'lon qilinadi.

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

Case'lar vergul orqali bir qatorda e'lon qilinishi mumkin:

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

Case'ga murojaat qilish uchun ma'lum turdan keyin nuqta sintaksisi ishlatiladi:

let direction = CompassDirection.north
// Tur ma'lum — qisqa sintaksis mavjud:
var currentPlanet = .earth

Ma'lum enum turidagi o'zgaruvchiga tayinlagandan so'ng, Swift avtomatik ravishda turni aniqlaydi va case'larga murojaat qilishda enumeratsiya nomini tushirib qoldirish mumkin.

Enumeratsiyalarda Raw Values

Raw Values — bu enum-ning har bir case'iga tayinlanadigan bir xil turdagi qiymatlardir. Associated values dan farqli o'laroq, raw values barcha case'lar uchun turi bo'yicha bir xil va e'lon vaqtida o'rnatiladi.

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

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

Butun sonli raw values uchun Swift qiymatlarni avtomatik ravishda oshiradi, agar faqat birinchisi aniq berilgan bo'lsa:

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

Raw values Int, String, Character yoki RawRepresentable protokoliga mos keladigan har qanday turda bo'lishi mumkin. Swift raw value dan enum yaratish uchun avtomatik ravishda init? initsializatorini yaratadi — bu API dan ma'lumotlarni pars qilishda qulay.

Enum-da Associated Values

Associated Values enumeratsiyaning har bir case'iga alohida turli xil ma'lumotlar turlarini bog'lash imkonini beradi. Raw values dan farqli o'laroq, associated values tur va miqdor jihatidan farq qilishi mumkin.

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

Switch orqali qayta ishlashda associated values o'zgaruvchilar yoki konstantalarga bog'lash orqali chiqariladi:

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

switch error {
case .timeout(let seconds):
    print("\(seconds)s dan keyin vaqt tugashi")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Ulanish yo'q")
case .unknown(let err):
    print("Noma'lum: \(err.localizedDescription)")
}

Apple hujjatlariga ko'ra, associated values enum-ni alohida o'rash turlarini yaratmasdan murakkab holatlarni modellashtirish uchun ifodali vositaga aylantiradi. Ularni Result-o'xshash stsenariylar va kontekst bilan xatolarni modellashtirish uchun foydalaning.

Rekursiv enum (indirect)

Rekursiv enum — case'lari enum turining o'ziga murojaat qiladigan enumeratsiya. Bunday case'lar indirect kalit so'zi bilan belgilanadi.

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

indirect kalit so'zi enum oldida barcha case'larni rekursiv deb belgilaydi. Shu bilan birga, faqat ma'lum bir case'ni indirect bilan belgilash mumkin:

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

Swift indirect dan rekursiv case'larni qiymatlar o'rniga havolalar (reference semantics) sifatida saqlash uchun foydalanadi — bu stekda enum-ning cheksiz hajmidan qochadi. Rekursiv enum daraxtlar, bog'langan ro'yxatlar va AST qurishda keng qo'llaniladi.

Enum va protokollar

Enum strukturalar va sinflar kabi protokollarni implementatsiya qilishi mumkin. Bu Swift-da protokol-yo'naltirilgan dasturlashning asosiy imkoniyatidir.

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"
        }
    }
}

Enum shuningdek Cocoa protokollarini implementatsiya qilishi mumkin — masalan, barcha case'larning to'plamini avtomatik yaratish uchun CaseIterable yoki serializatsiya uchun Codable. Bu enum-ni Swift ilovalarida universal qurilish blokiga aylantiradi.