मोबाइल डेवलपमेंट में Swift विशिष्टताएँ: यह क्या है, मुख्य विशेषताएँ और यह कैसे काम करता है

Swift में Struct vs Class: मान प्रकार और संदर्भ प्रकार

Swift में, struct एक मान प्रकार है, जबकि class एक संदर्भ प्रकार है। यह मूलभूत अंतर असाइनमेंट, फ़ंक्शन में पास करने और मेमोरी प्रबंधन के दौरान व्यवहार निर्धारित करता है। प्रत्येक असाइनमेंट पर Struct पूरी तरह से कॉपी होता है, class संदर्भ द्वारा पास किया जाता है — केवल हीप ऑब्जेक्ट का पॉइंटर कॉपी होता है।

Struct की मान शब्दार्थ

Struct स्वचालित रूप से मान शब्दार्थ लागू करता है — प्रत्येक इंस्टेंस स्वतंत्र है। Struct गुण का उत्परिवर्तन केवल var के माध्यम से संभव है, और गुणों को संशोधित करने वाली विधियों को mutating चिह्नित किया जाना चाहिए। Struct वंशानुक्रम का समर्थन नहीं करता但 प्रोटोकॉल का अनुपालन कर सकता है। Swift की मानक लाइब्रेरी String, Array, Dictionary, Int, Bool के लिए struct का उपयोग करती है — सभी मूलभूत प्रकार मान प्रकार हैं।

struct User {
    let id: Int
    var name: String

    mutating func updateName(_ newName: String) {
        name = newName
    }
}

var user1 = User(id: 1, name: "Alice")
var user2 = user1
user2.updateName("Bob")
// user1.name === "Alice", user2.name === "Bob"
// पूर्ण प्रतिलिपि — स्वतंत्र इंस्टेंस

Class की संदर्भ शब्दार्थ

Class हीप में संग्रहीत होता है और संदर्भ समानता का समर्थन करता है। कई चर एक ही ऑब्जेक्ट को संदर्भित कर सकते हैं, एक संदर्भ के माध्यम से परिवर्तन सभी अन्य के माध्यम से दिखाई देते हैं। Class वंशानुक्रम का समर्थन करता है, विधि ओवरराइडिंग (override) की अनुमति देता है, संसाधन सफाई के लिए deinit रखता है। Swift में, struct की तुलना में class का कम उपयोग किया जाता है — Apple struct से शुरू करने और केवल जब वंशानुक्रम या संदर्भ शब्दार्थ की आवश्यकता हो तो class पर स्विच करने की सलाह देता है।

class Car {
    let model: String
    var speed: Int

    init(model: String, speed: Int) {
        self.model = model
        self.speed = speed
    }

    func accelerate(_ amount: Int) {
        speed += amount
    }
}

let car1 = Car(model: "Tesla", speed: 0)
let car2 = car1
car2.accelerate(50)
// car1.speed === 50, car2.speed === 50
// एक ही संदर्भ — परिवर्तन हर जगह दिखाई देते हैं

struct और class के बीच चुनाव डेटा शब्दार्थ पर निर्भर करता है। कॉन्फ़िगरेशन, डेटा मॉडल और स्थितियों के लिए struct का उपयोग करें — प्रतिलिपि बनाना अधिक सुरक्षित और पूर्वानुमानित है। पहचान वाली वस्तुओं (उपयोगकर्ता सत्र, डेटाबेस कनेक्शन) और जब वंशानुक्रम की आवश्यकता हो, class का उपयोग करें।

Actor — Swift में थ्रेड सुरक्षा

Actor एक संदर्भ प्रकार है जो अपनी परिवर्तनीय स्थिति को समवर्ती पहुँच से बचाता है। Swift कंपाइलर गारंटी देता है कि actor चर तक केवल उसी actor संदर्भ से पहुँचा जा सकता है — कोई भी बाहरी पहुँच संकलन त्रुटि का कारण बनती है। यह मैन्युअल लॉक के बिना भाषा स्तर पर डेटा दौड़ को रोकता है।

Actor अलगाव

