Types trong Swift

1. Types là gì?

Trong lập trình, "Types" dịch sang tiếng Việt là "Kiểu" hoặc "Kiểu dữ liệu". Tuy nhiên, trong cộng đồng lập trình Việt Nam, người ta thường giữ nguyên từ "Type" vì đã quen thuộc.

Để hiểu rõ hơn, ta có thể ví Types như "khuôn mẫu" hoặc "khuôn đúc":

1. Như một khuôn bánh:

• Khuôn bánh (Type) định nghĩa hình dạng và cấu trúc
• Bánh được nướng ra (Instance/Object) là thực thể cụ thể từ khuôn đó
• Các đặc điểm của khuôn (Properties) như kích thước, hoa văn
• Cách sử dụng khuôn (Methods) như cách đổ bột, thời gian nướng

2. Hoặc như bản vẽ thiết kế nhà:

• Bản vẽ (Type) chỉ rõ cấu trúc, kích thước
• Ngôi nhà thực tế (Instance) được xây theo bản vẽ đó
• Các thông số của nhà (Properties) như diện tích, số tầng
• Chức năng các phòng (Methods) như cách sử dụng, mục đích

Trong tiếng Việt, ta có thể hiểu Types là:

• Kiểu dữ liệu (cho các type cơ bản như Int, String)
• Khuôn mẫu (cho các type phức tạp như Class, Struct)
• Định dạng (khi nói về cách dữ liệu được tổ chức)
• Loại (khi phân loại các đối tượng)

Ví dụ thực tế:

// Định nghĩa một Type là "SinhVien"
class SinhVien {
    var hoTen: String
    var tuoi: Int
    var diemTrungBinh: Double
    
    init(hoTen: String, tuoi: Int, diemTrungBinh: Double) {
        self.hoTen = hoTen
        self.tuoi = tuoi
        self.diemTrungBinh = diemTrungBinh
    }
    
    func tinhHocBong() -> Bool {
        return diemTrungBinh >= 8.0
    }
}

// Tạo một thể hiện (instance) của Type SinhVien
let nam = SinhVien(hoTen: "Nguyễn Văn Nam", tuoi: 20, diemTrungBinh: 8.5)

Bạn thấy đấy, Type giống như một bản thiết kế chi tiết về một đối tượng, bao gồm:

• Đặc điểm của đối tượng đó có gì (Properties)
• Đối tượng đó làm được những gì (Methods)
• Cách tạo ra đối tượng đó (Initializers)
• Mối quan hệ với các đối tượng khác (Inheritance, Protocols)

2. Properties và Methods trong các Type cơ bản

Một số Properties và Methods phổ biến trong các kiểu dữ liệu cơ bản của Swift:

1. String
Properties:

let text = "Hello, Swift"
text.count                  // Độ dài chuỗi
text.isEmpty               // Kiểm tra chuỗi rỗng
text.startIndex           // Vị trí bắt đầu
text.endIndex            // Vị trí kết thúc
text.uppercased()        // Chuyển thành chữ hoa
text.lowercased()        // Chuyển thành chữ thường

Methods:

// Thao tác với chuỗi
text.contains("Swift")      // Kiểm tra chuỗi con
text.hasPrefix("Hello")    // Kiểm tra tiền tố
text.hasSuffix(".swift")   // Kiểm tra hậu tố
text.split(separator: ",") // Tách chuỗi
text.replacingOccurrences(of: "Swift", with: "World") // Thay thế

2. Array
Properties:

var numbers = [1, 2, 3, 4, 5]
numbers.count              // Số phần tử
numbers.isEmpty           // Kiểm tra mảng rỗng
numbers.first            // Phần tử đầu tiên
numbers.last            // Phần tử cuối cùng

Methods:

// Thao tác với mảng
numbers.append(6)         // Thêm phần tử
numbers.insert(0, at: 0) // Chèn tại vị trí
numbers.remove(at: 0)    // Xóa tại vị trí
numbers.sort()           // Sắp xếp
numbers.reversed()       // Đảo ngược
numbers.filter { $0 > 3 }  // Lọc phần tử
numbers.map { $0 * 2 }    // Biến đổi phần tử

3. Dictionary
Properties:

var scores = ["Math": 90, "English": 85]
scores.count             // Số cặp key-value
scores.isEmpty          // Kiểm tra từ điển rỗng
scores.keys            // Tất cả keys
scores.values         // Tất cả values

Methods:

// Thao tác với từ điển
scores.updateValue(95, forKey: "Math")  // Cập nhật giá trị
scores.removeValue(forKey: "English")   // Xóa cặp key-value
scores.merge(["Physics": 88]) { current, _ in current }  // Gộp từ điển

4. Set
Properties:

var uniqueNumbers: Set = [1, 2, 3, 4, 5]
uniqueNumbers.count      // Số phần tử
uniqueNumbers.isEmpty   // Kiểm tra set rỗng

Methods:

// Thao tác với set
uniqueNumbers.insert(6)        // Thêm phần tử
uniqueNumbers.remove(1)       // Xóa phần tử
uniqueNumbers.contains(2)    // Kiểm tra tồn tại

// Các phép toán tập hợp
let setA: Set = [1, 2, 3]
let setB: Set = [3, 4, 5]
setA.union(setB)           // Hợp
setA.intersection(setB)    // Giao
setA.subtracting(setB)     // Hiệu

5. Numeric Types (Int, Double, Float)
Properties và Methods:

let number = 42
number.magnitude          // Giá trị tuyệt đối
number.signum()          // Dấu của số

let price = 19.99
price.rounded()          // Làm tròn
price.truncatingRemainder(dividingBy: 10)  // Phần dư

// Các thuộc tính giới hạn
Int.max                  // Giá trị lớn nhất
Int.min                  // Giá trị nhỏ nhất
Double.infinity         // Vô cực
Double.nan             // Not a Number

3. Tính năng Type-safe trong Swift

Swift là một ngôn ngữ type-safe, có nghĩa là nó rất nghiêm ngặt về kiểu dữ liệu. Đây là các loại types chính trong Swift:

1. Basic Types (Các kiểu cơ bản):

// Int - Số nguyên
let age: Int = 25

// Double - Số thực
let height: Double = 1.75

// Float - Số thực (độ chính xác thấp hơn Double)
let weight: Float = 68.5

// String - Chuỗi ký tự
let name: String = "Nguyễn Văn A"

// Bool - Giá trị logic
let isStudent: Bool = true

// Character - Ký tự đơn
let grade: Character = "A"

2. Collection Types (Các kiểu tập hợp):

// Array - Mảng
let numbers: [Int] = [1, 2, 3, 4, 5]

// Set - Tập hợp các phần tử unique
let uniqueNumbers: Set<Int> = [1, 2, 3, 4, 5]

// Dictionary - Từ điển key-value
let scores: [String: Int] = ["Toán": 9, "Văn": 8]

3. Optional Types (Kiểu tùy chọn):

// Optional với ?
var optionalName: String? = nil
optionalName = "John"

// Optional với !
var forcedName: String! // Unwrapped tự động nhưng nguy hiểm

4. Custom Types:

// Struct
struct Point {
    var x: Int
    var y: Int
}

// Class
class Person {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

// Enum
enum Direction {
    case north
    case south
    case east
    case west
}

5. Type Aliases (Định nghĩa lại tên type):

typealias AudioSample = UInt16
typealias Coordinates = (x: Int, y: Int)

Một số điểm quan trọng về Types trong Swift:

• Type Inference: Swift có thể tự suy luận kiểu dữ liệu dựa trên giá trị được gán

let name = "John" // Swift tự hiểu đây là String
let age = 25 // Swift tự hiểu đây là Int

• Type Safety: Swift không cho phép trộn lẫn các kiểu dữ liệu khác nhau

let number: Int = 10
let text: String = "20"
// let result = number + text // Lỗi! Không thể cộng Int với String

• Type Conversion: Chuyển đổi giữa các kiểu dữ liệu

let integer = 42
let doubleNumber = Double(integer)
let stringNumber = String(integer)

4. Cụ thể hơn về Custom Types

Types hoạt động như một bản thiết kế (blueprint) trong Swift.

Hãy lấy ví dụ về một chiếc xe để minh họa:

class Car {
    // PROPERTIES (Thuộc tính)
    var brand: String           // Thương hiệu xe
    var model: String          // Model xe
    var currentSpeed: Double    // Tốc độ hiện tại
    private var fuelLevel: Double  // Mức nhiên liệu (private - chỉ truy cập trong class)
    
    // Computed property (Thuộc tính tính toán)
    var description: String {
        return "\(brand) \(model) đang chạy với tốc độ \(currentSpeed) km/h"
    }
    
    // Property observer
    var speed: Double {
        willSet {
            print("Tốc độ sẽ thay đổi từ \(speed) thành \(newValue)")
        }
        didSet {
            if speed > 120 {
                print("Cảnh báo: Tốc độ quá cao!")
            }
        }
    }
    
    // INITIALIZER (Hàm khởi tạo)
    init(brand: String, model: String) {
        self.brand = brand
        self.model = model
        self.currentSpeed = 0
        self.fuelLevel = 100
        self.speed = 0
    }
    
    // METHODS (Các phương thức)
    func accelerate(by value: Double) {
        currentSpeed += value
        speed = currentSpeed
    }
    
    func brake() {
        currentSpeed = 0
        speed = currentSpeed
    }
    
    func refuel(amount: Double) {
        fuelLevel += amount
        if fuelLevel > 100 {
            fuelLevel = 100
        }
    }
}

Giải thích chi tiết:

1. Properties (Thuộc tính):

• Stored Properties: Lưu trữ giá trị trực tiếp

  var brand: String
  var model: String
  

• Computed Properties: Tính toán giá trị dựa trên các thuộc tính khác

  var description: String {
      return "\(brand) \(model) đang chạy với tốc độ \(currentSpeed) km/h"
  }
  

• Property Observers: Theo dõi và phản ứng với thay đổi của thuộc tính

  willSet - Chạy trước khi giá trị thay đổi
  didSet - Chạy sau khi giá trị đã thay đổi
  

2. Methods (Phương thức):

// Method để tăng tốc
func accelerate(by value: Double) {
    currentSpeed += value
}

// Method để dừng xe
func brake() {
    currentSpeed = 0
}

Sử dụng blueprint này:

// Tạo một instance của Car
let myCar = Car(brand: "Toyota", model: "Camry")

// Sử dụng các methods
myCar.accelerate(by: 20)  // Tăng tốc
print(myCar.description)  // In mô tả xe
myCar.brake()            // Dừng xe

3. Access Control (Kiểm soát truy cập):

• private: Chỉ truy cập được trong class
• fileprivate: Truy cập trong cùng file
• internal: Truy cập trong cùng module (mặc định)
• public: Truy cập từ bất kỳ module nào
• open: Giống public nhưng cho phép kế thừa và override

4. Inheritance (Kế thừa):

class ElectricCar: Car {
    var batteryLevel: Double
    
    override init(brand: String, model: String) {
        self.batteryLevel = 100
        super.init(brand: brand, model: model)
    }
    
    func charge() {
        batteryLevel = 100
    }
}

Như vậy, Type trong Swift hoạt động như một bản thiết kế hoàn chỉnh, định nghĩa:

• Các thuộc tính (dữ liệu)
• Các phương thức (hành vi)
• Cách khởi tạo
• Quyền truy cập
• Khả năng kế thừa và mở rộng

5. Kết luận

Tóm lại, Types trong Swift là một khái niệm nền tảng về kiểu dữ liệu, hoạt động như một bản thiết kế hoàn chỉnh cho đối tượng, bao gồm các thuộc tính (properties), phương thức (methods), quy tắc khởi tạo và quyền truy cập, đồng thời Swift là ngôn ngữ type-safe giúp đảm bảo tính chặt chẽ và an toàn trong việc xử lý dữ liệu.

Tags

• Swift
• Education