Swift-da Sort, Filter va Map — massiv ma'lumotlarini boshqarish

Ma'lumotlarni ilovaga yuklagandan keyin, ularni to'g'ridan-to'g'ri ekranda ko'rsatmasdan avval — tartiblash, filtrlash yoki boshqa turga o'zgartirish juda keng tarqalgan amaliyot. Bu videoda uchta asosiy usul ko'rib chiqiladi: sorted, filter va map.

Model va ViewModel

struct UserModel: Identifiable {
    let id: String = UUID().uuidString
    let name: String
    let points: Int
    let isVerified: Bool
}

class ArrayModificationViewModel: ObservableObject {

    @Published var dataArray: [UserModel] = []
    @Published var filteredArray: [UserModel] = []
    @Published var mappedArray: [String] = []

    init() {
        getUsers()
        updateFilteredArray()
    }

    func getUsers() {
        let users: [UserModel] = [
            UserModel(name: "Nick",    points: 5,   isVerified: true),
            UserModel(name: "Chris",   points: 0,   isVerified: false),
            UserModel(name: "Joe",     points: 20,  isVerified: true),
            UserModel(name: "Emily",   points: 50,  isVerified: false),
            UserModel(name: "Amanda",  points: 100, isVerified: true),
            UserModel(name: "Lisa",    points: 35,  isVerified: false),
            UserModel(name: "Tom",     points: 75,  isVerified: true),
            UserModel(name: "Sara",    points: 10,  isVerified: false),
            UserModel(name: "Mark",    points: 60,  isVerified: true),
            UserModel(name: "Jessica", points: 45,  isVerified: true),
        ]
        self.dataArray.append(contentsOf: users)
    }

    func updateFilteredArray() {
        // ...
    }
}

1. sorted() — tartiblash

// To'liq yozuv — boshlovchilar uchun tushunarli
filteredArray = dataArray.sorted { user1, user2 in
    return user1.points > user2.points
    // user1 user2 dan ko'p ball bo'lsa — user1 oldinga chiqadi
    // Natija: 100 → 75 → 60 → 50 ... (yuqoridan pastga)
}

// Qisqartma yozuv — tajribali dasturchilar ko'proq shu usulni ishlatadi
filteredArray = dataArray.sorted { $0.points > $1.points }
// $0 — birinchi element, $1 — ikkinchi element
// Natija xuddi shu: eng ko'p balldan eng kamagacha

// Teskari tartib — eng kamdan eng ko'pga
filteredArray = dataArray.sorted { $0.points < $1.points }

2. filter() — filtrlash

// Faqat tasdiqlangan foydalanuvchilar
filteredArray = dataArray.filter { user in
    return user.isVerified
}

// Qisqartma yozuv
filteredArray = dataArray.filter { $0.isVerified }

// Tasdiqlangan emaslari
filteredArray = dataArray.filter { !$0.isVerified }

// 50 dan ko'p ball bo'lganlar
filteredArray = dataArray.filter { $0.points > 50 }

// 50 dan kam ball bo'lganlar
filteredArray = dataArray.filter { $0.points < 50 }

// Ismida "i" harfi bo'lganlar (kichik-katta harfga sezgir)
filteredArray = dataArray.filter { $0.name.contains("i") }
// Nick, Chris, Emily, Lisa — mos keladi

3. map() — turni o'zgartirish

map() — massivdagi har bir elementni boshqa turga aylantiradi. Masalan, [UserModel] massivini [String] massiviga o'zgartirish:

// To'liq yozuv
mappedArray = dataArray.map { user in
    return user.name
}

// Qisqartma yozuv
mappedArray = dataArray.map { $0.name }

// Natija: ["Nick", "Chris", "Joe", ...]

Map qachon kerak bo'ladi?

Ma'lumotlar bazasidan kelgan ma'lumot UserModel formatida emas, uni konvertatsiya qilish kerak
Bir xil ekrannn turli model turlari uchun qayta ishlatish — foydalanuvchilar uchun ham, kitoblar uchun ham ismlar ro'yxati ko'rsatish

4. compactMap() — optional bilan xavfsiz ishlash

Agar model xususiyati optional bo'lsa va nil qiymatlarni o'tkazib yuborish kerak bo'lsa:

struct UserModel: Identifiable {
    let id: String = UUID().uuidString
    let name: String?  // optional — ba'zi foydalanuvchilar ism kiritmagan
    let points: Int
    let isVerified: Bool
}

// Oddiy map — nil bo'lsa majburiy qiymat berish kerak
mappedArray = dataArray.map { user in
    return user.name ?? "Noma'lum"  // nil bo'lsa "Noma'lum" yoziladi
}

// compactMap — nil bo'lsa o'tkazib yuboradi, massivga qo'shilmaydi
mappedArray = dataArray.compactMap { $0.name }
// 10 foydalanuvchidan 2 tasi nil bo'lsa → 8 ta nom qaytariladi

compactMap — optional xususiyatlarni ishlashda nil elementlarni avtomatik o'tkazib yuboradi.

Zanjirlab birlashtirish

Eng kuchli imkoniyat — uchala amalni ketma-ket birlashtirish:

// Alohida-alohida (tushunarliroq)
let sorted = dataArray.sorted { $0.points > $1.points }
let filtered = sorted.filter { $0.isVerified }
let mapped = filtered.compactMap { $0.name }
mappedArray = mapped

// Zanjirlab — professional kod
mappedArray = dataArray
    .sorted { $0.points > $1.points }   // 1. Eng ko'p balldan tartibla
    .filter { $0.isVerified }            // 2. Faqat tasdiqlanganlari
    .compactMap { $0.name }              // 3. Faqat ismlarni qaytarish

Natija: tasdiqlangan foydalanuvchilarning ismlari, eng ko'p balldan kamiga qarab tartiblangan.

Qisqartma yozuv tushuntirishi

// $0 — closure-ga uzatilgan birinchi argument
// $1 — closure-ga uzatilgan ikkinchi argument

// sorted uchun:
.sorted { $0.points > $1.points }
// $0 = user1, $1 = user2 — ikkala element taqqoslanadi

// filter uchun:
.filter { $0.isVerified }
// $0 = har bir element — shartga mos kelganlar qoldiriladi

// map/compactMap uchun:
.map { $0.name }
// $0 = har bir element — o'sha elementdan qiymat qaytariladi

Xulosa

Amal	Vazifasi	Natija turi
`sorted { }`	Massivni tartiblaydi	Bir xil tur
`filter { }`	Shartga mos elementlar	Bir xil tur, kamroq element
`map { }`	Turni o'zgartiradi	Boshqa tur, teng element soni
`compactMap { }`	Turni o'zgartiradi, nil o'tkazadi	Boshqa tur, kamroq element

Bu uchta amal real ilovalarda deyarli har doim ishlatiladi. Ma'lumotlar bazasidan kelgan xom ma'lumotlarni ekranda ko'rsatishga tayyor holga keltirish uchun zarur vositalar.