सभी actor गुण और विधियाँ डिफ़ॉल्ट रूप से पृथक हैं। बाहर से actor विधि को कॉल करने के लिए await की आवश्यकता है — Swift निष्पादन को actor पर स्विच करता है और वापस। Actor अनुक्रमिक रूप से पहुँच को सिंक्रनाइज़ करता है: विभिन्न कार्यों से अनुरोध कतारबद्ध होते हैं। यह actor के अंदर सुसंगत स्थिति सुनिश्चित करता है। गैर-पृथक विधियाँ (nonisolated) को await के बिना कॉल किया जा सकता है लेकिन वे परिवर्तनीय गुणों तक नहीं पहुँच सकतीं।

actor BankAccount {
    private var balance: Double

    init(initialBalance: Double) {
        balance = initialBalance
    }

    func deposit(amount: Double) {
        balance += amount
    }

    func withdraw(amount: Double) throws {
        guard balance >= amount else {
            throw BankError.insufficientFunds
        }
        balance -= amount
    }

    nonisolated func accountInfo() -> String {
        return "बैंक खाता"
    }
}

let account = BankAccount(initialBalance: 1000)
await account.deposit(amount: 500)
// balance = 1500 — परमाणु, बिना दौड़ की स्थिति के

Actor स्थिति प्रबंधकों, कैश और नेटवर्क सेवाओं के लिए उपयोगी है जहाँ कई कार्य समवर्ती रूप से डेटा पढ़ते और लिखते हैं। NSLock या DispatchQueue के माध्यम से मैन्युअल सिंक्रनाइज़ेशन के विपरीत, actor संकलन समय पर जाँचा जाता है — गलती करना असंभव है। अलगाव त्रुटियाँ संकलन समय पर दिखाई देती हैं, रनटाइम पर नहीं।

Property Wrappers: @Published, @State, @Binding

Property Wrapper एक एनोटेशन है जो किसी गुण की घोषणा को बदले बिना उसमें व्यवहार जोड़ता है। SwiftUI और Combine दृश्य स्थिति प्रबंधन के लिए अंतर्निहित रैपर प्रदान करते हैं। कंपाइलर कोड उत्पन्न करता है जो गुण पहुँच को लपेटता है, अवलोकन, सिंक्रनाइज़ेशन या परिवर्तन तर्क जोड़ता है।

@Published और @State

@Published का उपयोग ObservableObject का अनुपालन करने वाली कक्षाओं में स्वचालित रूप से परिवर्तन प्रकाशित करने के लिए किया जाता है। Combine सब्सक्राइबर प्रत्येक अद्यतन पर सूचनाएँ प्राप्त करते हैं। @State SwiftUI दृश्य की स्थानीय स्थिति है। @State बदलने पर SwiftUI स्वचालित रूप से दृश्य को पुनः रेंडर करता है। @Binding डेटा के स्वामित्व के बिना मूल और चाइल्ड दृश्य के बीच द्विदिश संबंध बनाता है।

import SwiftUI
import Combine

@main
struct CounterApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

class CounterViewModel: ObservableObject {
    @Published var count: Int = 0

    func increment() {
        count += 1
    }
}

struct ContentView: View {
    @State private var greeting: String = "नमस्ते"
    @StateObject private var viewModel = CounterViewModel()

    var body: some View {
        VStack {
            CounterDisplay(count: $viewModel.count)
            Text(greeting)
            Button("बढ़ाएँ", action: viewModel.increment)
        }
    }
}

struct CounterDisplay: View {
    @Binding var count: Int

    var body: some View {
        Text("गिनती: \(count)")
    }
}

कस्टम Property Wrappers @propertyWrapper और wrappedValue फ़ील्ड वाली संरचना के माध्यम से बनाए जाते हैं। यह तर्क के पुन: उपयोग की अनुमति देता है: सत्यापन, सामान्यीकरण, UserDefaults संग्रहण। Property Wrappers बॉयलरप्लेट कोड को काफी कम करते हैं और एनोटेशन के माध्यम से डेवलपर के इरादे को स्पष्ट करते हैं।

@propertyWrapper
struct Clamped<T: Comparable> {
    private var value: T
    let range: ClosedRange<T>

