首页 » Swift » Swift自定义类的存储

Swift自定义类的存储

原文 http://blog.csdn.net/average17/article/details/78236589

2017-10-14 21:20:22阅读(493)

Swift开发中,许多时候会涉及到存储自定义的类,不管是存储到本地文件还是远程服务器,都会涉及到编码和解码的问题。下面就来介绍一下在Swift中怎么存储自定义的类。
在Swift中存储自定义的类有两种方法,一种是Swift 3.0版本的NSCoding,还有一种是Swift 4.0版本的Codable。我们就两种方法来谈谈其中的区别吧。

Swift 3.0: NSCoding

在NSCoding这个协议在OC中就存在,所以自然而然的,Swift也能使用它。使用NSCoding协议,需要这个类继承自NSObject并遵循NSCoding协议,而且还要实现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 aCoder: NSCoder) {
        aCoder.encode(name, forKey: "name")
        aCoder.encode(age, forKey: "age")
    }
    //解码
    required init?(coder aDecoder: NSCoder) {
        self.name = aDecoder.decodeObject(forKey: "name") as! String
        self.age = aDecoder.decodeInteger(forKey: "age")
    }
}

其中编码和解码两个方法就是NSCoding协议中要求实现的两个方法,只有实现了这两个方法,才能将自定义的类序列化和反序列化。接下来,我们就要创建一个Person类的实例,并保存到本地文件中,和从本地文件中读取内容。

let person = Person(name: "Tom", age: 18)
//拿到一个本地文件的URL
let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")
//序列化Person实例
let dataWrite = NSKeyedArchiver.archivedData(withRootObject: person)
do {
    //将数据写入文件
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}
//从本地文件读取数据
if let dataRead = try? Data(contentsOf: url!) {
    //反序列化数据,并将结果强转为Person类的实例
    let person = NSKeyedUnarchiver.unarchiveObject(with: dataRead) as! Person
    //输出内容
    print("name: \(person.name)")  //输出: name: Tom
    print("age: \(person.age)")  //输出: age: 18
} else {
    print("文件不存在,读取本地文件失败")
}

可以看出,当第一步完成之后,保存自定义类就变得非常简单了,只需要使用系统定义好的NSKeyedArchiver类和NSKeyedUnarchiver类就可以了。

Swift 4.0: Codable

接下来再看看Swift 4.0的Codable协议怎么保存自定义类。
在Swift 4.0版本,Apple推出了一个新的协议叫Codable。只要类或者结构体遵循了这个协议,就能够很方便地将类或者结构体的实例转换为JSON数据,并且不需要在类或者结构体中实现编码和解码方法,可以看出,Codable协议比NSCoding协议更加方便、简洁。废话不多说,来看看具体的实现:

class Person: Codable {
    var name: String
    var age: Int
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}
let person = Person(name: "Tom", age: 18)
//拿到一个本地文件的URL
let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")
//将Person实例转换为JSON数据
let dataWrite = try JSONEncoder().encode(person)
do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}
//从本地文件读取数据
if let dataRead = try? Data(contentsOf: url!) {
    //将数据转换为Person实例
    let person = try JSONDecoder().decode(Person.self, from: dataRead)
    //输出内容
    print("name: \(person.name)")  //输出: name: Tom
    print("age: \(person.age)")  //输出: age: 18
} else {
    print("文件不存在,读取本地文件失败")
}

可以看出,Codable协议比NSCoding协议方便很多,而且代码看起来也简洁了很多。

Codable的坑

那可能就有人想问了,既然有了Codable协议,而且还这么简洁,那么NSCoding协议的存在还有什么意义呢?这个问题博主当初也想了很久,后来在一次偶然的机会,发现了Codable协议的不足。先卖个关子,我们来看一个需求:
要求:现有一个AnimalProtocol协议,该协议有一个eat()方法,然后实现两个类Cat和Dog,这两个类都有一个类型为String的name属性,并且需要遵循AnimalProtocol协议,实现eat()方法。创建一个数组,数组中保存若干个Cat实例和Dog实例,将此数组保存到本地文件中,并从文件中读取到相应的内容。

先来看看NSCoding协议是怎么实现这个需求的:

//定义协议
protocol AnimalProtocol {
    func eat()
}
//定义Cat类
class Cat: NSObject, NSCoding, AnimalProtocol {
    var name: String
    init(name: String) {
        self.name = name
    }
    func eat() {
        print("cat \(self.name) eat")
    }
    func encode(with aCoder: NSCoder) {
        aCoder.encode(name, forKey: "name")
    }
    required init?(coder aDecoder: NSCoder) {
        self.name = aDecoder.decodeObject(forKey: "name") as! String
    }
}
//定义Dog类
class Dog: NSObject, NSCoding, AnimalProtocol {
    var name: String
    init(name: String) {
        self.name = name
    }
    func eat() {
        print("dog \(self.name) eat")
    }
    func encode(with aCoder: NSCoder) {
        aCoder.encode(name, forKey: "name")
    }
    required init?(coder aDecoder: NSCoder) {
        self.name = aDecoder.decodeObject(forKey: "name") as! String
    }
}
//创建一个空数组(因为这个数组要同时保存两个类的实例,所以需要以它们共同的一个类型来创建数组)
var animalArray = [AnimalProtocol]()
//然后用循环创建多个Cat和Dog实例,并加入数组中
for i in 1...3 {
    let cat = Cat(name: "cat\(i)")
    let dog = Dog(name: "dog\(i)")
    animalArray.append(cat)
    animalArray.append(dog)
}
let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")
let dataWrite = NSKeyedArchiver.archivedData(withRootObject: animalArray)
do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}
if let dataRead = try? Data(contentsOf: url!) {
    let newArray = NSKeyedUnarchiver.unarchiveObject(with: dataRead) as! [AnimalProtocol]
    for item in newArray {
        item.eat()
    }
}
//输出如下
/*
cat cat1 eat
dog dog1 eat
cat cat2 eat
dog dog2 eat
cat cat3 eat
dog dog3 eat
*/

