class — यह क्या है, मुख्य अवधारणाएँ और Swift में कार्य सिद्धांत

Swift में class क्या है?

Class — Swift में एक समग्र संदर्भ प्रकार है जो गुणों और विधियों को इनहेरिटेंस और डायनामिक डिस्पैच के समर्थन के साथ एक इकाई में समूहित करता है। struct के विपरीत, एक क्लास इंस्टेंस हीप में बनाया जाता है, और एक वेरिएबल इस इंस्टेंस के संदर्भ को संग्रहीत करता है, न कि स्वयं डेटा को।

जब आप एक क्लास वेरिएबल को दूसरे वेरिएबल को असाइन करते हैं, तो दोनों मेमोरी में उसी ऑब्जेक्ट को संदर्भित करते हैं। एक संदर्भ के माध्यम से परिवर्तन दूसरे के माध्यम से दिखाई देते हैं — यह संदर्भ प्रकारों का एक मौलिक गुण है, जिसका उपयोग डेलिगेशन, ऑब्ज़र्वेशन और साझा स्थिति पैटर्न में किया जाता है।

Apple Swift दस्तावेज़ीकरण के अनुसार, UIKit और AppKit के साथ काम करने का एकमात्र तरीका क्लासेज़ हैं, जहां सभी UI घटक UIView और UIViewController से इनहेरिट करते हैं। इसके अतिरिक्त, क्लासेज़ उन पैटर्न को लागू करने के लिए आवश्यक हैं जिनमें ऑब्जेक्ट पहचान (एक ऑब्जेक्ट के दो संदर्भ) और नियंत्रित जीवनकाल की आवश्यकता होती है।

Class एक संदर्भ प्रकार के रूप में

संदर्भ प्रकार शब्दार्थ — क्लासेज़ का प्रमुख गुण। किसी क्लास को एक नए वेरिएबल को असाइन करते समय, Swift संदर्भ की प्रतिलिपि बनाता है, डेटा की नहीं। उसी इंस्टेंस को संदर्भित करने वाले सभी वेरिएबल इसकी वर्तमान स्थिति देखते हैं और इसे संशोधित कर सकते हैं। यह व्यवहार मूल्य प्रकारों से मौलिक रूप से भिन्न है, जहां प्रत्येक वेरिएबल को एक स्वतंत्र प्रतिलिपि मिलती है।

// संदर्भ प्रकार शब्दार्थ का उदाहरण
class User {
    var name: String
    init(name: String) { self.name = name }
}

let user1 = User(name: "Alice")
let user2 = user1           // user2 — समान संदर्भ
user2.name = "Bob"

print(user1.name)               // "Bob" — user2 के माध्यम से बदला गया!

// === ऑपरेटर के साथ पहचान जांच
print(user1 === user2)          // true — समान ऑब्जेक्ट

=== (पहचान) और !== ऑपरेटर जांचते हैं कि क्या दो वेरिएबल एक ही क्लास इंस्टेंस को संदर्भित करते हैं। यह == (समानता) से भिन्न है, जो गुण मानों की तुलना करता है। === ऑपरेटर struct के लिए उपलब्ध नहीं है — मूल्य प्रकारों की कोई पहचान नहीं होती।

क्लासेज़ की इनहेरिटेंस

इनहेरिटेंस — एक तंत्र जिसके द्वारा एक क्लास पैरेंट क्लास के गुणों और विधियों को ग्रहण कर सकती है। Swift में, एक क्लास केवल एक पैरेंट से इनहेरिट कर सकती है (एकल इनहेरिटेंस), लेकिन कई प्रोटोकॉल लागू कर सकती है। override कीवर्ड इनहेरिटेड विधि या गुण को ओवरराइड करने की अनुमति देता है।

बेस क्लास और सबक्लास

कोई भी क्लास जो दूसरी क्लास से इनहेरिट नहीं करती, स्वचालित रूप से बेस बन जाती है (NSObject से भ्रमित न हों)। एक सबक्लास अपने नाम के बाद कोलन के साथ पैरेंट निर्दिष्ट करता है। यदि कोई सबक्लास पैरेंट की विधि को ओवरराइड करता है, तो उसे पैरेंट के व्यवहार को संरक्षित करने के लिए super.method() को कॉल करना होगा — यह कंपाइलर की आवश्यकता है।

