Swift: ano ito, syntax at mga pangunahing konsepto ng wika

Ano ang Swift?

Swift — isang multi-paradigm programming language na binuo ng Apple para sa iOS, macOS, watchOS, tvOS at visionOS. Ang mga pangunahing layunin ng wika: kaligtasan, bilis at pagpapahayag ng syntax. Gumagamit ang Swift ng LLVM compiler at bumubuo ng optimized machine code, maihahambing sa pagganap sa C++.

Mula nang ilabas noong 2014, ang Swift ay dumaan sa 6 na pangunahing bersyon. Ipinakilala ng Swift 6 (2024) ang kumpletong modelo ng data-race safety sa pamamagitan ng mahigpit na kontrol ng isolation ng concurrent code. Ayon sa GitHub Octoverse 2025, ang Swift ay nasa top-10 na wika sa paglago ng komunidad, na higit sa Rust at Kotlin sa bilis ng pag-aampon sa mga platform ng Apple.

Ang Swift ay bukas at cross-platform — ang source code ay nai-publish sa GitHub (Swift Open Source). Bukod sa mga platform ng Apple, ginagamit ang Swift sa Linux at Windows para sa server development (Vapor, Hummingbird), bagaman ang pangunahing lugar ng aplikasyon ay nananatiling mobile at desktop development sa ecosystem ng Apple.

Bakit pinalitan ng Swift ang Objective-C

Pangunahing dahilan ng paglipat: Inaalis ng Swift ang buong klase ng mga error na posible sa Objective-C. Pinipigilan ng Type safety ang hindi pagkakatugma ng uri sa yugto ng compilation. Ang Optionals ay nag-aalis ng mga nil-dereference. Ang ARC ay isinama mula sa unang araw, hindi katulad ng MRC/ARC sa Objective-C. Ang syntax ng Swift ay mas maikli at mas nababasa — ipinapakita ng pananaliksik ang pagbawas ng dami ng code ng 30-40% kumpara sa Objective-C para sa mga katulad na gawain.

Syntax at mga pangunahing konstruksyon

Ang pangunahing syntax ng Swift ay pinagsasama ang pamilyar na mga konstruksyong tulad ng C sa mga elemento ng functional na wika. Ang mga variable ay idineklara sa pamamagitan ng var, mga constant sa pamamagitan ng let. Gumagamit ang compiler ng type inference, kaya ang tahasang pagtukoy ng uri ay kinakailangan lamang sa kalabuan.

import Foundation

// Mga constant at variable
let name = "Swift"
var version = 6.0
var count: Int = 42

// Mga function na may default na parameter
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let para sa maagang paglabas
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch at pattern matching sa Swift ay mas malakas kaysa sa C at Kotlin. Sinusuportahan ng Switch ang pagtutugma sa mga tuple, range, where condition at binding ng mga halaga. Sinusuri ng compiler ang malawak na saklaw ng lahat ng case — ang kawalan ng default ay hindi isang error kung ang lahat ng posibleng halaga ay nasasaklaw.

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

switch point {
case (0, 0):
    print("Punto ng pinagmulan")
case let (x, y) where x == y:
    print("X ay katumbas ng Y")
case let (x, y) where abs(y) > x:
    print("Y ay mas malaki kaysa sa X modulo")
default:
    print("Punto (\( point.x), \(point.y))")
}

Optionals at ligtas na pagtatrabaho sa nil

Optionals — ang sentral na konsepto ng Swift, na lumulutas sa problema ng null-reference sa antas ng sistema ng uri. Ang Optional<Wrapped> ay isang enum na may dalawang case: .none (nil) at .some(Wrapped). Ipinagbabawal ng compiler ang paggamit ng Optional nang walang tahasang pagsusuri, na nag-aalis ng buong klase ng runtime error.

var optionalString: String? = "Hello"
optionalString = nil  // pinapayagan

// Optional Binding — ligtas na pagkuha
if let text = optionalString {
    print("Teksto: \( text)")
} else {
    print("Walang halaga")
}

// Optional Chaining — ligtas na pag-access sa mga pag-aari
let length = optionalString?.count ?? 0

// Nil-coalescing operator
let greeting = optionalString ?? "Default"

