Swift Academy · पाठ

कलेक्शन में KeyPaths का उपयोग

की पाथ के आधार पर कलेक्शन को क्रमबद्ध और मैप कीजिए।

पाठ 2, कुल 4 में से13 चरण

कलेक्शन में KeyPaths का उपयोग, CoddyKit पर Swift Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Swift Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Swift Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

संग्रहों में कुंजी पथ कमाल दिखाते हैं

संग्रह संचालन, जैसे map, sorted और filter, अक्सर प्रत्येक तत्व का केवल एक गुणधर्म पढ़ते हैं। कुंजी पथ आपको क्लोज़र लिखे बिना उस आशय को व्यक्त करने देते हैं।

स्विफ्ट किसी भी ऐसे स्थान पर कुंजी पथ स्वीकार करता है जहाँ एक-तर्कीय फ़ंक्शन से value लौटाने की अपेक्षा हो, क्योंकि कुंजी पथ को मूल प्रकार से 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 का संक्षिप्त रूप

map(\.property) पास करना उस गुणधर्म को लौटाने वाला क्लोज़र लिखने के बराबर है, लेकिन यह अधिक छोटा और स्पष्ट है। शुरुआती बैकस्लैश और डॉट से कंपाइलर तत्व का प्रकार अपने-आप समझ लेता है।

नीचे दिए गए दोनों रूपों की तुलना कीजिए; इनसे एक ही परिणाम मिलता है।

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

किसी गुणधर्म के आधार पर क्रमबद्ध करने के लिए आपको अब भी एक छोटा तुलना-क्लोज़र लिखना पड़ता है, लेकिन स्पष्टता के लिए उसके भीतर कुंजी पथ के माध्यम से गुणधर्म पढ़ सकते हैं।

यहाँ हम लोगों की age values की तुलना करके उन्हें सबसे कम उम्र से सबसे अधिक उम्र के क्रम में रखते हैं।

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

पुनः उपयोग योग्य क्रमबद्ध करने वाला सहायक

आप एक सामान्य सहायक लिख सकते हैं जो किसी भी तुलनीय गुणधर्म के आधार पर किसी भी सरणी को क्रमबद्ध करे और उस गुणधर्म को कुंजी पथ तर्क के रूप में ले। इससे आपके पूरे कोड आधार में किसी फ़ील्ड के आधार पर क्रमबद्ध करना एक ही पंक्ति का काम बन जाता है।

T: Comparable की बाधा सुनिश्चित करती है कि गुणधर्म का क्रम निर्धारित किया जा सके।

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

कुंजी पथ के माध्यम से फ़िल्टर करना

filter के लिए बूलियन मान लौटाने वाली शर्त चाहिए, इसलिए सादा गुणधर्म कुंजी पथ तभी सीधे काम करता है जब वह गुणधर्म पहले से बूलियन हो।

यहाँ प्रत्येक task में isDone फ़्लैग है और हम कुंजी पथ के संक्षिप्त रूप से उसी के आधार पर फ़िल्टर करते हैं।

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

गैर-बूलियन गुणधर्म पर फ़िल्टर करना

जब आप किसी गैर-बूलियन गुणधर्म पर फ़िल्टर करते हैं, तो उसे क्लोज़र के भीतर कुंजी पथ के माध्यम से पढ़कर उसकी तुलना कीजिए। एक सामान्य सहायक इस तरीके को किसी भी समानता-जाँच योग्य गुणधर्म के लिए अपना सकता है।

यहाँ हम केवल उन लोगों को रखते हैं जिनका city किसी लक्ष्य से मेल खाता है।

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 और min

max(by:) और min(by:) विधियाँ sorted की तरह ही तुलना-क्लोज़र लेती हैं। सबसे बड़े या सबसे छोटे value वाला तत्व खोजने के लिए गुणधर्म को कुंजी पथ के माध्यम से पढ़िए।

यहाँ हम सबसे अधिक उम्र वाले व्यक्ति को खोजते हैं।

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 के साथ किसी गुणधर्म का योग

