Swift: nó là gì, cú pháp và các khái niệm chính của ngôn ngữ

Swift là gì?

Swift là ngôn ngữ lập trình đa mô hình được Apple phát triển cho iOS, macOS, watchOS, tvOS và visionOS. Các mục tiêu chính của ngôn ngữ: an toàn, tốc độ và khả năng biểu đạt cú pháp. Swift sử dụng trình biên dịch LLVM và tạo mã máy tối ưu, có hiệu suất tương đương C++.

Kể từ khi phát hành năm 2014, Swift đã trải qua 6 phiên bản chính. Swift 6 (2024) đã giới thiệu mô hình an toàn dữ liệu toàn diện thông qua kiểm soát chặt chẽ việc cô lập mã đồng thời. Theo GitHub Octoverse 2025, Swift nằm trong top 10 ngôn ngữ có tốc độ tăng trưởng cộng đồng, vượt qua Rust và Kotlin về tốc độ áp dụng trên các nền tảng Apple.

Swift là mã nguồn mở và đa nền tảng — mã nguồn được công bố trên GitHub (Swift Open Source). Ngoài các nền tảng Apple, Swift còn được sử dụng trên Linux và Windows để phát triển phía máy chủ (Vapor, Hummingbird), mặc dù lĩnh vực chính vẫn là phát triển di động và máy tính để bàn trong hệ sinh thái Apple.

Tại sao Swift thay thế Objective-C

Những lý do chính cho sự chuyển đổi: Swift loại bỏ toàn bộ các lớp lỗi có thể xảy ra trong Objective-C. An toàn kiểu ngăn chặn sự không tương thích kiểu tại thời điểm biên dịch. Optionals loại bỏ việc giải tham chiếu nil. ARC được tích hợp ngay từ ngày đầu tiên, không giống như MRC/ARC trong Objective-C. Cú pháp Swift ngắn hơn và dễ đọc hơn — các nghiên cứu cho thấy khối lượng mã giảm 30-40% so với Objective-C cho các tác vụ tương đương.

Cú pháp và cấu trúc cơ bản

Cú pháp Swift cơ bản kết hợp các cấu trúc quen thuộc giống C với các yếu tố từ ngôn ngữ hàm. Biến được khai báo bằng var, hằng số bằng let. Trình biên dịch sử dụng suy luận kiểu, do đó chú thích kiểu tường minh chỉ cần thiết khi có sự mơ hồ.

import Foundation

// Hằng số và biến
let name = "Swift"
var version = 6.0
var count: Int = 42

// Hàm với tham số mặc định
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let để thoát sớm
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch và so khớp mẫu trong Swift mạnh hơn trong C và Kotlin. Switch hỗ trợ so khớp với tuple, phạm vi, điều kiện where và ràng buộc giá trị. Trình biên dịch kiểm tra phạm vi bao phủ toàn diện tất cả các trường hợp — việc thiếu default không phải là lỗi nếu tất cả các giá trị có thể đều được bao phủ.

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

switch point {
case (0, 0):
    print("Gốc tọa độ")
case let (x, y) where x == y:
    print("X bằng Y")
case let (x, y) where abs(y) > x:
    print("Giá trị tuyệt đối của Y lớn hơn X")
default:
    print("Điểm (\(point.x), \(point.y))")
}

Optionals và làm việc an toàn với nil

Optionals là khái niệm trung tâm của Swift giải quyết vấn đề tham chiếu null ở cấp độ hệ thống kiểu. Optional là một enum với hai trường hợp: .none (nil) và .some(Wrapped). Trình biên dịch cấm sử dụng Optional mà không kiểm tra tường minh, loại bỏ toàn bộ một lớp lỗi thời gian chạy.

var optionalString: String? = "Hello"
optionalString = nil  // được phép

// Optional Binding — giải nén an toàn
if let text = optionalString {
    print("Văn bản: \(text)")
} else {
    print("Giá trị không tồn tại")
}

// Optional Chaining — truy cập thuộc tính an toàn
let length = optionalString?.count ?? 0