    init(wrappedValue: T, range: ClosedRange<T>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }

    var wrappedValue: T {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
}

struct Settings {
    @Clamped(range: 0...100) var volume: Int = 50
}

var s = Settings()
s.volume = 150
// s.volume === 100 — मान स्वचालित रूप से सीमित

Generics और प्रोटोकॉल उन्मुख प्रोग्रामिंग

Generics प्रकार सुरक्षा खोए बिना लचीला कोड लिखने के लिए Swift का एक शक्तिशाली तंत्र है। जेनेरिक फ़ंक्शन और प्रकार बाधाओं को पूरा करने वाले किसी भी प्रकार के साथ काम करते हैं। प्रोटोकॉल उन्मुख प्रोग्रामिंग (POP) एक Swift प्रतिमान है जहाँ protocol + extension शास्त्रीय वर्ग वंशानुक्रम को बदलते हैं, व्यवहार संरचना प्रदान करते हैं।

जेनेरिक बाधाएँ और संबद्ध प्रकार

Swift प्रोटोकॉल (where खंड) के साथ जेनेरिक पैरामीटर को प्रतिबंधित करने की अनुमति देता है। संबद्ध प्रकार वाला प्रोटोकॉल प्रोटोकॉल के लिए जेनेरिक समकक्ष है: ठोस प्रकार अनुपालन के समय निर्धारित होता है। यह प्रकार-सुरक्षित संग्रह और एल्गोरिदम की नींव है। Swift की मानक लाइब्रेरी सक्रिय रूप से जेनेरिक का उपयोग करती है: Array, Dictionary, Optional — सभी जेनेरिक प्रकार हैं।

protocol Cacheable {
    associatedtype Key: Hashable
    associatedtype Value

    func get(_ key: Key) -> Value?
    mutating func set(_ value: Value, for key: Key)
}

struct MemoryCache<K: Hashable, V>: Cacheable {
    private var storage: [K: V] = [:]

    typealias Key = K
    typealias Value = V

    func get(_ key: K) -> V? {
        return storage[key]
    }

    mutating func set(_ value: V, for key: K) {
        storage[key] = value
    }
}

func firstMatch<T: Equatable>(in array: [T], target: T) -> Int? {
    for (index, item) in array.enumerated() {
        if item == target {
            return index
        }
    }
    return nil
}

let numbers = [10, 20, 30, 40]
let index = firstMatch(in: numbers, target: 30)
// index === 2 — सभी Equatable प्रकारों के लिए एक जेनेरिक विधि

प्रोटोकॉल Extension और डिफ़ॉल्ट कार्यान्वयन

प्रोटोकॉल extension POP का एक मुख्य तंत्र है। extension में प्रोटोकॉल विधियों के डिफ़ॉल्ट कार्यान्वयन प्रदान किए जा सकते हैं। प्रोटोकॉल का अनुपालन करने वाले प्रकार इस कार्यान्वयन को मुफ्त में प्राप्त करते हैं और आवश्यकता पड़ने पर इसे ओवरराइड कर सकते हैं। यह वर्ग वंशानुक्रम के बिना व्यवहार पदानुक्रम बनाने की अनुमति देता है — एकाधिक वंशानुक्रम का विकल्प, जो Swift में उपलब्ध नहीं है।

protocol Drivable {
    var speed: Double { get set }
    func drive()
}

extension Drivable {
    func drive() {
        if speed > 0 {
            print("\(speed) किमी/घंटा की गति से ड्राइविंग")
        }
    }
}

struct Bicycle: Drivable {
    var speed: Double = 15
}

struct Plane: Drivable {
    var speed: Double = 900