Optional Chaining gamit ang ?. operator ay nagbibigay-daan sa ligtas na pagtawag ng mga pamamaraan at pag-access sa mga katangian ng isang opsyonal na halaga. Kung ang chain ay nagambala ng nil, ang resulta ng buong expression ay nil. Ang Nil-coalescing (??) ay nagbibigay ng default na halaga at malawakang ginagamit sa UI code para sa pagpapakita ng placeholder text.

Mga protocol at extension

Protocols sa Swift ay tumutukoy sa isang kontrata — isang set ng mga pag-aari at pamamaraan. Hindi tulad ng mga interface ng Java, ang Swift protocols ay maaaring magkaroon ng mga default na pagpapatupad sa pamamagitan ng protocol extensions. Ito ang batayan ng Protocol-Oriented Programming, ang inirerekomendang approach ng Apple sa halip na class inheritance.

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

// Default na pagpapatupad sa pamamagitan ng extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Pagsunod sa pamamagitan ng extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions ay nagpapahintulot sa pagdaragdag ng mga pamamaraan sa isang protocol nang hindi binabago ang bawat sumusunod na uri. Ito ay lalong kapaki-pakinabang para sa pagdaragdag ng mga karaniwang utility: map, filter, reduce para sa Sequence, o Codable para sa JSON serialization. Itinayo ng Apple ang maraming frameworks (SwiftUI, Combine) sa mga protocol na may mga extension.

Mga closure at functional chain

Closures sa Swift — mga anonymous function na kumukuha ng mga variable mula sa panlabas na konteksto. Sa syntax, ang closures ay katulad ng lambda sa Kotlin, ngunit may mas nababaluktot na syntax: trailing closure, shorthand argument names ($0, $1) at autoclosures.

// Closure na may pag-capture ng konteksto
let numbers = [5, 3, 8, 1, 9]

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

// Functional chain
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure bilang parameter ng function
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping closures ay ginagamit kapag ang closure ay isinasagawa pagkatapos bumalik mula sa function — karaniwan para sa mga network request at asynchronous operations. Ang @autoclosure ay awtomatikong bumabalot ng expression sa isang closure, na ginagamit sa assert at short-circuit logic.

Struct at Class: paghahambing

Ang pagpili sa pagitan ng struct at class — isa sa mga unang desisyon kapag nagdidisenyo ng modelo ng Swift. Inirerekomenda ng Apple na gamitin ang struct bilang default (value-type) at lumipat sa class (reference-type) lamang kapag kinakailangan ang mana o pagkakakilanlan sa pamamagitan ng reference.

Value-types (struct) ay mas ligtas sa multi-thread na kapaligiran — bawat thread ay nakakakuha ng independiyenteng kopya. Reference-types (class) ay kinakailangan para sa pagtatrabaho sa UIKit (UIView, UIViewController), kung saan kinakailangan ang reference identity at mana mula sa mga system class.

Pamamahala ng memorya ARC

ARC (Automatic Reference Counting) — ang sistema ng pamamahala ng memorya ng Swift para sa reference-types. Ang compiler ay naglalagay ng retain/release sa runtime, sinusubaybayan ang bilang ng malalakas na reference sa isang object. Kapag ang bilang ay umabot sa zero, ang object ay agad na pinalaya.

Ang pangunahing problema ng ARC — retain cycles (siklikong mga reference). Kapag ang dalawang object ay may malalakas na reference sa isa't isa, ang memorya ay hindi pinalaya. Ang solusyon — weak reference (awtomatikong nagiging nil kapag pinalaya) at unowned reference (ginagarantiya na ang object ay buhay).

class ProfileViewController: UIViewController {
    var onLogout: (() -> Void)?
    
    func setupHandler() {
        // [weak self] ay pumipigil sa retain cycle
        onLogout = { [weak self] in
            guard let self else { return }
            self.dismiss(animated: true)
        }
    }
}

Upang maiwasan ang retain cycles sa closures, gamitin ang [weak self] na may guard let self = self else { return }. Ang patakarang ito ay lalong mahalaga sa UIKit, kung saan ang ViewController ay may malalakas na reference sa kanyang mga pag-aari, at ang mga closure sa loob ng mga pag-aaring ito ay tumutukoy sa ViewController.