Swift में ऑब्जेक्ट ऐरे को सॉर्ट करना: सरल से जटिल तक

Swift में प्रॉपर्टी के अनुसार ऑब्जेक्ट ऐरे को कैसे सॉर्ट करें: हुड के नीचे झाँकना

नमस्ते, साथी! यदि आपने कभी Swift में कोई ऐसा ऐप लिखा है जो उपयोगकर्ताओं, उत्पादों या कार्यों की सूची दिखाता है, तो आपने निश्चित रूप से इस डेटा को सॉर्ट करने की आवश्यकता का सामना किया होगा। प्रश्न "How to sort an array of custom objects by property value?" Stack Overflow पर सबसे लोकप्रिय प्रश्नों में से एक है। और यह कोई संयोग नहीं है: पहली नज़र में सब कुछ सरल लगता है, लेकिन जैसे ही आप गहराई में जाते हैं, संभावनाओं की पूरी परतें खुल जाती हैं।

आज हम केवल तैयार उत्तर नहीं देंगे। हम यह समझेंगे कि Swift के हुड के नीचे सॉर्टिंग कैसे काम करती है, इसमें कौन से तंत्र शामिल हैं, और केवल काम करने वाला कोड नहीं, बल्कि कुशल और सुंदर कोड कैसे लिखें। चलिए शुरू करते हैं!

Swift में ऑब्जेक्ट ऐरे को सॉर्ट करना क्या है?

कल्पना करें: आपके पास User ऑब्जेक्ट का एक ऐरे है। प्रत्येक उपयोगकर्ता का एक नाम, आयु और रेटिंग है। आपको उन्हें आयु के अनुसार (सबसे छोटे से सबसे बड़े) सॉर्ट करके स्क्रीन पर प्रदर्शित करना है।

Swift में, यह बिल्ट-इन मेथड sort() (ऐरे को उसी स्थान पर सॉर्ट करता है) और sorted() (एक नया सॉर्ट किया गया ऐरे लौटाता है) के माध्यम से किया जाता है। दोनों एक क्लोजर लेते हैं जो क्रम निर्धारित करता है।

struct User {\n    let name: String\n    let age: Int\n    let rating: Double\n}\n\nlet users = [\n    User(name: "अन्ना", age: 25, rating: 4.5),\n    User(name: "बोरिस", age: 30, rating: 3.8),\n    User(name: "विका", age: 22, rating: 4.9)\n]\n\n// आयु के अनुसार सॉर्ट (आरोही क्रम में)\nlet sortedByAge = users.sorted { $0.age < $1.age }\nprint(sortedByAge.map { $0.name }) // ["विका", "अन्ना", "बोरिस"]

बस इतना ही। लेकिन आइए समझें कि वास्तव में यहाँ क्या हो रहा है।

sort() हुड के नीचे कैसे काम करता है: एल्गोरिदम और क्लोजर

Swift में sort() मेथड एक हाइब्रिड एल्गोरिदम TimSort (टिम पीटर्स के नाम पर) का उपयोग करता है। यह एक अनुकूली, स्थिर सॉर्टिंग एल्गोरिदम है जो मर्ज सॉर्ट और इंसर्शन सॉर्ट को जोड़ता है। यह आंशिक रूप से सॉर्ट किए गए डेटा पर विशेष रूप से कुशल है - न्यूज़ फ़ीड और कार्य सूचियों में आपका स्वागत है!

आप जो क्लोजर पास करते हैं, वह एक सॉर्टिंग प्रेडिकेट है: एक फंक्शन जो दो एलिमेंट लेता है और true लौटाता है यदि पहला दूसरे से पहले आना चाहिए। Swift इस क्लोजर को बार-बार कॉल करता है, एलिमेंट के जोड़ों की तुलना करता है।

महत्वपूर्ण: यदि आपके ऑब्जेक्ट Comparable प्रोटोकॉल का अनुपालन करते हैं, तो आप बिना क्लोजर के भी काम कर सकते हैं:

struct User: Comparable {\n    let name: String\n    let age: Int\n    \n    static func < (lhs: User, rhs: User) -> Bool {\n        return lhs.age < rhs.age\n    }\n}\n\nlet sortedUsers = users.sorted() // अब सरल

लेकिन क्या होगा यदि आपको रनटाइम में विभिन्न प्रॉपर्टी के अनुसार सॉर्ट करने की आवश्यकता है? यहाँ कीपैथ (KeyPath) मदद करते हैं।

KeyPath के साथ सॉर्टिंग: सुंदरता और लचीलापन

Swift 4 से शुरू करके, हमारे पास KeyPath है। यह किसी ऑब्जेक्ट की प्रॉपर्टी को संदर्भित करने का एक सुरक्षित तरीका है। KeyPath को क्लोजर के साथ जोड़कर, हम एक सार्वभौमिक सॉर्टिंग फंक्शन लिख सकते हैं:

extension Array {\n    mutating func sort<T: Comparable>(by keyPath: KeyPath<Element, T>, ascending: Bool = true) {\n        sort { ascending ?\n            $0[keyPath: keyPath] < $1[keyPath: keyPath] :\n            $0[keyPath: keyPath] > $1[keyPath: keyPath]\n        }\n    }\n    \n    func sorted<T: Comparable>(by keyPath: KeyPath<Element, T>, ascending: Bool = true) -> [Element] {\n        return sorted { ascending ?\n            $0[keyPath: keyPath] < $1[keyPath: keyPath] :\n            $0[keyPath: keyPath] > $1[keyPath: keyPath]\n        }\n    }\n}\n\n// उपयोग:\nusers.sort(by: \\.age) // आयु के अनुसार (आरोही)\nlet sortedByRating = users.sorted(by: \\.rating, ascending: false) // रेटिंग के अनुसार (अवरोही)

सुंदर है ना? टाइप-सेफ