可以看到,虽然步骤有一点点麻烦,但是还是能很方便地实现我们的需求的,接下来,我们再看看Codable协议是怎么做的吧。
先上代码:

//定义协议
protocol AnimalProtocol: Codable {
    func eat()
}
//定义Cat类
class Cat: AnimalProtocol {
    var name: String
    init(name: String) {
        self.name = name
    }
    func eat() {
        print("cat \(self.name) eat")
    }
}
//定义Dog类
class Dog: AnimalProtocol {
    var name: String
    init(name: String) {
        self.name = name
    }
    func eat() {
        print("dog \(self.name) eat")
    }
}
var animalArray = [AnimalProtocol]()
for i in 1...3 {
    let cat = Cat(name: "cat\(i)")
    let dog = Dog(name: "dog\(i)")
    animalArray.append(cat)
    animalArray.append(dog)
}
let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")
let dataWrite = try JSONEncoder().encode(animalArray)
do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}
if let dataRead = try? Data(contentsOf: url!) {
    let newArray = try JSONDecoder().decode([AnimalProtocol].self, from: dataRead)
    for item in newArray {
        item.eat()
    }
} else {
    print("文件不存在,读取本地文件失败")
}

看代码没错,而且能通过编译,但是一运行,直接crash。还报了一个莫名其妙的错误,错误是这样写的:fatal error: Array does not conform to Encodable because AnimalProtocol does not conform to Encodable.: file /Library/Caches/com.apple.xbs/Sources/swiftlang/swiftlang-900.0.65/src/swift/stdlib/public/core/Codable.swift, line 3962
2017-10-14 19:43:37.565213+0800 study[5383:411423] fatal error: Array does not conform to Encodable because AnimalProtocol does not conform to Encodable.: file /Library/Caches/com.apple.xbs/Sources/swiftlang/swiftlang-900.0.65/src/swift/stdlib/public/core/Codable.swift, line 3962
我去!这就郁闷了,明明我的类遵循了Codable协议,你却说没有遵循,这是什么鬼,而且就算用扩展让Array遵循协议也不可以

extension Array: Codable {
}

难道是遇到鬼了?不会吧!
后来博主请教导师,才知道原来这是Codable的一个不足点。遵循了Codable协议的类的数组,其中的元素必须为同一个类型。虽然这里是用协议类型去创建的数组,但其元素却是遵循了该协议类型的类的实例。所以本质上不尽相同。

如果在这里将AnimalProtocol协议改成一个类的话,虽然在运行时不会崩溃,但却无法将其向下转换为其子类了。代码如下:

//定义父类
class Animal: Codable {
    func eat() {
        print("Animal")
    }
}
//定义Cat类
class Cat: Animal {
    var name: String
    init(name: String) {
        self.name = name
        super.init()
    }
    required init(from decoder: Decoder) throws {
        fatalError("init(from:) has not been implemented")
    }
    override func eat() {
        print("cat \(self.name) eat")
    }
}
//定义Dog类
class Dog: Animal {
    var name: String
    init(name: String) {
        self.name = name
        super.init()
    }
    required init(from decoder: Decoder) throws {
        fatalError("init(from:) has not been implemented")
    }
    override func eat() {
        print("dog \(self.name) eat")
    }
}
var animalArray = [Animal]()
for i in 1...3 {
    let cat = Cat(name: "cat\(i)")
    let dog = Dog(name: "dog\(i)")
    animalArray.append(cat)
    animalArray.append(dog)
}
let manager = FileManager.default
var url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
url?.appendPathComponent("test.txt")
let dataWrite = try JSONEncoder().encode(animalArray)
do {
    try dataWrite.write(to: url!)
} catch {
    print("保存到本地文件失败")
}
if let dataRead = try? Data(contentsOf: url!) {
    let newArray = try JSONDecoder().decode([Animal].self, from: dataRead)
    for item in newArray {
        if item is Cat {
            (item as! Cat).eat()
        } else if item is Dog {
            (item as! Dog).eat()
        } else {
            item.eat()
        }
    }
} else {
    print("文件不存在,读取本地文件失败")
}
/*
输出结果为:
Animal
Animal
Animal
Animal
Animal
Animal
*/

以上便是博主个人的一些看法,如有错误,还请各位看客纠正。

最新发布

CentOS专题

关于本站

5ibc.net旗下博客站精品博文小部分原创、大部分从互联网收集整理。尊重作者版权、传播精品博文,让更多编程爱好者知晓!

小提示

按 Ctrl+D 键,
把本文加入收藏夹