Swift Academy · Ders

Koleksiyonlarda KeyPaths Kullanımı

Koleksiyonları anahtar yoluna göre sıralayın ve eşleyin.

Koleksiyonlarda KeyPaths Kullanımı, CoddyKit'te ücretsiz bir Swift Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Swift Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Swift Academy kursu toplamda 4 dersten oluşur.

Anahtar Yolları Koleksiyonlarda Parlıyor

map, sorted ve filter gibi koleksiyon işlemleri çoğu zaman her öğenin yalnızca bir özelliğini okur. Anahtar yolları, kapanış yazmadan bu amacı ifade etmenizi sağlar.

Swift, bir değer döndüren tek bağımsız değişkenli bir işlevin beklendiği her yerde anahtar yolu kabul eder; çünkü anahtar yolu Root türünden Value türüne bir işlev olarak kullanılabilir.

struct Person {
    let name: String
    let age: Int
}

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let names = people.map(\.name)
print(names)

Anahtar Yolu Kısaltmasıyla map

map(\.property) geçirmek, bu özelliği döndüren bir kapanış yazmakla eşdeğerdir; ancak daha kısa ve daha anlaşılırdır. Baştaki ters eğik çizgi ve nokta, derleyicinin öğe türünü çıkarsamasını sağlar.

Aşağıdaki iki biçimi karşılaştırınız; aynı sonucu üretirler.

struct Person {
    let name: String
    let age: Int
}

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let closureForm = people.map { $0.age }
let keyPathForm = people.map(\.age)
print(closureForm)
print(keyPathForm)

Anahtar Yolu Karşılaştırmasıyla sorted(by:)

Bir özelliğe göre sıralamak için yine küçük bir karşılaştırma kapanışı yazarsınız; ancak açıklığı artırmak için özelliği kapanışın içinde bir anahtar yolu aracılığıyla okuyabilirsiniz.

Burada kişileri, age değerlerini karşılaştırarak en gençten en yaşlıya sıralıyoruz.

struct Person {
    let name: String
    let age: Int
}

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let path = \Person.age
let sorted = people.sorted { $0[keyPath: path] < $1[keyPath: path] }
print(sorted.map(\.name))

Yeniden Kullanılabilir Bir Sıralama Yardımcısı

Herhangi bir diziyi, karşılaştırılabilir herhangi bir özelliğe göre sıralayan ve özelliği bir anahtar yolu bağımsız değişkeni olarak alan genel bir yardımcı işlev yazabilirsiniz. Böylece bir alana göre sıralama, kod tabanınızın her yerinde tek satırlık bir işleme dönüşür.

T: Comparable kısıtı, özelliğin sıralanabilmesini sağlar.

func sorted<E, T: Comparable>(_ array: [E], by path: KeyPath<E, T>) -> [E] {
    array.sorted { $0[keyPath: path] < $1[keyPath: path] }
}

struct Person { let name: String; let age: Int }
let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
print(sorted(people, by: \.age).map(\.name))

Anahtar Yolu Üzerinden Filtreleme

filter için Boole döndüren bir koşul gerekir; bu nedenle yalın bir özellik anahtar yolu, yalnızca özellik zaten Boole olduğunda doğrudan çalışır.

Burada her görevin bir isDone bayrağı vardır ve anahtar yolu kısaltmasını kullanarak buna göre filtreliyoruz.

struct Task {
    let title: String
    let isDone: Bool
}

let tasks = [Task(title: "A", isDone: true), Task(title: "B", isDone: false)]
let finished = tasks.filter(\.isDone)
print(finished.map(\.title))

Boole Olmayan Bir Özelliğe Göre Filtreleme

Boole olmayan bir özelliğe göre filtreleme yaparken özelliği bir kapanışın içinde anahtar yolu aracılığıyla okuyup karşılaştırınız. Genel bir yardımcı, bu örüntüyü eşitlenebilir her özellik için kapsayabilir.

Burada yalnızca şehri hedefle eşleşen kişileri tutuyoruz.

struct Person { let name: String; let city: String }

func filter<E, T: Equatable>(_ array: [E], _ path: KeyPath<E, T>, equals value: T) -> [E] {
    array.filter { $0[keyPath: path] == value }
}

let people = [Person(name: "Ana", city: "Oslo"), Person(name: "Ben", city: "Rome")]
print(filter(people, \.city, equals: "Oslo").map(\.name))

Anahtar Yoluna Göre max ve min

max(by:) ve min(by:) yöntemleri, tıpkı sorted gibi bir karşılaştırma kapanışı alır. En büyük veya en küçük değere sahip öğeyi bulmak için özelliği bir anahtar yolu aracılığıyla okuyunuz.

