PricingLoginStart free
Swift Academy · Pelajaran

Menggunakan KeyPaths dalam Koleksi

Urutkan dan petakan koleksi berdasarkan jalur kunci.

Pelajaran 2 dari 413 langkah

Menggunakan KeyPaths dalam Koleksi adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Jalur Kunci Unggul dalam Koleksi

Operasi koleksi seperti map, sorted, dan filter sering kali hanya membaca satu properti dari setiap elemen. Jalur kunci memungkinkan Anda menyatakan maksud tersebut tanpa menulis fungsi anonim.

Swift menerima jalur kunci di mana pun fungsi dengan satu argumen yang mengembalikan nilai diharapkan, karena jalur kunci dapat digunakan sebagai fungsi dari Root ke 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)

Bentuk Singkat map dengan Jalur Kunci

Meneruskan map(\.property) setara dengan menulis fungsi anonim yang mengembalikan properti tersebut, tetapi lebih singkat dan jelas. Garis miring terbalik dan titik di awal memungkinkan kompiler menyimpulkan tipe elemen.

Bandingkan kedua bentuk di bawah ini; keduanya menghasilkan hasil 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 Jalur Kunci

Untuk mengurutkan berdasarkan suatu properti, Anda tetap menulis fungsi pembanding kecil, tetapi Anda dapat membaca properti melalui jalur kunci di dalamnya agar lebih jelas.

Di sini kita mengurutkan orang dari yang termuda hingga yang tertua 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))

Fungsi Pembantu Pengurutan yang Dapat Digunakan Ulang

Anda dapat menulis fungsi pembantu generik yang mengurutkan larik apa pun berdasarkan properti apa pun yang dapat dibandingkan, dengan menerima properti tersebut sebagai argumen jalur kunci. Dengan demikian, pengurutan berdasarkan suatu properti dapat ditulis dalam satu baris di seluruh basis kode Anda.

Batasan T: Comparable memastikan bahwa properti tersebut dapat diurutkan.

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

Penyaringan Melalui Jalur Kunci

Untuk filter, Anda memerlukan predikat yang mengembalikan nilai boolean, sehingga jalur kunci properti tanpa tambahan hanya dapat digunakan secara langsung ketika propertinya memang bertipe boolean.

Di sini setiap tugas memiliki penanda isDone, dan kita menyaringnya menggunakan bentuk singkat jalur 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))

Penyaringan Berdasarkan Properti Non-Boolean

Ketika menyaring berdasarkan properti non-boolean, bacalah properti tersebut melalui jalur kunci di dalam fungsi anonim, lalu bandingkan nilainya. Fungsi pembantu generik dapat merangkum pola ini untuk properti apa pun yang dapat dibandingkan kesamaannya.

Di sini kita hanya mempertahankan orang yang kotanya cocok dengan 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 berdasarkan Jalur Kunci

Metode max(by:) dan min(by:) menerima fungsi pembanding seperti halnya sorted. Bacalah properti melalui jalur kunci untuk menemukan elemen 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 Properti dengan reduce

Anda dapat menggabungkan map(\.property) dengan reduce untuk menjumlahkan properti numerik. Pertama, ubah setiap elemen menjadi angka yang Anda inginkan, lalu jumlahkan semuanya.

Di sini kita menjumlahkan semua usia dalam satu rangkaian proses.

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)

Pengelompokan Berdasarkan Jalur Kunci

Dictionary(grouping:by:) mengelompokkan elemen berdasarkan hasil suatu fungsi anonim. Bacalah properti melalui jalur kunci untuk mengelompokkan berdasarkan properti tersebut.

Di sini orang-orang dikelompokkan berdasarkan kota ke dalam kamus berisi berbagai larik.

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

Pengurutan Berdasarkan Banyak Properti

Untuk mengurutkan berdasarkan satu properti dan menyelesaikan nilai yang sama dengan properti lain, bandingkan jalur kunci utama terlebih dahulu, lalu gunakan jalur kunci kedua ketika nilai utama sama.

Di sini kita mengurutkan berdasarkan usia, lalu berdasarkan nama untuk usia 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 Jalur Kunci Lebih Unggul daripada Fungsi Anonim di Sini

Menggunakan jalur kunci dalam pemanggilan koleksi mengurangi kode berulang, menghilangkan kemungkinan salah ketik di dalam fungsi anonim, dan memperjelas maksudnya: Anda sedang mengambil satu properti.

Untuk transformasi yang rumit, fungsi anonim tetap merupakan alat yang tepat, tetapi untuk sekadar membaca properti, \.property adalah 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)

Pemeriksaan Singkat: Jalur Kunci dalam map

Pilih bentuk jalur kunci yang ringkas untuk mengambil satu properti dari setiap elemen.

Jawab di pelajaran interaktif

Ringkasan: Jalur Kunci dalam Koleksi

Anda telah melihat cara jalur kunci membuat kode koleksi menjadi ringkas:

  • map(\.property) mengambil satu properti tanpa fungsi anonim.
  • filter(\.boolProperty) dapat digunakan secara langsung untuk properti boolean; gunakan fungsi anonim dengan [keyPath:] untuk properti lainnya.
  • Pengurutan, max, dan min membaca properti melalui jalur kunci di dalam fungsi pembandingnya.
  • Fungsi pembantu generik yang menerima KeyPath mengubah pengurutan dan penyaringan berdasarkan suatu properti menjadi kode satu baris yang dapat digunakan ulang.

Selanjutnya Anda akan mempelajari jalur kunci yang dapat ditulis, yang memungkinkan Anda menetapkan nilai, bukan hanya 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))
Gratis untuk memulai

Belajar Swift dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
122
Pelajaran
409
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menggunakan KeyPaths dalam Koleksi” gratis?

Ya — teks lengkap “Menggunakan KeyPaths dalam Koleksi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menggunakan KeyPaths dalam Koleksi”?

Urutkan dan petakan koleksi berdasarkan jalur kunci. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Menggunakan KeyPaths dalam Koleksi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Dasar-Dasar KeyPath
  2. Menggunakan KeyPaths dalam Koleksi
  3. KeyPath yang Dapat Ditulis dan Referensi
  4. @dynamicMemberLookup
← Kembali ke Swift Academy