OOP và Lập trình Hàm trong iOS: Chọn Lựa Nào Cho Từng Tình Huống?

Giới thiệu về các mô hình Lập trình trong Phát triển iOS

Chào mừng trở lại với loạt bài “Lộ trình học Lập trình viên iOS 2025“! Sau khi đã tìm hiểu về những nền tảng cốt lõi như cuộc đối đầu giữa Swift và Objective-C, lý do Swift trở thành ngôn ngữ thống trị, và thậm chí cả giá trị còn lại của Objective-C, cũng như những kiến thức Swift cơ bản, đã đến lúc chúng ta đào sâu vào các mô hình lập trình phổ biến mà bạn sẽ gặp và sử dụng hàng ngày: Lập trình Hướng đối tượng (Object-Oriented Programming – OOP) và Lập trình Hàm (Functional Programming – FP).

Là một lập trình viên iOS, việc hiểu rõ cả hai mô hình này và biết khi nào nên áp dụng chúng là vô cùng quan trọng. Swift là một ngôn ngữ đa mô hình, cho phép bạn tận dụng sức mạnh của cả OOP và FP. Bài viết này sẽ giúp bạn làm sáng tỏ hai khái niệm này trong bối cảnh phát triển ứng dụng Apple.

Lập trình Hướng đối tượng (OOP): Nền tảng quen thuộc

OOP là mô hình lập trình phổ biến đã tồn tại từ rất lâu và là nền tảng của nhiều ngôn ngữ, bao gồm cả Objective-C và là một phần quan trọng của Swift. Ý tưởng cốt lõi của OOP là tổ chức code xung quanh các “đối tượng” (objects), là sự kết hợp của dữ liệu (thuộc tính/properties) và hành vi (phương thức/methods) liên quan đến dữ liệu đó.

Các khái niệm chính trong OOP

OOP dựa trên bốn nguyên lý trụ cột:

• Tính đóng gói (Encapsulation): Gói gọn dữ liệu và các phương thức xử lý dữ liệu đó vào trong một “đối tượng” hoặc “lớp” (class). Điều này giúp bảo vệ dữ liệu khỏi bị truy cập và sửa đổi trực tiếp từ bên ngoài, chỉ cho phép tương tác thông qua các phương thức công khai (public methods).
• Tính trừu tượng (Abstraction): Giấu đi các chi tiết phức tạp bên trong và chỉ hiển thị những gì cần thiết cho người dùng (lập trình viên sử dụng đối tượng). Ví dụ, khi bạn sử dụng một đối tượng `UIButton`, bạn không cần biết chính xác nó vẽ lên màn hình như thế nào, chỉ cần biết cách thiết lập tiêu đề, hình ảnh và thêm hành động khi nhấn.
• Tính kế thừa (Inheritance): Cho phép một lớp (lớp con – subclass) kế thừa các thuộc tính và phương thức từ một lớp khác (lớp cha – superclass). Điều này giúp tái sử dụng code và tạo ra một cấu trúc phân cấp các lớp.
• Tính đa hình (Polymorphism): Cho phép các đối tượng thuộc các lớp khác nhau phản ứng theo cách riêng của chúng với cùng một thông điệp (phương thức). Ví dụ, phương thức `draw()` có thể được gọi trên các đối tượng `Shape` khác nhau (như `Circle`, `Square`), và mỗi đối tượng sẽ vẽ hình dạng tương ứng của nó.

Ưu điểm của OOP trong iOS

• Tái sử dụng code: Thông qua kế thừa và đóng gói, OOP giúp bạn viết code có thể tái sử dụng ở nhiều nơi.
• Dễ quản lý và bảo trì: Khi code được chia thành các đối tượng độc lập, việc theo dõi, sửa lỗi và cập nhật trở nên dễ dàng hơn.
• Mô hình hóa thế giới thực: OOP thường phản ánh cách chúng ta nghĩ về các đối tượng và mối quan hệ của chúng trong thế giới thực, giúp việc thiết kế hệ thống trở nên trực quan.
• Cấu trúc framework mạnh mẽ: Hầu hết các framework của Apple như UIKit, AppKit, Foundation đều được xây dựng dựa trên mô hình OOP với các lớp (class) và hệ thống phân cấp kế thừa.