आप map(\.property) को reduce के साथ मिलाकर किसी संख्यात्मक फ़ील्ड का कुल निकाल सकते हैं। पहले प्रत्येक तत्व को अपनी इच्छित संख्या में बदलें, फिर उन सभी को जोड़ दें।

यहाँ हम एक ही प्रक्रिया-श्रृंखला में सभी age values का योग निकालते हैं।

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)

कुंजी पथ के आधार पर समूह बनाना

Dictionary(grouping:by:) किसी क्लोज़र के परिणाम के आधार पर तत्वों को अलग-अलग समूहों में रखता है। किसी फ़ील्ड के आधार पर समूह बनाने के लिए उस गुणधर्म को कुंजी पथ के माध्यम से पढ़िए।

यहाँ लोगों को city के आधार पर सरणियों वाले शब्दकोश में समूहित किया गया है।

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

बहु-फ़ील्ड क्रमबद्ध करना

किसी एक फ़ील्ड के आधार पर क्रमबद्ध करके समान मानों की स्थिति में दूसरे फ़ील्ड से क्रम तय करने के लिए पहले प्राथमिक कुंजी पथ की तुलना करें और प्राथमिक मान बराबर होने पर दूसरे कुंजी पथ का उपयोग करें।

यहाँ हम age के आधार पर और समान age होने पर नाम के आधार पर क्रमबद्ध करते हैं।

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

यहाँ कुंजी पथ क्लोज़र से बेहतर क्यों हैं

संग्रह कॉल में कुंजी पथों का उपयोग करने से अनावश्यक प्रारंभिक कोड कम होता है, क्लोज़र के भीतर टंकण-त्रुटि की संभावना हटती है और आशय स्पष्ट हो जाता है: आप एक ही फ़ील्ड को अलग रूप में निकाल रहे हैं।

जटिल रूपांतरणों के लिए क्लोज़र अब भी सही उपकरण है, लेकिन साधारण गुणधर्म-पठन के लिए \.property सबसे स्पष्ट विकल्प है।

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)

त्वरित जाँच: map में कुंजी पथ

प्रत्येक तत्व से एक गुणधर्म निकालने के लिए संक्षिप्त कुंजी पथ रूप चुनिए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: संग्रहों में कुंजी पथ

आपने देखा कि कुंजी पथ संग्रह कोड को संक्षिप्त कैसे बनाते हैं:

map(\.property) बिना क्लोज़र के एक फ़ील्ड को अलग रूप में निकालता है।
filter(\.boolProperty) सीधे बूलियन फ़ील्ड के लिए काम करता है; अन्य फ़ील्ड के लिए [keyPath:] के साथ क्लोज़र का उपयोग करें।
क्रमबद्ध करना, max और min अपनी तुलना-क्लोज़र के भीतर कुंजी पथ के माध्यम से गुणधर्म पढ़ते हैं।
KeyPath लेने वाले सामान्य सहायक किसी फ़ील्ड के आधार पर क्रमबद्ध करने और फ़िल्टर करने को पुनः उपयोग योग्य एक-पंक्ति के काम में बदल देते हैं।

अब आप लेखन योग्य कुंजी पथ सीखेंगे, जिनसे केवल पढ़ने के बजाय value निर्धारित की जा सकती हैं।

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

शुरुआत निःशुल्क

एआई शिक्षक के साथ Swift सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 122
पाठ: 409

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “कलेक्शन में KeyPaths का उपयोग” पाठ निःशुल्क है?

हाँ — Swift Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “कलेक्शन में KeyPaths का उपयोग” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Swift Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“कलेक्शन में KeyPaths का उपयोग” में मैं क्या सीखूँगा?

की पाथ के आधार पर कलेक्शन को क्रमबद्ध और मैप कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Swift Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Swift Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Swift Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“कलेक्शन में KeyPaths का उपयोग” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Swift Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Swift Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Swift Academy पर वापस जाएँ