फ़ाइनल क्लास

class से पहले कीवर्ड final इनहेरिटेंस को रोकता है। कंपाइलर स्टैटिक डिस्पैच के माध्यम से फ़ाइनल क्लास की विधि कॉल को अनुकूलित कर सकता है, जिससे प्रदर्शन में सुधार होता है। उन क्लासेज़ के लिए final का उपयोग करें जो विस्तार के लिए नहीं हैं — यह आपके इरादे का दस्तावेज़ीकरण करता है और कोड को गति देता है।

// Swift में क्लास इनहेरिटेंस का उदाहरण
class Vehicle {
    var speed: Double = 0

    func description() -> String {
        "Speed: \(speed) km/h"
    }
}

// Car, Vehicle से इनहेरिट करता है
class Car: Vehicle {
    var brand: String = "Unknown"

    override func description() -> String {
        "\(brand) - \(speed) km/h"
    }
}

// फ़ाइनल क्लास — इनहेरिटेंस को रोकता है
final class ElectricCar: Car {
    var batteryLevel: Double = 100
}

let tesla = ElectricCar()
tesla.brand = "Tesla"
tesla.speed = 120
print(tesla.description())  // "Tesla - 120.0 km/h"

इनहेरिटेंस एक शक्तिशाली लेकिन जिम्मेदारी भरा तंत्र है। गहरी पदानुक्रम (5+ स्तर) रखरखाव और परीक्षण को जटिल बनाती है। इनहेरिटेंस के बिना कार्यात्मक पुन: उपयोग के लिए, extension और प्रोटोकॉल-उन्मुख प्रोग्रामिंग के साथ प्रोटोकॉल का उपयोग करें — यह दृष्टिकोण Apple गहरी क्लास पदानुक्रम के विकल्प के रूप में प्रचारित करता है।

डीइनिशियलाइज़ेशन और मेमोरी प्रबंधन

Swift क्लास मेमोरी प्रबंधन के लिए ARC (स्वचालित संदर्भ गणना) का उपयोग करता है। प्रत्येक क्लास इंस्टेंस में एक सशक्त संदर्भ काउंटर होता है। जब एक नया सशक्त संदर्भ बनाया जाता है, तो काउंटर बढ़ता है; जब नष्ट होता है, तो घटता है। जब काउंटर शून्य तक पहुँचता है, तो मेमोरी मुक्त हो जाती है।

Deinit

Deinit — एक विधि जो क्लास इंस्टेंस के मुक्त होने से पहले स्वचालित रूप से बुलाई जाती है। यह संसाधनों को मुक्त करती है: फ़ाइलें बंद करती है, सूचनाओं से सदस्यता रद्द करती है, टाइमर रोकती है। Deinit केवल क्लासेज़ के लिए उपलब्ध है — structs और enums में यह नहीं होता।

कमज़ोर और बेस्वामी संदर्भ

सशक्त संदर्भ चक्रों (retain cycles) को रोकने के लिए, Swift weak और unowned संदर्भ प्रदान करता है। Weak एक वैकल्पिक संदर्भ है जो ऑब्जेक्ट के मुक्त होने पर स्वचालित रूप से nil हो जाता है। Unowned गैर-वैकल्पिक है लेकिन एक ऐसे ऑब्जेक्ट को संदर्भित करता है जो वर्तमान संदर्भ से अधिक समय तक जीवित रहने की गारंटी है। एक विशिष्ट retain cycle पैरेंट-चाइल्ड संबंध में होता है: चाइल्ड पैरेंट के लिए एक सशक्त संदर्भ रखता है।

// ARC और कमज़ोर संदर्भ का उदाहरण
class Parent {
    var name: String
    var child: Child?

    init(name: String) { self.name = name }
    deinit { print("\(name) मुक्त हो गया") }
}

class Child {
    var name: String
    weak var parent: Parent?   // weak retain cycle को रोकता है

    init(name: String) { self.name = name }
    deinit { print("\(name) मुक्त हो गया") }
}

var parent: Parent? = Parent(name: "Anna")
parent?.child = Child(name: "Mia")
parent?.child?.parent = parent

parent = nil  // दोनों ऑब्जेक्ट मुक्त हो गए!
// weak के बिना यह retain cycle बनाएगा

