موبائل ڈیولپمنٹ میں 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 کی معیاری لائبریری فعال طور پر Generics استعمال کرتی ہے: 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 کلومیٹر/گھنٹہ کی رفتار سے پرواز" — اوور رائڈ

Extension کے ساتھ POP متعدد پروٹوکولز کے ذریعے ترکیب کو قابل بناتا ہے — ایک قسم متعدد پروٹوکولز کی تعمیل کر سکتی ہے، ان کے نفاذ حاصل کر سکتی ہے۔ یہ واحد کلاس کی وراثت سے زیادہ لچکدار ہے جہاں پورا درجہ بندی طے شدہ ہے۔ 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) kbps"
        }
    }
}

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"

منسلک اقدار + Extension کے ساتھ Enum Kotlin کے مہربند کلاسز یا دوسری زبانوں کے امتیازی یونینز کا متبادل ہے۔ Swift اس امتزاج کو Result (معیاری لائبریری میں ایک معیاری قسم)، Optional (Optional .none اور .some کے ساتھ ایک enum ہے) اور SwiftUI میں حالت کے انتظام کے لیے استعمال کرتا ہے۔ پیٹرن میچنگ ضمانت دیتا ہے کہ تمام حالتیں ہینڈل کی گئی ہیں — رن ٹائم کی غلطیاں ناممکن ہیں۔