// Toán tử nil-coalescing
let greeting = optionalString ?? "Default"

Optional Chaining với toán tử ?. cho phép gọi phương thức và truy cập thuộc tính của giá trị tùy chọn một cách an toàn. Nếu chuỗi bị gián đoạn bởi nil, kết quả của toàn bộ biểu thức là nil. Nil-coalescing (??) cung cấp giá trị mặc định và được sử dụng rộng rãi trong mã UI để hiển thị văn bản giữ chỗ.

Giao thức và mở rộng

Giao thức trong Swift định nghĩa một hợp đồng — một tập hợp các thuộc tính và phương thức. Không giống như interface Java, giao thức Swift có thể có triển khai mặc định thông qua mở rộng giao thức (protocol extensions). Đây là nền tảng của Lập trình Hướng Giao thức, cách tiếp cận được Apple khuyến nghị thay vì kế thừa lớp.

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

// Triển khai mặc định qua extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Tuân thủ qua extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions cho phép thêm phương thức vào giao thức mà không cần sửa đổi mỗi kiểu tuân thủ. Điều này đặc biệt hữu ích để thêm các tiện ích chung: map, filter, reduce cho Sequence, hoặc Codable cho tuần tự hóa JSON. Apple đã xây dựng nhiều framework (SwiftUI, Combine) trên các giao thức với mở rộng.

Bao đóng và chuỗi hàm

Bao đóng (Closures) trong Swift là các hàm ẩn danh chụp các biến từ ngữ cảnh bên ngoài. Về mặt cú pháp, closure giống lambda trong Kotlin nhưng có cú pháp linh hoạt hơn: trailing closure, tên đối số rút gọn ($0, $1) và autoclosures.

// Bao đóng với chụp ngữ cảnh
let numbers = [5, 3, 8, 1, 9]

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

// Chuỗi hàm
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Bao đóng như tham số hàm
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

Closure @escaping được sử dụng khi closure thực thi sau khi hàm trả về — điển hình cho các yêu cầu mạng và hoạt động bất đồng bộ. @autoclosure tự động bọc một biểu thức vào trong closure, được sử dụng trong assert và logic rẽ nhánh ngắn.

Cấu trúc và lớp: so sánh

Lựa chọn giữa struct và class là một trong những quyết định đầu tiên khi thiết kế mô hình Swift. Apple khuyến nghị sử dụng struct theo mặc định (kiểu giá trị) và chuyển sang class (kiểu tham chiếu) chỉ khi cần kế thừa hoặc định danh tham chiếu.

Kiểu giá trị (struct) an toàn hơn trong môi trường đa luồng — mỗi luồng nhận được một bản sao độc lập. Kiểu tham chiếu (class) cần thiết để làm việc với UIKit (UIView, UIViewController), nơi cần định danh tham chiếu và kế thừa từ các lớp hệ thống.

Quản lý bộ nhớ ARC

ARC (Automatic Reference Counting) là hệ thống quản lý bộ nhớ của Swift cho các kiểu tham chiếu. Trình biên dịch chèn các lệnh gọi retain/release tại thời gian chạy, theo dõi số lượng tham chiếu mạnh đến một đối tượng. Khi bộ đếm về không, đối tượng được giải phóng ngay lập tức.

Vấn đề chính của ARC là vòng giữ tham chiếu (retain cycles). Khi hai đối tượng giữ tham chiếu mạnh đến nhau, bộ nhớ không bao giờ được giải phóng. Giải pháp là tham chiếu yếu (weak, tự động trở thành nil khi giải phóng) và tham chiếu unowned (đảm bảo đối tượng còn sống).

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

Để ngăn vòng giữ tham chiếu trong closure, hãy sử dụng [weak self] với guard let self = self else { return }. Quy tắc này đặc biệt quan trọng trong UIKit, nơi ViewController giữ tham chiếu mạnh đến các thuộc tính của nó và các closure bên trong các thuộc tính đó tham chiếu đến ViewController.