Swift: यह क्या है, सिंटैक्स और भाषा की मुख्य अवधारणाएँ

Swift क्या है?

Swift एक बहु-प्रतिमान प्रोग्रामिंग भाषा है जिसे Apple द्वारा iOS, macOS, watchOS, tvOS और visionOS के लिए विकसित किया गया है। भाषा के मुख्य लक्ष्य: सुरक्षा, गति और सिंटैक्स की अभिव्यंजना। Swift LLVM कंपाइलर का उपयोग करती है और C++ के बराबर प्रदर्शन वाला अनुकूलित मशीन कोड उत्पन्न करती है।

2014 में रिलीज़ के बाद से Swift 6 प्रमुख संस्करणों से गुज़री है। Swift 6 (2024) ने समवर्ती कोड अलगाव के सख्त नियंत्रण के माध्यम से पूर्ण डेटा-रेस सुरक्षा मॉडल प्रस्तुत किया। GitHub Octoverse 2025 के अनुसार, Swift समुदाय की वृद्धि में शीर्ष 10 भाषाओं में है, जो Apple प्लेटफ़ॉर्म पर अपनाने की गति में Rust और Kotlin से आगे है।

Swift खुला और क्रॉस-प्लेटफ़ॉर्म है — स्रोत कोड GitHub (Swift Open Source) पर प्रकाशित है। Apple प्लेटफ़ॉर्म के अलावा, Swift का उपयोग Linux और Windows पर सर्वर-साइड डेवलपमेंट (Vapor, Hummingbird) के लिए किया जाता है, हालाँकि इसका मुख्य क्षेत्र Apple इकोसिस्टम में मोबाइल और डेस्कटॉप डेवलपमेंट है।

Swift ने Objective-C को क्यों बदला

संक्रमण के मुख्य कारण: Swift Objective-C में संभव त्रुटियों की पूरी श्रेणियों को समाप्त करती है। Type safety संकलन चरण में प्रकार बेमेल को रोकता है। Optionals nil डीरेफ़रेंसिंग को समाप्त करते हैं। ARC पहले दिन से निर्मित है, Objective-C में MRC/ARC के विपरीत। Swift का सिंटैक्स छोटा और अधिक पठनीय है — अध्ययन समतुल्य कार्यों के लिए Objective-C की तुलना में कोड की मात्रा में 30-40% की कमी दिखाते हैं।

सिंटैक्स और मूलभूत संरचनाएँ

मूलभूत Swift सिंटैक्स परिचित C-जैसी संरचनाओं को कार्यात्मक भाषाओं के तत्वों के साथ जोड़ता है। चर var के माध्यम से घोषित किए जाते हैं, स्थिरांक let के माध्यम से। कंपाइलर type inference का उपयोग करता है, इसलिए स्पष्ट प्रकार एनोटेशन केवल अस्पष्टता पर आवश्यक है।

import Foundation

// स्थिरांक और चर
let name = "Swift"
var version = 6.0
var count: Int = 42

// डिफ़ॉल्ट पैरामीटर वाले फ़ंक्शन
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// प्रारंभिक निकास के लिए Guard-let
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch और पैटर्न मैचिंग Swift में C और Kotlin से अधिक शक्तिशाली हैं। Switch टुपल्स, रेंज, where शर्तों और वैल्यू बाइंडिंग के साथ मिलान का समर्थन करता है। कंपाइलर सभी case की व्यापक कवरेज की जाँच करता है — डिफ़ॉल्ट का अभाव त्रुटि नहीं है यदि सभी संभावित मान कवर हैं।

let point = (x: 3, y: -1)

switch point {
case (0, 0):
    print("मूल बिंदु")
case let (x, y) where x == y:
    print("X, Y के बराबर है")
case let (x, y) where abs(y) > x:
    print("Y का निरपेक्ष मान X से बड़ा है")
default:
    print("बिंदु (\(point.x), \(point.y))"point.x), \(point.y))")
}

Optionals और nil के साथ सुरक्षित कार्य

Optionals Swift की एक केंद्रीय अवधारणा है जो प्रकार प्रणाली के स्तर पर null संदर्भ समस्या को हल करती है। Optional दो case वाला enum है: .none (nil) और .some(Wrapped)। कंपाइलर स्पष्ट जाँच के बिना Optional का उपयोग करने से रोकता है, जो रनटाइम त्रुटियों की एक पूरी श्रेणी को समाप्त करता है।

var optionalString: String? = "Hello"
optionalString = nil  // अनुमति है

// Optional Binding — सुरक्षित निष्कर्षण
if let text = optionalString {
    print("टेक्स्ट: \(text)"text)")
} else {
    print("मान अनुपस्थित")
}

// Optional Chaining — गुणों तक सुरक्षित पहुँच
let length = optionalString?.count ?? 0

// Nil-coalescing ऑपरेटर
let greeting = optionalString ?? "Default"

Optional Chaining ऑपरेटर ?. के साथ वैकल्पिक मान के गुणों तक सुरक्षित रूप से विधियों को कॉल करने और एक्सेस करने की अनुमति देता है। यदि श्रृंखला nil से टूट जाती है, तो पूरे व्यंजक का परिणाम nil होता है। Nil-coalescing (??) एक डिफ़ॉल्ट मान प्रदान करता है और प्लेसहोल्डर टेक्स्ट प्रदर्शित करने के लिए UI कोड में व्यापक रूप से उपयोग किया जाता है।

