Swift Academy · Pelajaran

Menggunakan KeyPaths dalam Koleksi

Isih dan petakan koleksi mengikut laluan kunci.

Pelajaran 2 daripada 413 langkah

Menggunakan KeyPaths dalam Koleksi ialah pelajaran Swift Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Swift Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Laluan Kunci Menyerlah dalam Koleksi

Operasi koleksi seperti map, sorted dan filter sering kali hanya membaca satu sifat bagi setiap unsur. Laluan kunci membolehkan anda menyatakan tujuan itu tanpa menulis penutupan.

Swift menerima laluan kunci di mana-mana fungsi satu argumen yang mengembalikan nilai dijangka, kerana laluan kunci boleh digunakan sebagai fungsi daripada Root kepada Value.

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)

map dengan Singkatan Laluan Kunci

Menghantar map(\.property) adalah setara dengan menulis penutupan yang mengembalikan sifat tersebut, tetapi lebih pendek dan jelas. Garis miring terbalik dan titik pada permulaan membolehkan pengompil membuat inferens terhadap jenis unsur.

Bandingkan kedua-dua bentuk di bawah; kedua-duanya menghasilkan keputusan yang sama.

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)

sorted(by:) dengan Perbandingan Laluan Kunci

Untuk mengisih mengikut sesuatu sifat, anda masih perlu menulis penutupan perbandingan yang ringkas, tetapi anda boleh membaca sifat itu melalui laluan kunci di dalamnya supaya lebih jelas.

Di sini, kita mengisih orang daripada yang paling muda kepada yang paling tua dengan membandingkan nilai age mereka.

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))

Pembantu Pengisihan Boleh Guna Semula

Anda boleh menulis pembantu generik yang mengisih sebarang tatasusunan mengikut sebarang sifat yang boleh dibandingkan, dengan menerima sifat itu sebagai argumen laluan kunci. Ini menjadikan pengisihan mengikut medan hanya satu baris di seluruh pangkalan kod anda.

Kekangan T: Comparable memastikan sifat itu boleh disusun mengikut tertib.

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))

Menapis Melalui Laluan Kunci

Untuk filter, anda memerlukan predikat yang mengembalikan nilai Boolean, jadi laluan kunci sifat tanpa tambahan hanya boleh digunakan secara terus apabila sifat itu memang Boolean.

Di sini, setiap tugas mempunyai bendera isDone, dan kita menapis berdasarkan bendera itu menggunakan singkatan laluan kunci.

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))

Menapis Sifat Bukan Boolean

Apabila menapis mengikut sifat bukan Boolean, baca sifat itu melalui laluan kunci di dalam penutupan dan bandingkan nilainya. Pembantu generik boleh merangkum pola ini untuk sebarang sifat yang boleh disamakan.

Di sini, kita hanya mengekalkan orang yang bandarnya sepadan dengan bandar sasaran.

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))

max dan min Mengikut Laluan Kunci

Kaedah max(by:) dan min(by:) menerima penutupan perbandingan sama seperti sorted. Baca sifat itu melalui laluan kunci untuk mencari unsur dengan nilai terbesar atau terkecil.

Di sini, kita mencari orang yang paling tua.

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

Menjumlahkan Sifat Dengan reduce

Anda boleh menggabungkan map(\.property) dengan reduce untuk menjumlahkan medan berangka. Mula-mula, petakan setiap unsur kepada nombor yang anda kehendaki, kemudian jumlahkan semuanya.

Di sini, kita menjumlahkan semua umur dalam satu saluran pemprosesan.

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)

Pengumpulan Mengikut Laluan Kunci

Dictionary(grouping:by:) mengumpulkan unsur berdasarkan hasil penutupan. Baca sesuatu sifat melalui laluan kunci untuk mengumpulkan unsur mengikut medan itu.

Di sini, orang dikumpulkan mengikut bandar ke dalam kamus tatasusunan.

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) ?? [])

Pengisihan Berbilang Medan

Untuk mengisih mengikut satu medan dan menyelesaikan seri dengan medan lain, bandingkan laluan kunci utama dahulu dan gunakan laluan kunci sekunder apabila nilai utama sama.

Di sini, kita mengisih mengikut umur, kemudian mengikut nama bagi umur yang sama.

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))

Mengapa Laluan Kunci Mengatasi Penutupan di Sini

Menggunakan laluan kunci dalam panggilan koleksi mengurangkan kod berulang, menghapuskan kemungkinan tersilap taip dalam badan penutupan dan menjadikan tujuan kod jelas: anda sedang mengambil satu medan.

Untuk transformasi yang kompleks, penutupan masih merupakan alat yang sesuai, tetapi untuk pembacaan sifat biasa, \.property ialah pilihan yang paling jelas.

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)

Semakan Pantas: Laluan Kunci dalam map

Pilih bentuk laluan kunci yang ringkas untuk mengambil satu sifat daripada setiap unsur.

Jawab dalam pelajaran interaktif

Imbas Kembali: Laluan Kunci dalam Koleksi

Anda telah melihat cara laluan kunci menjadikan kod koleksi lebih ringkas:

map(\.property) mengambil satu medan daripada setiap unsur tanpa penutupan.
filter(\.boolProperty) berfungsi secara terus untuk medan Boolean; gunakan penutupan dengan [keyPath:] untuk medan lain.
Pengisihan, max dan min membaca sifat melalui laluan kunci di dalam penutupan perbandingan.
Pembantu generik yang menerima KeyPath menjadikan pengisihan dan penapisan mengikut medan sebagai ungkapan satu baris yang boleh diguna semula.

Seterusnya, anda akan mempelajari laluan kunci boleh tulis yang membolehkan anda menetapkan nilai, bukan sekadar membacanya.

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))

Percuma untuk bermula

Pelajari Swift dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 122
Pelajaran: 409

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menggunakan KeyPaths dalam Koleksi” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Swift Academy, termasuk “Menggunakan KeyPaths dalam Koleksi”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Menggunakan KeyPaths dalam Koleksi”?

Isih dan petakan koleksi mengikut laluan kunci. Anda berlatih Swift Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Swift Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Swift Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Menggunakan KeyPaths dalam Koleksi” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy