Swift Core

Cheat Sheet'lar

Swift Core Cheat Sheet

Swift tilining chuqurroq tushunchalari, xotira boshqaruvi, protokollar va tizimli imkoniyatlari bo'yicha tezkor ma'lumotnoma.

1. Value Types vs Reference Types

// Copy-on-Write (COW): Swift standart collection'lari (Array, Dictionary)
// faqat qiymat o'zgargandagina yangi xotira ajratadi.
var arr1 = [1, 2, 3]
var arr2 = arr1 // Hozircha bir xil xotira manziliga qarab turibdi
arr2.append(4)  // Shu yerda arr2 uchun alohida nusxa olinadi (COW)

2. Memory Management: ARC & Retain Cycles

Avtomatik hisoblagich (Automatic Reference Counting - ARC) faqat Reference typelar (class) uchun ishlaydi.

class Owner {
    var name: String
    var car: Car?
    init(name: String) { self.name = name }
    deinit { print("\(name) xotiradan o'chirildi") }
}

class Car {
    var model: String
    // Retain cycle'ning oldini olish uchun weak ishlatiladi
    weak var owner: Owner?
    init(model: String) { self.model = model }
    deinit { print("\(model) xotiradan o'chirildi") }
}

Reference turlari:

• **strong**: Standart havola. Retain count +1.
• **weak**: Doim var va Optional?. Retain count oshirmaydi. Ob'yekt o'chganda avtomatik nil bo'ladi.
• **unowned**: Retain count oshirmaydi, lekin Optional emas. Ob'yekt o'chib ketganidan so'ng murojaat qilinsa, crash (EXC_BAD_ACCESS) beradi.

Closure'larda Capture List:

class NetworkService {
    var data = "Boshlang'ich"

    func fetchData() {
        // [weak self] retain cycle'ni oldini oladi
        ApiClient.shared.get { [weak self] result in
            guard let self else { return }
            self.data = result
        }
    }
}

3. Protocols, Generics va some vs any

Protocol va Opaque Types:

protocol IdentifiableEntity {
    associatedtype ID: Hashable
    var id: ID { get }
}

// 'some' (Opaque Type): Kompilyatsiya vaqtida aniq bitta tur qaytariladi
func createView() -> some View {
    Text("Salom")
}

// 'any' (Existential Type): Har qanday mos tur qabul qilinadi (quti/box ichida saqlanadi)
func process(items: [any IdentifiableEntity]) {
    // Dynamic dispatch ishlatiladi
}

Protocol Composition:

typealias CodableEntity = Codable & Identifiable & Equatable

4. Property Wrappers

O'zgaruvchilarga get/set mantiqini inkapsulyatsiya qilib qayta ishlatish mexanizmi.

@propertyWrapper
struct Trimmed {
    private var text: String = ""
    
    var wrappedValue: String {
        get { text }
        set { text = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
    }
    
    // Projected value ($ belgisi orqali olinadi)
    var projectedValue: Bool {
        return !text.isEmpty
    }
    
    init(wrappedValue: String) {
        self.wrappedValue = wrappedValue
    }
}

// Ishlatilishi:
struct UserProfile {
    @Trimmed var username: String
}

var profile = UserProfile(username: "   azimjon   ")
print(profile.username)   // "azimjon" (bo'shliqlar olib tashlangan)
print(profile.$username)  // true (projected value)

5. Standart Protokollar (Standard Protocols)

struct Product: Identifiable, Equatable, Hashable, Comparable {
    let id: UUID
    let name: String
    let price: Double

    // Equatable (==)
    static func == (lhs: Product, rhs: Product) -> Bool {
        lhs.id == rhs.id
    }

    // Comparable (<)
    static func < (lhs: Product, rhs: Product) -> Bool {
        lhs.price < rhs.price
    }

    // Hashable (Set yoki Dictionary kaliti bo'lishi uchun)
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}

6. Result Type va Xatoliklar

enum DataError: Error, LocalizedError {
    case notFound
    case unauthorized
    
    var errorDescription: String? {
        switch self {
        case .notFound: return "Ma'lumot topilmadi"
        case .unauthorized: return "Ruxsat yo'q"
        }
    }
}

// Result<Success, Failure>
func fetchScore(userId: String) -> Result<Int, DataError> {
    guard !userId.isEmpty else { return .failure(.notFound) }
    return .success(100)
}

// Ishlatilishi:
let result = fetchScore(userId: "123")
switch result {
case .success(let score):
    print("Ball:", score)
case .failure(let error):
    print("Xato:", error.localizedDescription)
}

7. defer Kalit So'zi

Funksiya qanday tugashidan qat'i nazar (return yoki throw), eng oxirida bajariladi.

func processFile() {
    let file = openFile()
    defer {
        // Har doim funksiya scope'dan chiqayotganda ishlaydi
        closeFile(file)
    }
    
    // Asosiy ishlov berish...
    if errorOccurred { return }
}

8. Pattern Matching & Control Flow

// if case / guard case
let score: Int? = 85
if case .some(let value) = score, value > 80 {
    print("A'lo: \(value)")
}

// ~= Operator (Range ichida tekshirish)
let age = 22
switch age {
case 0..<18: print("Voyaga yetmagan")
case 18...60: print("Kattalar")
default: print("Nafaqaxo'r")
}

// KeyPath
let names = products.map(\.name)
let sorted = products.sorted(by: { $0.price < $1.price })

9. Access Control (Ruxsat darajalari)

1. open: Boshqa modullardan ko'rinadi va subclass/override qilinishi mumkin (faqat class'lar).
2. public: Boshqa modullardan ko'rinadi, lekin faqat shu modul ichida subclass/override qilinadi.
3. package: Bitta Swift Package ichidagi barcha modullarda ko'rinadi (Swift 5.9+).
4. internal: Bitta modul (target) ichida to'liq ko'rinadi (default daraja).
5. fileprivate: Faqat o'sha yozilgan .swift fayl ichidagina ko'rinadi.
6. private: Faqat belgilangan struct/class va uning shu fayldagi extension'larida ko'rinadi.