引用类型
使用 swift 的 Data 和 NSMutableData 作对比
var sampleBytes: [UInt8] = [0x0b, 0xad, 0xf0, 0x0d]
let nsData = NSMutableData(bytes: sampleBytes, length: sampleBytes.count)
复制代码
在这里,我们使用了 let 来修饰 nsData 变量,但是因为 NSMutableData 是一个引用类型,swift 的 let/var 关键字不能控制它。对于引用类型,let 只能保证 nsData 不被指向其他实例,但是我们可以修改他:
nsData.append(sampleBytes, length: sampleBytes.count)
复制代码
因为我们操作的是一个对象,在以下例子中,两个对象都会发生改变:
// 两者都指向同一个对象,所以都改变了
let nsOtherData = nsData
nsData.append(sampleBytes, length: sampleBytes.count)
复制代码
如果不希望 nsOtherData 也随之改变,可以使用 mutableCopy
// 这样 nsOtherData 就不会改变
let nsOtherData = nsData.mutableCopy() as! NSMutableData
nsData.append(sampleBytes, length: sampleBytes.count)
复制代码
值类型
现在我们看一下 Data 类型,这是一个结构体
let data = Data(bytes: sampleBytes, count: sampleBytes.count) 这里我们使用了 let 修饰,这样就不能修改 data 的值,除非将他设置为 var。并且将 data 赋值给别的变量,修改变量也不会影响 data。
值类型和引用类型之间的差异在于,当你将一个值类型赋值给别的变量或者作为函数参数时,只是对值进行了赋值。但是将引用类型分配给其他变量时,只会创建指向内存中同一个对象的第二个引用。
当我们创建一个副本时,结构体被逐个复制。但是这不意味着 Data 的值直接被复制过去,因为 Data 有一个内部的内存引用。当结构体被复制时,只是引用被复制给新值。只有当复制的变量值改变时,才会将值复制过去。
写时复制
在Swift中采用的优化方式叫做写时复制技术,简单的说就是,只有当一个结构体发生了写入行为时才会有复制行为。具体的做法就是,在结构体内部用一个引用类型来存储实际的数据,在不进行写入操作的普通传递过程中,都是将内部的reference的应用计数+1,在进行写入操作时,对内部的reference做一次copy操作用来存储新的数据,防止和之前的reference产生意外的数据共享。
在这里我们将实现一个很简单的结构体版本,来更好的理解写时复制
struct MyData {
var data = NSMutableData()
mutating func append(_ bytes: [UInt8]) {
data.append(bytes, length: bytes.count)
}
}
复制代码
接下来看看结果如何
var data = MyData()
var copy = data
data.append(sampleBytes)
复制代码
Copy 还是被改变了,这是因为在结构体复制时,将引用复制了过去,这个引用指向了实际的值,所以 copy 还是被改变,以下代码就可以修复这个问题
struct MyData {
var data = NSMutableData()
mutating func append(_ bytes: [UInt8]) {
print("making a copy")
data = data.mutableCopy() as! NSMutableData
data.append(bytes, length: bytes.count)
}
}
复制代码
现在 copy 的值不会被改变了,接下来重构一下结构体,更加优雅点:
struct MyData {
var data = NSMutableData()
var dataForWriting: NSMutableData {
mutating get {
print("making a copy")
data = data.mutableCopy() as! NSMutableData
return data
}
}
mutating func append(_ bytes: [UInt8]) {
dataForWriting.append(bytes, length: bytes.count)
}
}
复制代码
让写时复制更高效 目前的做法是很幼稚的,我们会在每次 append 的时候都去复制,而不去管我们是这个对象的唯一拥有者,例如以下代码:
for _ in 0..<10 {
data.append(sampleBytes)
}
// This prints:
// making a copy
// making a copy
// making a copy
// making a copy
// making a copy
// making a copy
// making a copy
// making a copy
// making a copy
// making a copy
复制代码
以上代码在理想情况下应该只 copy 一次,想这样做的话也很简单,使用 isKnownUniquelyReferenced 方法,这个方法可以判断传入的参数是否已经有一个强引用
struct MyData {
var dataForWriting: NSMutableData {
mutating get {
if isKnownUniquelyReferenced(&data) {
return data
}
print("making a copy")
data = data.mutableCopy() as! NSMutableData
return data
}
}
}
复制代码
但是上面的代码还是没有起效的,因为 isKnownUniquelyReferenced 只适用于 swift 对象,现在我们来将 NSMutableData 包装为 swift 对象:
final class Box<A> {
// 使用这个常量
let unbox: A
init(_ value: A) {
unbox = value
}
}
struct MyData {
var data = Box(NSMutableData())
var dataForWriting: NSMutableData {
mutating get {
if isKnownUniquelyReferenced(&data) {
return data.unbox
}
print("making a copy")
data = Box(data.unbox.mutableCopy() as! NSMutableData)
return data.unbox
}
}
mutating func append(_ bytes: [UInt8]) {
dataForWriting.append(bytes, length: bytes.count)
}
}
复制代码
现在我们再去进行之前的遍历操作会发现只复制了一次,有点类似 lazy
写时复制也不是时时起效
(0..<10).reduce(data) { result, _ in
var copy = result
copy.append(sampleBytes)
return copy
}
复制代码
上面的写法会 copy10次,所以写时复制也不是万能的,但是一般情况下不会出现这种问题。
上面 reduce 内部做了什么?
-
(0..<10) 代表了闭包会进行10次
-
接受了一个初始值参数,并将这个初始值作为第一次遍历的 result 的值
-
返回的 copy 作为下一次循环的 result 值
参考自: swift talk
转载自:简书