Nhược điểm của OOP

• Phức tạp với hệ thống phân cấp sâu: Việc kế thừa quá sâu có thể tạo ra các lớp phụ thuộc phức tạp và khó hiểu.
• Khó xử lý thay đổi trạng thái (State): Khi nhiều đối tượng tương tác và thay đổi trạng thái lẫn nhau, việc theo dõi luồng dữ động và xác định nguồn gốc lỗi trở nên khó khăn, đặc biệt trong môi trường đa luồng (multi-threading).
• “Vấn đề kim cương” (Diamond Problem): Có thể xảy ra trong các ngôn ngữ hỗ trợ đa kế thừa (mặc dù Swift không hỗ trợ đa kế thừa lớp, nhưng nguyên tắc này vẫn liên quan đến thiết kế).

Khi nào sử dụng OOP trong iOS?

OOP là lựa chọn tuyệt vời cho:

• Xây dựng giao diện người dùng: Các thành phần UI như `UIView`, `UIViewController`, `UITableViewCell` là những ví dụ điển hình của đối tượng. Bạn sẽ làm việc với các lớp này liên tục.
• Mô hình dữ liệu phức tạp: Khi bạn cần mô hình hóa các thực thể có thuộc tính và hành vi rõ ràng (ví dụ: `User`, `Product`, `Order`).
• Tổ chức code logic lớn: Chia nhỏ các tác vụ lớn thành các đối tượng quản lý riêng biệt (ví dụ: `NetworkingService`, `DatabaseManager`).
• Làm việc với các framework của Apple: Do các framework này chủ yếu dựa trên OOP, bạn sẽ tự nhiên áp dụng mô hình này khi sử dụng chúng.

// Ví dụ OOP cơ bản trong Swift
class Dog {
    var name: String
    let breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("\(name) says Woof!")
    }

    func changeName(to newName: String) {
        self.name = newName
    }
}

let myDog = Dog(name: "Buddy", breed: "Golden Retriever")
myDog.bark() // Output: Buddy says Woof!
myDog.changeName(to: "Buddy Bear")
print(myDog.name) // Output: Buddy Bear

Trong ví dụ trên, `Dog` là một lớp (class) đóng gói dữ liệu (`name`, `breed`) và hành vi (`bark`, `changeName`). Đối tượng `myDog` là một thể hiện của lớp này.

Lập trình Hàm (Functional Programming – FP): Một cách tiếp cận khác

Ngược lại với OOP tập trung vào “đối tượng” và “thay đổi trạng thái”, Lập trình Hàm tập trung vào “hàm” (functions) như những công dân hạng nhất và tránh “thay đổi trạng thái” (mutation) hoặc các tác dụng phụ (side effects). FP coi tính toán như việc đánh giá các hàm toán học.

Các khái niệm chính trong FP

FP dựa trên một số nguyên tắc cốt lõi:

• Hàm là công dân hạng nhất (First-Class Functions): Hàm có thể được gán cho biến, truyền làm đối số cho hàm khác và được trả về từ các hàm khác. Swift hỗ trợ rất tốt điều này với closures.
• Hàm thuần khiết (Pure Functions): Một hàm được coi là thuần khiết nếu:
  • Với cùng một đầu vào, luôn cho cùng một đầu ra.
  • Không gây ra bất kỳ tác dụng phụ nào (không thay đổi trạng thái bên ngoài, không ghi file, không in ra console, v.v.).

  Hàm thuần khiết dễ kiểm thử và dự đoán hơn nhiều.

