@sun-asterisk/sunlint 1.3.40 → 1.3.42

package/skill-assets/sunlint-code-quality/rules/swift/SW007-discouraged-direct-init.md

@@ -0,0 +1,28 @@
+---
+title: Tránh khởi tạo trực tiếp các system types
+impact: MEDIUM
+impactDescription: Tránh việc tạo các instance không hợp lệ hoặc không cần thiết của các system types có sẵn cơ chế factory/singleton.
+tags: swift, ios, bundle, uidevice, initialization
+---
+
+## Tránh khởi tạo trực tiếp các system types
+
+Tránh khởi tạo trực tiếp các kiểu như: `Bundle`, `NSError`, `UIDevice`. Sử dụng các factory method hoặc properties sẵn có (như `.main`, `.current`) thay vì gọi `init()` trực tiếp để đảm bảo tính nhất quán và hiệu năng.
+
+**Incorrect (khởi tạo trực tiếp):**
+
+```swift
+let bundle = Bundle()
+let device = UIDevice()
+let error = NSError()
+```
+
+**Correct (sử dụng instance có sẵn):**
+
+```swift
+let mainBundle = Bundle.main
+let currentDevice = UIDevice.current
+let designError = NSError(domain: "com.example", code: 404, userInfo: nil) // Cần truyền tham số nếu tạo mới hợp lệ
+```
+
+**Tools:** SwiftLint (discouraged_direct_init)

package/skill-assets/sunlint-code-quality/rules/swift/SW008-discouraged-optional-boolean.md

@@ -0,0 +1,32 @@
+---
+title: Không dùng optional cho Boolean
+impact: HIGH
+impactDescription: Tránh ambiguity logic (3 trạng thái: true, false, nil) khi chỉ cần 2 trạng thái logic nhị phân.
+tags: swift, ios, boolean, optional, logic
+---
+
+## Không dùng optional cho Boolean
+
+Không khai báo kiểu `Bool?` nếu có thể tránh được. Việc có 3 trạng thái (`true`, `false`, `nil`) cho một biến logic thường gây khó khăn trong việc kiểm soát luồng điều kiện và dễ dẫn đến lỗi logic. Hãy sử dụng giá trị mặc định rõ ràng.
+
+**Incorrect (dùng optional bool):**
+
+```swift
+var isExpanded: Bool?
+
+if isExpanded == true {
+    // ...
+}
+```
+
+**Correct (dùng bool với giá trị mặc định):**
+
+```swift
+var isExpanded: Bool = false
+
+if isExpanded {
+    // ...
+}
+```
+
+**Tools:** SwiftLint (discouraged_optional_boolean)

package/skill-assets/sunlint-code-quality/rules/swift/SW009-empty-count.md

@@ -0,0 +1,30 @@
+---
+title: Ưu tiên .isEmpty thay vì .count == 0
+impact: LOW
+impactDescription: Code rõ ràng hơn và hiệu năng tốt hơn (một số collection cần duyệt để đếm nhưng chỉ cần check phần tử đầu để biết có trống không).
+tags: swift, ios, performance, collection, isEmpty
+---
+
+## Ưu tiên .isEmpty thay vì .count == 0
+
+Dùng `.isEmpty` giúp code dễ đọc hơn và mang ý nghĩa rõ ràng hơn về mục đích kiểm tra tập hợp trống. Ngoài ra, `.count == 0` có thể chậm hơn trên một số loại collection so với `.isEmpty`.
+
+**Incorrect (kiểm tra count):**
+
+```swift
+let items = [String]()
+if items.count == 0 {
+    print("Danh sách trống")
+}
+```
+
+**Correct (dùng isEmpty):**
+
+```swift
+let items = [String]()
+if items.isEmpty {
+    print("Danh sách trống")
+}
+```
+
+**Tools:** SwiftLint (empty_count)

package/skill-assets/sunlint-code-quality/rules/swift/SW010-empty-string.md

@@ -0,0 +1,30 @@
+---
+title: Ưu tiên isEmpty thay vì so sánh == ""
+impact: LOW
+impactDescription: Tăng độ rõ ràng và tránh lỗi tiềm ẩn khi xử lý chuỗi rỗng.
+tags: swift, ios, string, isEmpty, readability
+---
+
+## Ưu tiên isEmpty thay vì so sánh == ""
+
+Dùng `.isEmpty` thay cho so sánh bằng chuỗi rỗng `""`. Điều này giúp code đồng bộ, chuyên nghiệp và rõ ràng hơn về mặt ngữ nghĩa trong Swift.
+
+**Incorrect (so sánh chuỗi rỗng):**
+
+```swift
+let name = ""
+if name == "" {
+    print("Tên không được để trống")
+}
+```
+
+**Correct (dùng isEmpty):**
+
+```swift
+let name = ""
+if name.isEmpty {
+    print("Tên không được để trống")
+}
+```
+
+**Tools:** SwiftLint (empty_string)

package/skill-assets/sunlint-code-quality/rules/swift/SW011-explicit-init.md

@@ -0,0 +1,26 @@
+---
+title: Không sử dụng .init() khi không cần thiết
+impact: LOW
+impactDescription: Giảm bớt sự rườm rà trong code, tuân thủ phong cách viết Swift ngắn gọn và hiện đại.
+tags: swift, ios, initialization, init, readability
+---
+
+## Không sử dụng .init() khi không cần thiết
+
+Tránh gọi `.init()` một cách tường minh nếu không bắt buộc. Trong Swift, việc khởi tạo đối tượng bằng cách gọi trực tiếp tên kiểu dữ liệu kèm tham số được ưu tiên hơn vì tính ngắn gọn và dễ đọc.
+
+**Incorrect (gọi .init tường minh):**
+
+```swift
+let point = CGPoint.init(x: 10, y: 20)
+let user = User.init(name: "John")
+```
+
+**Correct (khởi tạo trực tiếp):**
+
+```swift
+let point = CGPoint(x: 10, y: 20)
+let user = User(name: "John")
+```
+
+**Tools:** SwiftLint (explicit_init)

package/skill-assets/sunlint-code-quality/rules/swift/SW012-fatal-error-message.md

@@ -0,0 +1,28 @@
+---
+title: Luôn phải có message rõ ràng khi sử dụng fatalError
+impact: MEDIUM
+impactDescription: Giúp xác định nguyên nhân lỗi nhanh chóng khi ứng dụng bị crash trong quá trình phát triển hoặc test.
+tags: swift, ios, error-handling, fatalError, debugging
+---
+
+## Luôn phải có message rõ ràng khi sử dụng fatalError
+
+Bắt buộc thêm mô tả khi gọi `fatalError(...)`. Message này rất quan trọng để cung cấp ngữ cảnh về lý do tại sao code rơi vào trạng thái không thể hồi phục, giúp trace lỗi dễ dàng hơn trong log hoặc khi debug.
+
+**Incorrect (không có message):**
+
+```swift
+func test() {
+    fatalError()
+}
+```
+
+**Correct (có message mô tả):**
+
+```swift
+func test() {
+    fatalError("Hàm này chưa được triển khai hoặc trạng thái không hợp lệ")
+}
+```
+
+**Tools:** SwiftLint (fatal_error_message)

package/skill-assets/sunlint-code-quality/rules/swift/SW013-for-where.md

@@ -0,0 +1,30 @@
+---
+title: Ưu tiên for-where thay vì if trong loop
+impact: LOW
+impactDescription: Code gọn gàng hơn, giảm bớt một tầng lồng nhau (nesting) và thể hiện rõ ý định lọc phần tử.
+tags: swift, ios, loops, for-where, readability
+---
+
+## Ưu tiên for-where thay vì if trong loop
+
+Nếu chỉ có một điều kiện lọc duy nhất bên trong toàn bộ nội dung của vòng lặp, nên sử dụng cú pháp `for ... where` thay vì dùng câu lệnh `if` lồng bên trong. Điều này giúp mã nguồn phẳng hơn và làm rõ mục đích duyệt các phần tử thỏa mãn điều kiện.
+
+**Incorrect (dùng if lồng):**
+
+```swift
+for user in users {
+    if user.isActive {
+        print(user.name)
+    }
+}
+```
+
+**Correct (dùng for-where):**
+
+```swift
+for user in users where user.isActive {
+    print(user.name)
+}
+```
+
+**Tools:** SwiftLint (for_where)

package/skill-assets/sunlint-code-quality/rules/swift/SW014-force-cast.md

@@ -0,0 +1,26 @@
+---
+title: Tránh as! (force cast)
+impact: CRITICAL
+impactDescription: Ngăn chặn crash ứng dụng do ép kiểu sai thực tế. Force-cast là nguyên nhân phổ biến gây lỗi runtime.
+tags: swift, ios, casting, force-cast, safety
+---
+
+## Tránh as! (force cast)
+
+Không sử dụng ép kiểu bắt buộc `as!`, thay vào đó nên dùng `as?` kết hợp với kiểm tra null (optional binding). Force-cast sẽ khiến ứng dụng bị crash ngay lập tức nếu đối tượng không thuộc kiểu dữ liệu mong đợi.
+
+**Incorrect (force cast):**
+
+```swift
+let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") as! MyCustomCell
+```
+
+**Correct (safe cast):**
+
+```swift
+guard let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") as? MyCustomCell else {
+    fatalError("Không thể cast cell sang MyCustomCell")
+}
+```
+
+**Tools:** SwiftLint (force_cast)

package/skill-assets/sunlint-code-quality/rules/swift/SW015-force-try.md

@@ -0,0 +1,30 @@
+---
+title: Tránh try! (force try)
+impact: CRITICAL
+impactDescription: Ngăn chặn crash ứng dụng khi có lỗi phát sinh từ các phương thức ném exception.
+tags: swift, ios, error-handling, force-try, safety
+---
+
+## Tránh try! (force try)
+
+Tránh sử dụng `try!`, thay vào đó hãy dùng `try?` hoặc cấu trúc `do-catch`. `try!` bỏ qua việc xử lý lỗi và sẽ gây crash ứng dụng nếu có bất kỳ exception nào xảy ra trong quá trình thực thi.
+
+**Incorrect (force try):**
+
+```swift
+let content = try! String(contentsOfFile: filePath)
+```
+
+**Correct (xử lý lỗi an toàn):**
+
+```swift
+do {
+    let content = try String(contentsOfFile: filePath)
+} catch {
+    print("Lỗi khi đọc file: \(error)")
+}
+// Hoặc
+let content = try? String(contentsOfFile: filePath)
+```
+
+**Tools:** SwiftLint (force_try)

package/skill-assets/sunlint-code-quality/rules/swift/SW016-force-unwrapping.md

@@ -0,0 +1,32 @@
+---
+title: Tránh ! (force unwrap)
+impact: CRITICAL
+impactDescription: Loại bỏ nguy cơ crash ứng dụng do truy cập trực tiếp vào giá trị nil của Optional.
+tags: swift, ios, optional, force-unwrap, safety
+---
+
+## Tránh ! (force unwrap)
+
+Không sử dụng `value!` để lấy giá trị từ một Optional. Force unwrap là một "code smell" nguy hiểm vì nó giả định giá trị luôn tồn tại. Ưu tiên dùng optional binding (`if let`, `guard let`) hoặc nil-coalescing operator (`??`) để xử lý an toàn.
+
+**Incorrect (force unwrap):**
+
+```swift
+let url = URL(string: "https://invalid url")!
+print(url.absoluteString)
+```
+
+**Correct (optional binding):**
+
+```swift
+if let url = URL(string: "https://example.com") {
+    print(url.absoluteString)
+}
+
+// Hoặc dùng guard
+guard let url = URL(string: "https://example.com") else {
+    return
+}
+```
+
+**Tools:** SwiftLint (force_unwrapping)

package/skill-assets/sunlint-code-quality/rules/swift/SW017-function-parameter-count.md

@@ -0,0 +1,37 @@
+---
+title: Giới hạn số lượng tham số của hàm dưới 6
+impact: MEDIUM
+impactDescription: Giúp hàm dễ đọc, dễ kiểm thử và giảm độ phức tạp khi gọi hàm.
+tags: swift, ios, clean-code, functions, architecture
+---
+
+## Giới hạn số lượng tham số của hàm dưới 6
+
+Tránh khai báo function có quá nhiều tham số (nên giữ dưới 6). Một hàm có quá nhiều tham số thường vi phạm nguyên tắc Single Responsibility và gây khó khăn cho việc bảo trì. Nếu cần truyền nhiều dữ liệu, hãy cân nhắc gộp chúng vào một `struct` hoặc `class` chuyên biệt.
+
+**Incorrect (quá nhiều tham số):**
+
+```swift
+func registerUser(name: String, age: Int, email: String, phone: String, city: String, country: String) {
+    // ...
+}
+```
+
+**Correct (gộp vào struct):**
+
+```swift
+struct UserRegistrationInfo {
+    let name: String
+    let age: Int
+    let email: String
+    let phone: String
+    let city: String
+    let country: String
+}
+
+func registerUser(info: UserRegistrationInfo) {
+    // ...
+}
+```
+
+**Tools:** SwiftLint (function_parameter_count)

package/skill-assets/sunlint-code-quality/rules/swift/SW018-large-tuple.md

@@ -0,0 +1,41 @@
+---
+title: Không sử dụng tuple có quá nhiều phần tử
+impact: LOW
+impactDescription: Giảm độ phức tạp, tăng khả năng đọc hiểu (readability) và bảo trì (maintainability).
+tags: swift, ios, tuple, struct, code-quality
+---
+
+## Không sử dụng tuple có quá nhiều phần tử
+
+Tuple chỉ nên được sử dụng cho các nhóm dữ liệu nhỏ, tạm thời (tối đa 2-3 phần tử). Nếu một tuple dài hơn, người đọc sẽ khó biết được ý nghĩa của từng phần tử qua index. Trong trường hợp này, hãy thay thế bằng một `struct` có tên thuộc tính rõ ràng.
+
+**Incorrect (tuple lớn):**
+
+```swift
+func getInfo() -> (String, Int, Double, String) {
+    return ("John", 30, 180.5, "New York")
+}
+
+let info = getInfo()
+print(info.0) // Khó hiểu index 0 là gì
+```
+
+**Correct (dùng struct):**
+
+```swift
+struct PersonInfo {
+    let name: String
+    let age: Int
+    let height: Double
+    let city: String
+}
+
+func getInfo() -> PersonInfo {
+    return PersonInfo(name: "John", age: 30, height: 180.5, city: "New York")
+}
+
+let info = getInfo()
+print(info.name) // Rõ ràng và dễ hiểu
+```
+
+**Tools:** SwiftLint (large_tuple)

package/skill-assets/sunlint-code-quality/rules/swift/SW019-legacy-constructor.md

@@ -0,0 +1,28 @@
+---
+title: Sử dụng khởi tạo Swift thay vì Objective-C
+impact: LOW
+impactDescription: Giữ cho mã nguồn Swift thuần túy (idiomatic), hiện đại và dễ bảo trì.
+tags: swift, ios, legacy, objective-c, initialization
+---
+
+## Sử dụng khởi tạo Swift thay vì Objective-C
+
+Không sử dụng các hàm khởi tạo kiểu cũ (legacy constructors) kế thừa từ Objective-C như `CGPointMake`, `CGRectMake`, `CGSizeMake`, v.v. Hãy sử dụng các hàm khởi tạo chính thức của Swift để tận dụng các tính năng của ngôn ngữ như tham số có tên (named parameters).
+
+**Incorrect (Legacy constructor):**
+
+```swift
+let point = CGPointMake(10, 20)
+let rect = CGRectMake(0, 0, 100, 100)
+let size = CGSizeMake(50, 50)
+```
+
+**Correct (Swift constructor):**
+
+```swift
+let point = CGPoint(x: 10, y: 20)
+let rect = CGRect(x: 0, y: 0, width: 100, height: 100)
+let size = CGSize(width: 50, height: 50)
+```
+
+**Tools:** SwiftLint (legacy_constructor)

package/skill-assets/sunlint-code-quality/rules/swift/SW020-nesting.md

@@ -0,0 +1,38 @@
+---
+title: Data type chỉ lồng nhau tối đa 1 level
+impact: LOW
+impactDescription: Tránh mã nguồn khó đọc và khó debug do có quá nhiều tầng lồng nhau.
+tags: swift, ios, nesting, architecture, clean-code
+---
+
+## Data type chỉ lồng nhau tối đa 1 level
+
+Không nên lồng quá một cấp trong các định nghĩa kiểu dữ liệu như `class`, `struct`, `enum`, `actor`. Việc lồng nhau quá sâu làm tăng độ phức tạp của tên kiểu dữ liệu (fully qualified name) và thường vi phạm nguyên tắc Phân tách mối quan tâm (Separation of Concerns).
+
+**Incorrect (lồng quá sâu):**
+
+```swift
+class Parent {
+    class Child {
+        class GrandChild {
+            // ...
+        }
+    }
+}
+```
+
+**Correct (phẳng hóa hoặc chỉ lồng 1 cấp):**
+
+```swift
+class Parent {
+    class Child {
+        // ...
+    }
+}
+
+class GrandChild {
+    // ...
+}
+```
+
+**Tools:** SwiftLint (nesting)

package/skill-assets/sunlint-code-quality/rules/swift/SW021-no-extension-access-modifier.md

@@ -0,0 +1,28 @@
+---
+title: Không sử dụng access modifier với extension
+impact: MEDIUM
+impactDescription: Giữ cho extension rõ ràng và nhất quán theo chuẩn Swift style guide.
+tags: swift, ios, extension, access-modifier, style-guide
+---
+
+## Không sử dụng access modifier với extension
+
+Không nên khai báo `public`, `private`, `internal`, hoặc `fileprivate` trực tiếp cho phần `extension`. Quyền truy cập nên được định nghĩa cụ thể cho từng thành phần (biến, hàm) bên trong extension. Điều này giúp kiểm soát truy cập linh hoạt hơn và tránh các hành vi không mong muốn khi gom nhóm code.
+
+**Incorrect (khai báo modifier cho extension):**
+
+```swift
+public extension MyClass {
+    func doSomething() {}
+}
+```
+
+**Correct (khai báo modifier cho thành phần bên trong):**
+
+```swift
+extension MyClass {
+    public func doSomething() {}
+}
+```
+
+**Tools:** SwiftLint (no_extension_access_modifier)

package/skill-assets/sunlint-code-quality/rules/swift/SW022-overridden-super-call.md

@@ -0,0 +1,30 @@
+---
+title: Gọi super trong các phương thức lifecycle
+impact: HIGH
+impactDescription: Đảm bảo các hành vi mặc định của hệ thống được thực thi đúng cách, tránh lỗi UI hoặc logic không đồng bộ.
+tags: swift, ios, uikit, lifecycle, super-call
+---
+
+## Gọi super trong các phương thức lifecycle
+
+Khi override các phương thức lifecycle của hệ thống (như `viewDidLoad`, `viewWillAppear`, `viewDidAppear`, `viewWillDisappear`, v.v. trong UIKit), bạn bắt buộc phải gọi `super.methodName()`. Việc thiếu lời gọi tới lớp cha có thể khiến các khởi tạo mặc định hoặc logic quan trọng của hệ thống không được thực hiện, dẫn đến các lỗi khó xác định.
+
+**Incorrect (không gọi super):**
+
+```swift
+override func viewWillAppear(_ animated: Bool) {
+    // Thiếu super.viewWillAppear(animated)
+    setupTheme()
+}
+```
+
+**Correct (gọi super đầy đủ):**
+
+```swift
+override func viewWillAppear(_ animated: Bool) {
+    super.viewWillAppear(animated)
+    setupTheme()
+}
+```
+
+**Tools:** SwiftLint (overridden_super_call)

package/skill-assets/sunlint-code-quality/rules/swift/SW023-override-in-extension.md

@@ -0,0 +1,32 @@
+---
+title: Không sử dụng override trong extension
+impact: CRITICAL
+impactDescription: Tránh thay đổi hành vi định nghĩa ban đầu của lớp cha qua extension, giữ code ổn định và dễ dự đoán.
+tags: swift, ios, extension, override, architecture
+---
+
+## Không sử dụng override trong extension
+
+Không được `override` thuộc tính hoặc phương thức của lớp cha bên trong một `extension`. Extension được thiết kế để mở rộng tính năng chứ không phải để thay đổi hành vi thừa kế. Nếu cần override, hãy thực hiện việc này trong định nghĩa của chính class đó hoặc class con.
+
+**Incorrect (override trong extension):**
+
+```swift
+extension MyViewController {
+    override func viewDidLoad() { // Nguy hiểm: Không nên override ở đây
+        super.viewDidLoad()
+    }
+}
+```
+
+**Correct (override trong class chính):**
+
+```swift
+class MyViewController: UIViewController {
+    override func viewDidLoad() {
+        super.viewDidLoad()
+    }
+}
+```
+
+**Tools:** SwiftLint (override_in_extension)

package/skill-assets/sunlint-code-quality/rules/swift/SW024-private-over-fileprivate.md

@@ -0,0 +1,28 @@
+---
+title: Ưu tiên private thay vì fileprivate
+impact: MEDIUM
+impactDescription: Giới hạn phạm vi truy cập chặt chẽ nhất có thể, giúp tăng tính đóng gói (encapsulation).
+tags: swift, ios, access-control, private, fileprivate
+---
+
+## Ưu tiên private thay vì fileprivate
+
+Sử dụng `private` để giới hạn phạm vi truy cập trong cùng một khối khai báo `class`/`struct`. Chỉ sử dụng `fileprivate` nếu bạn thực sự cần chia sẻ dữ liệu giữa các class/struct khác nhau cùng nằm trong một file vật lý Duy nhất. Việc lạm dụng `fileprivate` làm loãng tính đóng gói của code.
+
+**Incorrect (dùng fileprivate khi không cần thiết):**
+
+```swift
+class User {
+    fileprivate var name: String = ""
+}
+```
+
+**Correct (dùng private):**
+
+```swift
+class User {
+    private var name: String = ""
+}
+```
+
+**Tools:** SwiftLint (private_over_fileprivate)

package/skill-assets/sunlint-code-quality/rules/swift/SW025-private-unit-test.md

@@ -0,0 +1,32 @@
+---
+title: Không khai báo private cho Unit Test function
+impact: CRITICAL
+impactDescription: Đảm bảo các hàm test có thể được nhận diện và thực thi bởi trình chạy test (test runner).
+tags: swift, ios, unit-test, xctest, access-control
+---
+
+## Không khai báo private cho Unit Test function
+
+Không sử dụng `private` cho các class hoặc function bên trong `XCTestCase`. Các hàm test cần có quyền truy cập `internal` (mặc định) hoặc `public` để Swift test runner có thể gọi và thực thi chúng. Nếu đánh dấu là `private`, các bài test này sẽ bị bỏ qua một cách lặng lẽ.
+
+**Incorrect (test function bị private):**
+
+```swift
+class MyTests: XCTestCase {
+    private func testLoginSuccess() { // Lỗi: Test runner không tìm thấy
+        // ...
+    }
+}
+```
+
+**Correct (hàm test công khai):**
+
+```swift
+class MyTests: XCTestCase {
+    func testLoginSuccess() { // Đúng: Mặc định là internal
+        // ...
+    }
+}
+```
+
+**Tools:** SwiftLint (private_unit_test)

package/skill-assets/sunlint-code-quality/rules/swift/SW026-prohibited-super-call.md

@@ -0,0 +1,29 @@
+---
+title: Không gọi super trong các specific method
+impact: MEDIUM
+impactDescription: Tránh các hành vi không mong muốn hoặc crash khi gọi super trong các hàm mà Apple khuyến nghị không nên gọi.
+tags: swift, ios, uikit, super-call, prohibited-call
+---
+
+## Không gọi super trong các specific method
+
+Không nên gọi `super` nếu phương thức không định nghĩa gì trong lớp cha hoặc bị Apple khuyến nghị không gọi trong các phương thức cụ thể (ví dụ: `loadView()`). Việc gọi `super.loadView()` có thể gây ra các vòng lặp khởi tạo vô hạn hoặc chiếm dụng tài nguyên không cần thiết.
+
+**Incorrect (gọi super trong loadView):**
+
+```swift
+override func loadView() {
+    super.loadView() // Không cần thiết và không được khuyến khích
+    view = MyCustomView()
+}
+```
+
+**Correct (không gọi super):**
+
+```swift
+override func loadView() {
+    view = MyCustomView()
+}
+```
+
+**Tools:** SwiftLint (prohibited_super_call)

package/skill-assets/sunlint-code-quality/rules/swift/SW027-sorted-first-last.md

@@ -0,0 +1,28 @@
+---
+title: Ưu tiên dùng .min() hoặc .max() thay vì sorted().first/last
+impact: CRITICAL
+impactDescription: Tăng hiệu năng đáng kể (O(n) so với O(n log n)) khi tìm phần tử lớn nhất/nhỏ nhất trong collection.
+tags: swift, ios, performance, algorithms, collection
+---
+
+## Ưu tiên dùng .min() hoặc .max() thay vì sorted().first/last
+
+Sử dụng `.min()` hoặc `.max()` thay vì `.sorted().first` hoặc `.sorted().last`. Việc gọi `sorted()` sẽ phải sắp xếp toàn bộ tập hợp (độ phức tạp O(n log n)), trong khi `.min()`/`.max()` chỉ duyệt qua tập hợp đúng 1 lần (độ phức tạp O(n)). Điều này giúp tăng hiệu năng rõ rệt trên các tập dữ liệu lớn.
+
+**Incorrect (sort rồi lấy phần tử đầu/cuối):**
+
+```swift
+let numbers = [5, 3, 8, 1, 9]
+let minNumber = numbers.sorted().first
+let maxNumber = numbers.sorted().last
+```
+
+**Correct (dùng hàm chuyên dụng):**
+
+```swift
+let numbers = [5, 3, 8, 1, 9]
+let minNumber = numbers.min()
+let maxNumber = numbers.max()
+```
+
+**Tools:** SwiftLint (sorted_first_last)