    func drive() {
        print("\(speed) किमी/घंटा की गति से उड़ान")
    }
}

let bike = Bicycle()
bike.drive() // "15.0 किमी/घंटा की गति से ड्राइविंग" — डिफ़ॉल्ट

let plane = Plane()
plane.drive() // "900.0 किमी/घंटा की गति से उड़ान" — ओवरराइड

POP extension के साथ एकाधिक प्रोटोकॉल के माध्यम से संरचना सक्षम करता है — एक प्रकार कई प्रोटोकॉल का अनुपालन कर सकता है, उनके कार्यान्वयन प्राप्त कर सकता है। यह एकल वर्ग वंशानुक्रम की तुलना में अधिक लचीला है जहाँ संपूर्ण पदानुक्रम निश्चित है। Swift की मानक लाइब्रेरी POP पर बनी है: CustomStringConvertible, Equatable, Hashable, Codable — सभी extensions वाले प्रोटोकॉल हैं।

संबद्ध मानों और Extension के साथ Enum

Enum Swift में अन्य भाषाओं की तुलना में काफी अधिक शक्तिशाली निर्माण है। प्रत्येक केस में संबद्ध मान हो सकते हैं — किसी भी प्रकार के डेटा का एक मनमाना सेट। extension और पैटर्न मिलान के संयोजन में, enum अवस्थाओं, संचालन परिणामों और परिमित अवस्था मशीनों के मॉडलिंग की नींव बन जाता है।

संबद्ध मान और पैटर्न मिलान

संबद्ध मान प्रत्येक केस को अद्वितीय डेटा संग्रहीत करने की अनुमति देते हैं। उदाहरण के लिए, loading केस में कोई डेटा नहीं है, success में परिणाम है, failure में त्रुटि है। switch के माध्यम से पैटर्न मिलान संबद्ध मान निकालता है और प्रत्येक केस को संभालता है। कंपाइलर व्यापकता की जाँच करता है (exhaustive switch) — यह भूली हुई अवस्थाओं को समाप्त करता है।

enum NetworkResult<T> {
    case loading
    case success(T)
    case failure(Error)
}

enum MediaFile {
    case image(url: URL, width: Int, height: Int)
    case video(url: URL, duration: Double)
    case audio(url: URL, bitrate: Int)
}

func handle(_ result: NetworkResult<String>) {
    switch result {
    case .loading:
        print("लोड हो रहा है...")
    case .success(let data):
        print("प्राप्त: \(data)")
    case .failure(let error):
        print("त्रुटि: \(error.localizedDescription)")
    }
}

let file = MediaFile.video(url: URL(string: "https://example.com/video.mp4")!, duration: 120)

if case .video(let url, let duration) = file {
    print("वीडियो \(url) अवधि \(duration) सेकंड")
}

Enum के लिए Extension

Swift enum के लिए extension के माध्यम से विधियाँ, परिकलित गुण और प्रोटोकॉल अनुपालन जोड़ने की अनुमति देता है। इसके लिए मूल घोषणा को बदलने की आवश्यकता नहीं है — कोड साफ और मॉड्यूलर रहता है। extension में विधियाँ संबद्ध मानों के साथ काम कर सकती हैं, व्युत्पन्न डेटा की गणना कर सकती हैं और व्यावसायिक तर्क लागू कर सकती हैं।

extension MediaFile {
    var fileName: String {
        switch self {
        case .image(let url, _, _),
             .video(let url, _),
             .audio(let url, _):
            return url.lastPathComponent
        }
    }

    var description: String {
        switch self {
        case .image(_, let w, let h):
            return "छवि \(w)x\(h)"
        case .video(_, let d):
            return "वीडियो \(d)से"
        case .audio(_, let b):
            return "ऑडियो \(b) केबीपीएस"
        }
    }
}

extension MediaFile: Equatable {
    static func == (lhs: MediaFile, rhs: MediaFile) -> Bool {
        return lhs.fileName == rhs.fileName
    }
}

let files: [MediaFile] = [file]
files.forEach { print($0.description) }
// "वीडियो 120.0s"

संबद्ध मानों के साथ Enum + extension Kotlin से सीलबंद कक्षाओं या अन्य भाषाओं से विभेदित यूनियनों का प्रतिस्थापन है। Swift इस संयोजन का उपयोग Result (मानक लाइब्रेरी में एक मानक प्रकार), Optional (Optional .none और .some के साथ एक enum है) और SwiftUI में स्थिति प्रबंधन के लिए करती है। पैटर्न मिलान गारंटी देता है कि सभी स्थितियों को संभाला गया है — रनटाइम त्रुटियाँ असंभव हैं।