• Tính bất biến (Immutability): Tránh thay đổi trạng thái của dữ liệu sau khi nó đã được tạo. Thay vào đó, khi cần thay đổi, bạn tạo ra một bản sao mới với sự thay đổi đó. Điều này làm cho code dễ hiểu và an toàn hơn trong môi trường đa luồng.
• Tránh tác dụng phụ (Avoiding Side Effects): Mục tiêu là giảm thiểu hoặc cách ly các phần code gây ra tác dụng phụ, giúp phần lớn code trở nên dễ kiểm soát hơn.
• Hàm bậc cao hơn (Higher-Order Functions): Các hàm nhận một hoặc nhiều hàm khác làm đối số, hoặc trả về một hàm khác. Các hàm `map`, `filter`, `reduce` trong Swift là những ví dụ điển hình.

Ưu điểm của FP trong iOS

• Dễ kiểm thử: Hàm thuần khiết rất dễ kiểm thử vì chúng không phụ thuộc vào trạng thái bên ngoài và không gây tác dụng phụ.
• An toàn trong môi trường đa luồng: Do ưu tiên tính bất biến và tránh thay đổi trạng thái, code theo phong cách FP ít gặp các vấn đề về race condition.
• Code ngắn gọn và biểu cảm: Sử dụng các hàm bậc cao hơn và closure có thể giúp viết code mạch lạc và ngắn gọn hơn, đặc biệt khi xử lý tập hợp (collections).
• Dễ suy luận: Với hàm thuần khiết, bạn có thể dễ dàng dự đoán đầu ra chỉ dựa vào đầu vào.

Nhược điểm của FP

• Có thể khó hiểu ban đầu: Các khái niệm như bất biến, hàm bậc cao hơn có thể lạ lẫm nếu bạn chỉ quen với OOP.
• Không phải mọi thứ đều dễ dàng mô hình hóa bằng hàm thuần khiết: Các tác vụ như I/O, cập nhật UI chắc chắn có tác dụng phụ và không thể hoàn toàn là hàm thuần khiết.
• Có thể tạo ra nhiều đối tượng mới (nếu không cẩn thận): Do ưu tiên bất biến, việc “thay đổi” dữ liệu thường dẫn đến việc tạo ra các bản sao mới, có thể ảnh hưởng đến hiệu năng nếu không tối ưu.

Khi nào sử dụng FP trong iOS?

FP đặc biệt hữu ích cho:

• Xử lý tập hợp dữ liệu: Sử dụng `map`, `filter`, `reduce`, `compactMap`, `sorted`, v.v., để biến đổi và thao tác với mảng, dictionary, set.
• Viết code logic không trạng thái (stateless): Các hàm tính toán, biến đổi dữ liệu mà không phụ thuộc hoặc thay đổi trạng thái bên ngoài.
• Làm việc với bất đồng bộ và song song: Các framework như Combine (mô hình lập trình phản ứng – Reactive Programming, thường kết hợp các yếu tố FP) tận dụng mạnh mẽ các nguyên tắc FP để xử lý các luồng dữ liệu theo thời gian.
• Kiểm thử đơn vị (Unit Testing): Viết các hàm thuần khiết giúp việc kiểm thử trở nên đơn giản và đáng tin cậy hơn nhiều.

// Ví dụ FP cơ bản trong Swift (sử dụng Higher-Order Functions)
let numbers = [1, 2, 3, 4, 5, 6]

// Sử dụng filter để lấy các số chẵn
let evenNumbers = numbers.filter { $0 % 2 == 0 } // evenNumbers là [2, 4, 6]

// Sử dụng map để nhân đôi mỗi số
let doubledNumbers = numbers.map { $0 * 2 } // doubledNumbers là [2, 4, 6, 8, 10, 12]

// Sử dụng reduce để tính tổng
let sum = numbers.reduce(0) { $0 + $1 } // sum là 21

print(evenNumbers)
print(doubledNumbers)
print(sum)

Trong ví dụ trên, chúng ta sử dụng các hàm bậc cao hơn (`filter`, `map`, `reduce`) để thao tác với mảng `numbers` mà không làm thay đổi mảng gốc (tính bất biến) và không gây ra tác dụng phụ. Closure `{ $0 % 2 == 0 }` hay `{ $0 * 2 }` là các hàm (ẩn danh) được truyền làm đối số.