प्रोटोकॉल और एक्सटेंशन

प्रोटोकॉल Swift में एक अनुबंध परिभाषित करते हैं — गुणों और विधियों का एक सेट। Java इंटरफ़ेस के विपरीत, Swift प्रोटोकॉल में protocol extensions के माध्यम से डिफ़ॉल्ट कार्यान्वयन हो सकते हैं। यह प्रोटोकॉल-उन्मुख प्रोग्रामिंग का आधार है, जो क्लास इनहेरिटेंस के बजाय Apple का अनुशंसित दृष्टिकोण है।

protocol NamedEntity {
    var name: String { get }
    func description() -> String
}

// एक्सटेंशन के माध्यम से डिफ़ॉल्ट कार्यान्वयन
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// एक्सटेंशन के माध्यम से अनुरूपता
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions प्रत्येक अनुरूप प्रकार को संशोधित किए बिना प्रोटोकॉल में विधियाँ जोड़ने की अनुमति देते हैं। यह सामान्य उपयोगिताओं को जोड़ने के लिए विशेष रूप से उपयोगी है: Sequence के लिए map, filter, reduce, या JSON क्रमांकन के लिए Codable। Apple ने कई फ्रेमवर्क (SwiftUI, Combine) को एक्सटेंशन के साथ प्रोटोकॉल पर बनाया।

क्लोज़र और कार्यात्मक श्रृंखलाएँ

क्लोज़र (Closures) Swift में अनाम फ़ंक्शन हैं जो बाहरी संदर्भ से चर कैप्चर करते हैं। सिंटैक्टिक रूप से, क्लोज़र Kotlin में lambdas के समान हैं लेकिन अधिक लचीले सिंटैक्स के साथ: trailing closure, संक्षिप्त तर्क नाम ($0, $1) और ऑटोक्लोज़र।

// संदर्भ कैप्चर के साथ क्लोज़र
let numbers = [5, 3, 8, 1, 9]

// Trailing closure syntax
let sorted = numbers.sorted { $0 < $1 }

// कार्यात्मक श्रृंखला
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// फ़ंक्शन पैरामीटर के रूप में क्लोज़र
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping क्लोज़र का उपयोग तब किया जाता है जब क्लोज़र फ़ंक्शन से वापसी के बाद निष्पादित होता है — आमतौर पर नेटवर्क अनुरोधों और अतुल्यकालिक संचालन के लिए। @autoclosure स्वचालित रूप से एक व्यंजक को क्लोज़र में लपेटता है, जिसका उपयोग assert और शॉर्ट-सर्किट लॉजिक में किया जाता है।

स्ट्रक्चर और क्लास: तुलना

struct और class के बीच चयन Swift मॉडल डिज़ाइन करते समय पहले निर्णयों में से एक है। Apple डिफ़ॉल्ट रूप से struct (मान-प्रकार) का उपयोग करने और केवल इनहेरिटेंस या संदर्भ पहचान की आवश्यकता होने पर class (संदर्भ-प्रकार) पर स्विच करने की अनुशंसा करता है।

मान-प्रकार (struct) बहु-थ्रेडेड वातावरण में अधिक सुरक्षित हैं — प्रत्येक थ्रेड को एक स्वतंत्र प्रतिलिपि मिलती है। संदर्भ-प्रकार (class) UIKit (UIView, UIViewController) के साथ काम करने के लिए आवश्यक हैं, जहाँ संदर्भ पहचान और सिस्टम क्लास से इनहेरिटेंस की आवश्यकता होती है।

ARC मेमोरी प्रबंधन

ARC (Automatic Reference Counting) संदर्भ-प्रकारों के लिए Swift की मेमोरी प्रबंधन प्रणाली है। कंपाइलर रनटाइम में retain/release कॉल सम्मिलित करता है, किसी ऑब्जेक्ट पर मजबूत संदर्भों की संख्या को ट्रैक करता है। जब काउंटर शून्य तक पहुँचता है, तो ऑब्जेक्ट तुरंत मुक्त हो जाता है।

ARC की मुख्य समस्या retain cycles (चक्रीय संदर्भ) है। जब दो ऑब्जेक्ट एक-दूसरे पर मजबूत संदर्भ रखते हैं, तो मेमोरी कभी मुक्त नहीं होती। समाधान weak संदर्भ (मुक्त होने पर स्वचालित रूप से nil हो जाते हैं) और unowned संदर्भ (गारंटी देते हैं कि ऑब्जेक्ट जीवित है) हैं।

class ProfileViewController: UIViewController {
    var onLogout: (() -> Void)?
    
    func setupHandler() {
        // [weak self] retain cycle को रोकता है
        onLogout = { [weak self] in
            guard let self else { return }
            self.dismiss(animated: true)
        }
    }
}

क्लोज़र में retain cycles को रोकने के लिए, [weak self] का उपयोग guard let self = self else { return } के साथ करें। यह नियम UIKit में विशेष रूप से महत्वपूर्ण है, जहाँ ViewController अपने गुणों पर मजबूत संदर्भ रखता है, और उन गुणों के अंदर क्लोज़र ViewController को संदर्भित करते हैं।