Burada en yaşlı kişiyi buluyoruz.

struct Person { let name: String; let age: Int }

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25), Person(name: "Cy", age: 41)]
let path = \Person.age
if let oldest = people.max(by: { $0[keyPath: path] < $1[keyPath: path] }) {
    print(oldest.name)
}

reduce ile Bir Özelliği Toplama

Sayısal bir alanın toplamını bulmak için map(\.property) ile reduce işlemlerini birleştirebilirsiniz. Önce her öğeyi istediğiniz sayıya dönüştürün, ardından bunları toplayın.

Burada tüm yaşları tek bir işlem hattında topluyoruz.

struct Person { let name: String; let age: Int }

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let totalAge = people.map(\.age).reduce(0, +)
print(totalAge)

Anahtar Yoluna Göre Gruplama

Dictionary(grouping:by:), öğeleri bir kapanışın sonucuna göre gruplara ayırır. Bir alana göre gruplamak için özelliği anahtar yolu aracılığıyla okuyunuz.

Burada kişiler, dizilerden oluşan bir sözlükte şehre göre gruplanıyor.

struct Person { let name: String; let city: String }

let people = [
    Person(name: "Ana", city: "Oslo"),
    Person(name: "Ben", city: "Rome"),
    Person(name: "Cy", city: "Oslo")
]
let path = \Person.city
let byCity = Dictionary(grouping: people, by: { $0[keyPath: path] })
print(byCity["Oslo"]?.map(\.name) ?? [])

Birden Çok Alana Göre Sıralama

Bir alana göre sıralayıp eşitlikleri başka bir alanla bozmak için önce birincil anahtar yolunu karşılaştırın; birincil değerler eşitse ikincil anahtara geçin.

Burada yaşa, eşit yaşlarda ise ada göre sıralıyoruz.

struct Person { let name: String; let age: Int }

let people = [
    Person(name: "Zoe", age: 30),
    Person(name: "Ana", age: 30),
    Person(name: "Ben", age: 25)
]
let sorted = people.sorted {
    if $0[keyPath: \Person.age] != $1[keyPath: \Person.age] {
        return $0.age < $1.age
    }
    return $0.name < $1.name
}
print(sorted.map(\.name))

Anahtar Yolları Burada Neden Kapanışlardan Daha İyi

Koleksiyon çağrılarında anahtar yollarını kullanmak gereksiz kodu azaltır, kapanış gövdesinde yazım hatası yapma olasılığını ortadan kaldırır ve amacı açıkça gösterir: tek bir alanı seçiyorsunuz.

Karmaşık dönüşümler için kapanış hâlâ doğru araçtır; ancak yalın bir özellik okuması için \.property en anlaşılır seçimdir.

struct Product { let name: String; let price: Double }

let products = [Product(name: "Pen", price: 2), Product(name: "Pad", price: 5)]
let names = products.map(\.name)
let prices = products.map(\.price)
print(names)
print(prices)

Hızlı Kontrol: map içinde Anahtar Yolu

Her öğeden tek bir özellik çıkarmak için kısa anahtar yolu biçimini seçiniz.

Özet: Koleksiyonlarda Anahtar Yolları

Anahtar yollarının koleksiyon kodunu nasıl kısalttığını gördünüz:

map(\.property), kapanış kullanmadan tek bir alanı seçer.
filter(\.boolProperty), Boole alanlarında doğrudan çalışır; diğerleri için [keyPath:] kullanan bir kapanış kullanın.
Sıralama, max ve min, özelliklerini karşılaştırma kapanışlarının içinde bir anahtar yolu aracılığıyla okur.
Bir KeyPath alan genel yardımcılar, bir alana göre sıralama ve filtrelemeyi yeniden kullanılabilir tek satırlık işlemlere dönüştürür.

Sırada, yalnızca değerleri okumanızı değil, ayarlamanızı da sağlayan yazılabilir anahtar yollarını öğreneceksiniz.

struct Person { let name: String; let age: Int }

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let youngestFirst = people.sorted { $0[keyPath: \Person.age] < $1[keyPath: \Person.age] }
print(youngestFirst.map(\.name))

Sıkça Sorulan Sorular

“Koleksiyonlarda KeyPaths Kullanımı” dersi ücretsiz mi?

Evet — “Koleksiyonlarda KeyPaths Kullanımı” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Swift Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Swift Academy kursu toplamda 4 dersten oluşur.

“Koleksiyonlarda KeyPaths Kullanımı” dersinde ne öğreneceğim?

Koleksiyonları anahtar yoluna göre sıralayın ve eşleyin. Swift Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Swift Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Swift Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Koleksiyonlarda KeyPaths Kullanımı” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Swift Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Swift Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Swift Academy Sayfasına Dön