Kết hợp OOP và FP trong Swift

Điểm mạnh của Swift là nó không buộc bạn phải chọn một trong hai. Bạn hoàn toàn có thể và nên kết hợp cả hai mô hình để tận dụng ưu điểm của từng cái. Đây là một số cách phổ biến:

• Sử dụng `struct` (FP hơn) thay vì `class` (OOP hơn) khi phù hợp: `struct` trong Swift là kiểu giá trị (value type) và khuyến khích tính bất biến theo mặc định (với `let`). Chúng tuyệt vời cho việc mô hình hóa dữ liệu đơn giản hoặc các kiểu dữ liệu không có identity cần được chia sẻ bằng tham chiếu.
• Thiết kế các lớp (class) của bạn để có các phương thức thuần khiết khi có thể: Ngay cả trong một lớp OOP, bạn vẫn có thể viết các phương thức nhận đầu vào, thực hiện tính toán và trả về kết quả mà không thay đổi trạng thái nội bộ của đối tượng hoặc môi trường bên ngoài.
• Sử dụng các hàm bậc cao hơn (`map`, `filter`, `reduce`, v.v.) để xử lý dữ liệu trong các phương thức của lớp: Thay vì sử dụng các vòng lặp `for` truyền thống để biến đổi mảng dữ liệu trong một phương thức của lớp, hãy sử dụng các hàm FP để có code ngắn gọn và biểu cảm hơn.
• Áp dụng các nguyên tắc FP (bất biến, tránh tác dụng phụ) khi thiết kế các luồng dữ liệu phức tạp: Đặc biệt hữu ích khi làm việc với các kiến trúc dựa trên luồng dữ liệu một chiều (như Elm Architecture, Redux) hoặc khi sử dụng Combine/RxSwift.

// Ví dụ kết hợp
struct User {
    let id: Int
    let name: String
    let isActive: Bool
    var friends: [User] // struct có thể chứa mảng struct khác
}

class UserManager {
    private var users: [User] = [] // Lưu trữ dữ liệu User (struct)

    init(users: [User]) {
        self.users = users
    }

    // Phương thức OOP, quản lý trạng thái nội bộ (mảng users)
    func addUser(_ user: User) {
        self.users.append(user)
    }

    // Phương thức sử dụng FP để xử lý dữ liệu
    func getActiveUsers() -> [User] {
        // filter là hàm bậc cao hơn, closure là hàm thuần khiết (trong ngữ cảnh này)
        return users.filter { $0.isActive }
    }

    // Phương thức sử dụng FP để biến đổi dữ liệu
    func getUserNames() -> [String] {
        // map là hàm bậc cao hơn, closure là hàm thuần khiết
        return users.map { $0.name }
    }

    // Phương thức kết hợp OOP và FP
    func findUser(byId id: Int) -> User? {
        // first(where:) là hàm bậc cao hơn
        return users.first { $0.id == id }
    }
}

let initialUsers = [
    User(id: 1, name: "Alice", isActive: true, friends: []),
    User(id: 2, name: "Bob", isActive: false, friends: []),
    User(id: 3, name: "Charlie", isActive: true, friends: [])
]

let userManager = UserManager(users: initialUsers)

let activeUsers = userManager.getActiveUsers() // Sử dụng phương thức FP
print(activeUsers.map { $0.name }) // Output: ["Alice", "Charlie"]

userManager.addUser(User(id: 4, name: "David", isActive: true, friends: [])) // Sử dụng phương thức OOP để thay đổi trạng thái
let allNames = userManager.getUserNames() // Sử dụng phương thức FP trên trạng thái đã thay đổi
print(allNames) // Output: ["Alice", "Bob", "Charlie", "David"]

Trong ví dụ này, `User` là một `struct` (hướng FP về mặt kiểu giá trị và bất biến mặc định). `UserManager` là một `class` (hướng OOP) quản lý một tập hợp các `User`. Các phương thức của `UserManager` như `getActiveUsers()` hay `getUserNames()` lại sử dụng các kỹ thuật lập trình hàm (`filter`, `map`) để thao tác với dữ liệu. Đây là cách kết hợp rất phổ biến và hiệu quả trong Swift.

Khi nào nên ưu tiên mô hình nào?

Việc lựa chọn ưu tiên không phải lúc nào cũng rõ ràng và thường phụ thuộc vào ngữ cảnh cụ thể. Tuy nhiên, đây là một vài hướng dẫn:

• Ưu tiên OOP khi:
  • Bạn cần mô hình hóa các thực thể có vòng đời (lifecycle) hoặc cần quản lý trạng thái phức tạp và các tương tác giữa chúng (ví dụ: `UIViewController` quản lý vòng đời màn hình).
  • Làm việc chặt chẽ với các framework của Apple dựa trên lớp (class).
  • Khi tính kế thừa và đa hình giúp cấu trúc code trở nên rõ ràng hơn (mặc dù Composition over Inheritance thường được khuyến khích trong Swift).
• Ưu tiên FP khi:
  • Bạn cần xử lý biến đổi dữ liệu hoặc tập hợp một cách hiệu quả và an toàn.
  • Viết các hàm tính toán, xử lý logic không trạng thái.
  • Làm việc với các luồng dữ liệu bất đồng bộ hoặc song song.
  • Khi tính bất biến giúp code dễ kiểm thử và an toàn hơn trong môi trường đa luồng.

Quan trọng nhất là hãy sử dụng mô hình nào giúp code của bạn dễ đọc, dễ hiểu, dễ bảo trì và dễ kiểm thử nhất cho tình huống cụ thể.

So sánh Tổng quan

Dưới đây là bảng tóm tắt so sánh giữa hai mô hình:

Lời khuyên cho Lập trình viên Junior

Nếu bạn mới bắt đầu hành trình trở thành một lập trình viên iOS (như đã đề cập trong lộ trình học), có thể bạn sẽ cảm thấy OOP quen thuộc hơn vì các framework của Apple ban đầu được xây dựng dựa trên nó, và các khái niệm như lớp, đối tượng dễ hình dung hơn. Hãy nắm vững các nguyên lý OOP và cách làm việc với các thành phần UI/Kit.

Tuy nhiên, đừng ngại học và áp dụng các kỹ thuật Lập trình Hàm. Swift được thiết kế để bạn có thể sử dụng cả hai. Bắt đầu với việc làm quen với các hàm xử lý tập hợp như `map`, `filter`, `reduce`. Hiểu về `struct` và sự khác biệt giữa kiểu giá trị và kiểu tham chiếu là một bước quan trọng.

Theo thời gian, khi bạn làm việc với các kiến trúc hiện đại hơn hoặc các thư viện xử lý luồng dữ liệu, các nguyên tắc FP sẽ trở nên cực kỳ giá trị. Việc thành thạo cả hai mô hình sẽ làm cho bạn trở thành một lập trình viên Swift mạnh mẽ và linh hoạt hơn.

Kết luận

Trong thế giới phát triển iOS hiện đại với Swift, cuộc tranh luận “OOP vs FP” không còn là chọn một bỏ một. Thay vào đó, nó là về việc hiểu rõ ưu điểm và nhược điểm của từng mô hình và khéo léo kết hợp chúng để xây dựng ứng dụng mạnh mẽ, dễ bảo trì và mở rộng.

OOP cung cấp cấu trúc vững chắc cho việc tổ chức code phức tạp và tương tác với các framework truyền thống. FP mang lại sự gọn gàng, khả năng kiểm thử cao và an toàn trong xử lý dữ liệu, đặc biệt hữu ích trong các tình huống bất đồng bộ và xử lý tập hợp.

Hãy tiếp tục khám phá và thực hành. Mỗi dòng code bạn viết sẽ giúp bạn hiểu sâu sắc hơn về cách hai mô hình này hoạt động cùng nhau trong Swift.