1import RealmSwift
2
3class Task: Object {
4    @Persisted var title: String = ""
5    @Persisted var isCompleted: Bool = false
6    @Persisted var priority: Int = 0
7    @Persisted var createdAt: Date = Date()
8}
9
10let realm = try! Realm()
11let results: Results<Task> = realm.objects(Task.self)
12
13// Results is lazy and auto-updating
14print(results.count)  // Queries the database
15// If another thread adds a task, count changes on next access

1let realm = try! Realm()
2
3// Query
4let results: Results<Task> = realm.objects(Task.self)
5    .filter("isCompleted == false")
6    .sorted(byKeyPath: "priority", ascending: false)
7
8// Convert to Array
9let tasksArray: [Task] = Array(results)
10
11// Now you have a standard Swift Array
12print(tasksArray.count)
13print(tasksArray.first?.title ?? "No tasks")
14
15// Array methods work normally
16let titles = tasksArray.map { $0.title }
17let highPriority = tasksArray.filter { $0.priority > 5 }
18let indexed = tasksArray.enumerated().map { ($0.offset, $0.element.title) }

1let realm = try! Realm()
2let allTasks = realm.objects(Task.self)
3
4// Filter with Realm's query engine (faster, uses indexes)
5let realmFiltered = allTasks.filter("priority > 3")
6let filteredArray = Array(realmFiltered)
7
8// Or convert first, then filter with Swift (more flexible)
9let allArray = Array(allTasks)
10let swiftFiltered = allArray.filter { $0.priority > 3 && $0.title.contains("Bug") }
11
12// Map to different type
13let taskSummaries: [(String, Bool)] = Array(allTasks).map { ($0.title, $0.isCompleted) }
14
15// Reduce
16let totalPriority = Array(allTasks).reduce(0) { $0 + $1.priority }
17
18// Compact map
19let completedTitles: [String] = Array(allTasks).compactMap {
20    $0.isCompleted ? $0.title : nil
21}

1// PREFERRED — Realm filters use database indexes
2let fast = Array(realm.objects(Task.self).filter("priority > 5"))
3
4// SLOWER — loads ALL objects, then filters in memory
5let slow = Array(realm.objects(Task.self)).filter { $0.priority > 5 }

1let realm = try! Realm()
2let tasks = realm.objects(Task.self)
3
4// Sort with Realm (uses database-level sorting)
5let realmSorted = Array(tasks.sorted(byKeyPath: "createdAt", ascending: false))
6
7// Sort after conversion (more flexible sort options)
8let swiftSorted = Array(tasks).sorted { a, b in
9    if a.priority == b.priority {
10        return a.createdAt > b.createdAt
11    }
12    return a.priority > b.priority
13}
14
15// Multiple sort descriptors in Realm
16let multiSorted = Array(tasks.sorted(by: [
17    SortDescriptor(keyPath: "isCompleted", ascending: true),
18    SortDescriptor(keyPath: "priority", ascending: false)
19]))

1let realm = try! Realm()
2let results = realm.objects(Task.self).filter("isCompleted == false")
3
4// Freeze creates thread-safe, immutable copies
5let frozenResults = results.freeze()
6let frozenArray = Array(frozenResults)
7
8// Safe to pass to another thread
9DispatchQueue.global().async {
10    for task in frozenArray {
11        print(task.title)  // Works — frozen objects are thread-safe
12    }
13}

1let tasks = Array(realm.objects(Task.self))
2
3DispatchQueue.global().async {
4    // CRASH: "Realm accessed from incorrect thread"
5    print(tasks.first?.title ?? "")
6}

1import SwiftUI
2import RealmSwift
3
4struct TaskListView: View {
5    @ObservedResults(Task.self, filter: NSPredicate(format: "isCompleted == false"),
6                     sortDescriptor: SortDescriptor(keyPath: "priority", ascending: false))
7    var tasks
8
9    var body: some View {
10        List {
11            // @ObservedResults provides Results<Task> directly
12            ForEach(tasks) { task in
13                Text(task.title)
14            }
15        }
16    }
17
18    // When you need an Array (e.g., for a chart library)
19    var taskData: [Task] {
20        Array(tasks)
21    }
22}

1struct TaskDTO {
2    let title: String
3    let isCompleted: Bool
4    let priority: Int
5}
6
7extension Task {
8    func toDTO() -> TaskDTO {
9        TaskDTO(title: title, isCompleted: isCompleted, priority: priority)
10    }
11}
12
13let realm = try! Realm()
14let dtos: [TaskDTO] = Array(realm.objects(Task.self)).map { $0.toDTO() }
15// dtos are plain structs — no Realm dependency, thread-safe, Codable-ready