在iOS开发中，将自定义对象类型写入文件通常需要将对象序列化为一种可以存储的格式，例如JSON、XML、二进制数据或归档对象。以下是几种常见的方法：
方法1：使用NSCoding协议进行归档
NSCoding协议允许你将对象序列化为二进制数据，然后存储到文件中。这种方法适用于需要存储复杂对象或对象图的场景。
步骤：
让自定义类遵守NSCoding协议
实现encode(with:)方法，用于将对象的属性编码为二进制数据。
实现init?(coder:)方法，用于从二进制数据解码对象。
归档对象
使用NSKeyedArchiver将对象归档为二进制数据并写入文件。
解档对象
使用NSKeyedUnarchiver从文件中读取二进制数据并解码为对象。
示例代码：
swift复制
import Foundation

// 定义一个遵守 NSCoding 协议的自定义类
class Person: NSObject, NSCoding {
var name: String
var age: Int

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

// 编码方法
func encode(with coder: NSCoder) {
    coder.encode(name, forKey: "name")
    coder.encode(age, forKey: "age")
}

// 解码方法
required init?(coder: NSCoder) {
    guard let name = coder.decodeObject(forKey: "name") as? String else { return nil }
    let age = coder.decodeInteger(forKey: "age")
    self.name = name
    self.age = age
}

}

// 归档对象到文件
func archivePerson(person: Person, toFile filePath: String) {
let success = NSKeyedArchiver.archiveRootObject(person, toFile: filePath)
if success {
print("对象已成功归档到文件：(filePath)")
} else {
print("归档失败")
}
}

// 从文件解档对象
func unarchivePerson(fromFile filePath: String) -> Person? {
guard let person = NSKeyedUnarchiver.unarchiveObject(withFile: filePath) as? Person else {
print("解档失败")
return nil
}
return person
}

// 示例：使用归档和解档
let person = Person(name: "John Doe", age: 30)
let filePath = "/path/to/person.archive"

// 归档
archivePerson(person: person, toFile: filePath)

// 解档
if let loadedPerson = unarchivePerson(fromFile: filePath) {
print("加载的姓名：(loadedPerson.name)，年龄：(loadedPerson.age)")
}
方法2：使用Codable协议进行JSON序列化
Codable协议是Swift 4引入的，用于将对象序列化为JSON数据，这种方法适用于需要将数据存储为文本格式或与其他系统交互的场景。
步骤：
让自定义类或结构体遵守Codable协议
Codable是一个类型别名，表示同时遵守Encodable和Decodable协议。
将对象序列化为JSON数据
使用JSONEncoder将对象编码为JSON数据。
将JSON数据写入文件
使用Data的write(to:)方法将JSON数据写入文件。
从文件读取JSON数据并解码为对象
使用JSONDecoder将JSON数据解码为对象。
示例代码：
swift复制
import Foundation

// 定义一个遵守 Codable 协议的自定义结构体
struct Person: Codable {
var name: String
var age: Int
}

// 将对象序列化为 JSON 数据并写入文件
func savePerson(person: Person, toFile filePath: String) throws {
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted // 格式化输出
let jsonData = try encoder.encode(person)
try jsonData.write(to: URL(fileURLWithPath: filePath))
print("对象已成功保存到文件：(filePath)")
}

// 从文件读取 JSON 数据并解码为对象
func loadPerson(fromFile filePath: String) throws -> Person {
let jsonData = try Data(contentsOf: URL(fileURLWithPath: filePath))
let decoder = JSONDecoder()
let person = try decoder.decode(Person.self, from: jsonData)
return person
}

// 示例：使用 JSON 编码和解码
let person = Person(name: "John Doe", age: 30)
let filePath = "/path/to/person.json"

do {
// 保存到文件
try savePerson(person: person, toFile: filePath)

// 从文件加载
let loadedPerson = try loadPerson(fromFile: filePath)
print("加载的姓名：\(loadedPerson.name)，年龄：\(loadedPerson.age)")

} catch {
print("发生错误：(error)")
}
方法3：使用UserDefaults存储简单数据
如果你需要存储简单的数据（如字符串、数字、数组等），可以使用UserDefaults。这种方法适用于存储少量的配置数据或用户偏好设置。
示例代码：
swift复制
import Foundation

// 保存数据到 UserDefaults
func saveDataToUserDefaults(name: String, age: Int) {
let defaults = UserDefaults.standard
defaults.set(name, forKey: "name")
defaults.set(age, forKey: "age")
print("数据已保存到 UserDefaults")
}

// 从 UserDefaults 加载数据
func loadDataFromUserDefaults() -> (name: String?, age: Int?) {
let defaults = UserDefaults.standard
let name = defaults.string(forKey: "name")
let age = defaults.integer(forKey: "age")
return (name, age)
}

// 示例：使用 UserDefaults
saveDataToUserDefaults(name: "John Doe", age: 30)

if let name = loadDataFromUserDefaults().name, let age = loadDataFromUserDefaults().age {
print("加载的姓名：(name)，年龄：(age)")
}
方法4：使用数据库（如Core Data或SQLite）
如果需要存储大量结构化数据，可以使用数据库。Core Data是iOS开发中常用的ORM框架，而SQLite是一个轻量级的数据库。
示例：使用Core Data
创建Core Data模型
在Xcode中创建一个新的Core Data模型文件（.xcdatamodeld），定义实体和属性。
保存数据到Core Data
使用NSManagedObjectContext插入和保存数据。
从Core Data加载数据
使用NSFetchRequest查询数据。
示例代码（Core Data）：
swift复制
import CoreData

// 获取 Core Data 的上下文
guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
let context = appDelegate.persistentContainer.viewContext

// 创建一个新的 Person 实体
let person = Person(context: context)
person.name = "John Doe"
person.age = 30

// 保存上下文
do {
try context.save()
print("数据已成功保存到 Core Data")
} catch {
print("保存失败：(error)")
}

// 查询数据
let fetchRequest: NSFetchRequest<Person> = Person.fetchRequest()
do {
let results = try context.fetch(fetchRequest)
for person in results {
print("姓名：(person.name ?? "未知")，年龄：(person.age)")
}
} catch {
print("查询失败：(error)")
}
总结
NSCoding：适用于复杂对象的二进制归档，适合本地存储。
Codable：适用于JSON序列化，适合本地存储或网络传输。
UserDefaults：适用于存储简单的配置数据。
数据库（如Core Data或SQLite）：适用于存储大量结构化数据。
根据你的具体需求选择合适的方法。