Swift: คืออะไร ไวยากรณ์และแนวคิดหลักของภาษา

Swift คืออะไร?

Swift เป็นภาษาโปรแกรมแบบหลายกระบวนทัศน์ที่พัฒนาโดย Apple สำหรับ iOS, macOS, watchOS, tvOS และ visionOS เป้าหมายหลักของภาษา: ความปลอดภัย ความเร็ว และความสามารถในการแสดงออกทางไวยากรณ์ Swift ใช้คอมไพเลอร์ LLVM และสร้างโค้ดเครื่องที่ปรับให้เหมาะสมซึ่งมีประสิทธิภาพเทียบเท่า C++

นับตั้งแต่เปิดตัวในปี 2014 Swift ผ่านมาแล้ว 6 เวอร์ชันหลัก Swift 6 (2024) นำเสนอโมเดลความปลอดภัยด้าน data race ที่สมบูรณ์ผ่านการควบคุมการแยกโค้ดพร้อมกันอย่างเข้มงวด ตามข้อมูลของ GitHub Octoverse 2025 Swift อยู่ใน 10 อันดับภาษาที่มีการเติบโตของชุมชนสูงที่สุด แซงหน้า Rust และ Kotlin ในความเร็วในการนำไปใช้บนแพลตฟอร์ม Apple

Swift เป็น โอเพนซอร์สและข้ามแพลตฟอร์ม — ซอร์สโค้ดเผยแพร่บน GitHub (Swift Open Source) นอกเหนือจากแพลตฟอร์ม Apple แล้ว Swift ยังใช้บน Linux และ Windows สำหรับการพัฒนาเซิร์ฟเวอร์ (Vapor, Hummingbird) แม้ว่าขอบเขตหลักยังคงเป็นการพัฒนามือถือและเดสก์ท็อปในระบบนิเวศของ Apple

ทำไม Swift จึงแทนที่ Objective-C

เหตุผลหลักสำหรับการเปลี่ยนแปลง: Swift กำจัดข้อผิดพลาดทั้งคลาสที่อาจเกิดขึ้นใน Objective-C ความปลอดภัยของชนิด ป้องกันความไม่เข้ากันของชนิดในขั้นตอนการคอมไพล์ Optionals กำจัดการอ้างอิง nil ARC ถูกสร้างไว้ตั้งแต่แรกเริ่ม แตกต่างจาก MRC/ARC ใน Objective-C ไวยากรณ์ของ Swift สั้นกว่าและอ่านง่ายกว่า — การศึกษาพบว่าปริมาณโค้ดลดลง 30-40% เมื่อเทียบกับ Objective-C สำหรับงานที่เทียบเท่ากัน

ไวยากรณ์และโครงสร้างพื้นฐาน

ไวยากรณ์พื้นฐานของ 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 — การไม่มี default ไม่ใช่ข้อผิดพลาดหากค่าที่เป็นไปได้ทั้งหมดครอบคลุมแล้ว

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 เป็น 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 กำหนดสัญญา — ชุดของคุณสมบัติและเมธod แตกต่างจากอินเทอร์เฟซ Java โปรโตคอลของ Swift สามารถมีการใช้งานเริ่มต้นผ่านส่วนขยายโปรโตคอล (protocol extensions) นี่คือพื้นฐานของการเขียนโปรแกรมเชิงโปรโตคอล แนวทางที่ Apple แนะนำแทนการสืบทอดคลาส

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

// การใช้งานเริ่มต้นผ่าน extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// การทำให้สอดคล้องผ่าน extension
extension String: NamedEntity {
    var name: String { return self }
}

ส่วนขยายโปรโตคอล ช่วยให้เพิ่มเมธอดลงในโปรโตคอลโดยไม่ต้องแก้ไขแต่ละชนิดที่ conform นี่มีประโยชน์อย่างยิ่งสำหรับการเพิ่มยูทิลิตี้ทั่วไป: map, filter, reduce สำหรับ Sequence หรือ Codable สำหรับการทำให้ JSON เป็นอนุกรม Apple สร้างเฟรมเวิร์กมากมาย (SwiftUI, Combine) บนโปรโตคอลพร้อมส่วนขยาย

คลูเซอร์และลูกโซ่เชิงฟังก์ชัน

คลูเซอร์ (Closures) ใน Swift เป็นฟังก์ชันนิรนามที่จับตัวแปรจากบริบทภายนอก ในเชิงไวยากรณ์ คลูเซอร์คล้ายกับแลมบ์ดาใน Kotlin แต่มีไวยากรณ์ที่ยืดหยุ่นกว่า: trailing closure, ชื่ออาร์กิวเมนต์แบบย่อ ($0, $1) และ autoclosures

// คลูเซอร์พร้อมการจับบริบท
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