चाइल्ड ऑब्जेक्ट से पैरेंट तक संदर्भों और क्लोज़र में कैप्चर सूचियों के लिए हमेशा weak का उपयोग करें। Unowned का उपयोग केवल तभी करें जब आप सुनिश्चित हों कि ऑब्जेक्ट वर्तमान संदर्भ से अधिक समय तक जीवित रहेगा — unowned का गलत उपयोग मुक्त मेमोरी तक पहुँचने पर क्रैश का कारण बन सकता है।

Class vs Struct: मुख्य अंतर

class और struct के बीच चुनाव एक आर्किटेक्चरल निर्णय है जो प्रदर्शन, थ्रेड सुरक्षा और API डिज़ाइन को प्रभावित करता है। प्रत्येक मामले में सही निर्णय लेने में मदद के लिए मुख्य अंतरों की तालिका पर विचार करें।

क्लासेज़ का उपयोग करें जब आपको साझा पहचान (कोड के कई भाग एक ऑब्जेक्ट के साथ काम कर रहे हों), इनहेरिटेंस, या Objective-C runtime के साथ इंटरैक्शन की आवश्यकता हो। बाकी सबके लिए, structs पसंद किए जाते हैं — वे तेज़, मल्टीथ्रेडेड कोड में सुरक्षित होते हैं और मेमोरी प्रबंधन की आवश्यकता नहीं होती।

Swift में class का उपयोग कब करें

डिफ़ॉल्ट रूप से struct का उपयोग करने की Apple की अनुशंसा के बावजूद, कई विशिष्ट परिदृश्यों में क्लासेज़ आवश्यक हैं। आइए व्यावहारिक उदाहरणों के साथ प्रत्येक की जाँच करें।

UIKit और AppKit घटक

iOS और macOS में सभी UI घटक UIView (iOS) या NSView (macOS) से इनहेरिट करने वाली क्लासेज़ हैं। आप UIViewController को struct से प्रतिस्थापित नहीं कर सकते — इसे संसाधनों को मुक्त करने के लिए इनहेरिटेंस और deinit की आवश्यकता है। UIKit के साथ काम करते समय, कंट्रोलर, व्यू और उनके डेलिगेट के लिए क्लासेज़ का उपयोग करें।

सिंगलटन और साझा स्थिति

सिंगलटन पैटर्न (पूरे एप्लिकेशन के लिए एक क्लास इंस्टेंस) को संदर्भ शब्दार्थ की आवश्यकता है। प्रबंधक: NetworkManager, SettingsManager, AnalyticsService — आमतौर पर shared static गुण वाली क्लासेज़ के रूप में लागू किए जाते हैं। Structs उपयुक्त नहीं हैं क्योंकि प्रत्येक प्रतिलिपि एक स्वतंत्र इंस्टेंस होगी।

डिपेंडेंसी इंजेक्शन और संदर्भ ऑब्जेक्ट

जब कोई ऑब्जेक्ट सत्य का एकमात्र स्रोत होना चाहिए और मॉड्यूल के बीच संदर्भ द्वारा पारित किया जाता है — class का उपयोग करें। यह स्थिति प्रबंधन पर लागू होता है, जहां एक स्थान पर ऑब्जेक्ट को बदलना सभी आश्रित घटकों में दिखाई देना चाहिए। SwiftUI में ObservableObject के लिए, क्लासेज़ अनिवार्य हैं।

// ObservableObject — SwiftUI के लिए class आवश्यक
import SwiftUI

class AppViewModel: ObservableObject {
    @Published var isLoggedIn: Bool = false
    @Published var username: String = ""

    func login(user: String) {
        isLoggedIn = true
        username = user
    }
}

// SwiftUI View में उपयोग
struct ContentView: View {
    @StateObject var viewModel = AppViewModel()

    var body: some View {
        Text(viewModel.isLoggedIn ? "स्वागत है" : "लॉगिन")
    }
}

नियम: यदि किसी ऑब्जेक्ट में पहचान (दो संदर्भ -> एक ऑब्जेक्ट) होनी चाहिए, एक एकल इंस्टेंस होना चाहिए, या UIKit/Objective-C के साथ काम करना चाहिए — class चुनें। यदि कोई ऑब्जेक्ट केवल डेटा रखता है — struct चुनें।