由于Swift 3倾向于Data而不是[UInt8]，我试图找出将各种数字类型(UInt8、Double、Float、Int64等)编码/解码为数据对象的最有效/惯用的方法.
有this answer for using [UInt8]个，但它似乎使用了我在数据上找不到的各种指针API.
我想介绍一些定制的扩展，它们看起来像:
let input = 42.13 // implicit Double
let bytes = input.data
let roundtrip = bytes.to(Double) // --> 42.13
我已经浏览了一堆文档，但真正让我困惑的是，如何获得某种指针(OpaquePointer、BufferPointer或UnsafePointer？)从任何基本 struct (所有数字都是).在C中，我只需在它前面打一个符号，就可以了.
Note:现在代码已经更新了Swift 5(Xcode 10.2).(可以在编辑历史记录中找到Swift 3和Swift 4.2版本.)另外，现在可能正确处理了未对齐的数据.
Data from a value从Swift 4.2开始，只需使用
let value = 42.13
let data = withUnsafeBytes(of: value) { Data($0) }
print(data as NSData) // <713d0ad7 a3104540>
说明:
withUnsafeBytes(of: value)Data($0)来创建数据.Data从Swift 5开始，Data中的withUnsafeBytes(_:)调用闭包，并对字节进行"非类型化"UnsafeMutableRawBufferPointer.load(fromByteOffset:as:)方法从内存中读取值:
let data = Data([0x71, 0x3d, 0x0a, 0xd7, 0xa3, 0x10, 0x45, 0x40])
let value = data.withUnsafeBytes {
$0.load(as: Double.self)
}
print(value) // 42.13
这种方法有一个问题:它要求内存是类型的属性aligned(这里:与8字节地址对齐).但这并不能保证，例如，如果数据是作为另一个Data值的切片获得的.
因此，将字节数设置为copy会更安全:
let data = Data([0x71, 0x3d, 0x0a, 0xd7, 0xa3, 0x10, 0x45, 0x40])
var value = 0.0
let bytesCopied = withUnsafeMutableBytes(of: &value, { data.copyBytes(to: $0)} )
assert(bytesCopied == MemoryLayout.size(ofValue: value))
print(value) // 42.13
说明:
withUnsafeMutableBytes(of:_:)使用覆盖值原始字节的可变缓冲区指针调用闭包.DataProtocol的copyBytes(to:)方法(Data符合)将字节从数据复制到该缓冲区. 返回值copyBytes()是复制的字节数.它等于目标缓冲区的大小，如果数据包含的字节不足，则小于目标缓冲区的大小.
以上转换现在可以很容易地实现为struct Data的通用方法:
extension Data {
init<T>(from value: T) {
self = Swift.withUnsafeBytes(of: value) { Data($0) }
}
func to<T>(type: T.Type) -> T? where T: ExpressibleByIntegerLiteral {
var value: T = 0
guard count >= MemoryLayout.size(ofValue: value) else { return nil }
_ = Swift.withUnsafeMutableBytes(of: &value, { copyBytes(to: $0)} )
return value
}
}
这里添加了约束T: ExpressibleByIntegerLiteral，这样我们就可以轻松地将值初始化为"零"——这并不是真正的限制，因为这种方法可以用于"trival"(整数和浮点)类型，见下文.
例子:
let value = 42.13 // implicit Double
let data = Data(from: value)
print(data as NSData) // <713d0ad7 a3104540>
if let roundtrip = data.to(type: Double.self) {
print(roundtrip) // 42.13
} else {
print("not enough data")
}
类似地，您可以将arrays转换为Data，然后再转换回来:
extension Data {
init<T>(fromArray values: [T]) {
self = values.withUnsafeBytes { Data($0) }
}
func toArray<T>(type: T.Type) -> [T] where T: ExpressibleByIntegerLiteral {
var array = Array<T>(repeating: 0, count: self.count/MemoryLayout<T>.stride)
_ = array.withUnsafeMutableBytes { copyBytes(to: $0) }
return array
}
}
例子:
let value: [Int16] = [1, Int16.max, Int16.min]
let data = Data(fromArray: value)
print(data as NSData) // <0100ff7f 0080>
let roundtrip = data.toArray(type: Int16.self)
print(roundtrip) // [1, 32767, -32768]
上述方法有一个缺点:它实际上只适用于"琐碎的"
所以我们可以解决这个问题
定义一个协议，该协议定义了转换为Data和返回的方法:
protocol DataConvertible {
init?(data: Data)
var data: Data { get }
}
将转换作为协议扩展中的默认方法实现:
extension DataConvertible where Self: ExpressibleByIntegerLiteral{
init?(data: Data) {
var value: Self = 0
guard data.count == MemoryLayout.size(ofValue: value) else { return nil }
_ = withUnsafeMutableBytes(of: &value, { data.copyBytes(to: $0)} )
self = value
}
var data: Data {
return withUnsafeBytes(of: self) { Data($0) }
}
}
我在这里 Select 了一个failable初始值设定项，它判断提供的字节数
最后声明所有类型的一致性，这些类型可以安全地转换为Data并返回:
extension Int : DataConvertible { }
extension Float : DataConvertible { }
extension Double : DataConvertible { }
// add more types here ...
这使得转换更加优雅:
let value = 42.13
let data = value.data
print(data as NSData) // <713d0ad7 a3104540>
if let roundtrip = Double(data: data) {
print(roundtrip) // 42.13
}
第二种方法的优点是，您不能无意中进行不安全的转换.缺点是必须明确列出所有"安全"类型.
您还可以为其他需要进行非平凡转换的类型实现该协议，例如:
extension String: DataConvertible {
init?(data: Data) {
self.init(data: data, encoding: .utf8)
}
var data: Data {
// Note: a conversion to UTF-8 cannot fail.
return Data(self.utf8)
}
}
或者在您自己的类型中实现转换方法，以执行任何需要的操作
上述方法不进行字节顺序转换，数据始终处于
let value = 1000
let data = value.bigEndian.data
print(data as NSData) // <00000000 000003e8>
if let roundtrip = Int(data: data) {
print(Int(bigEndian: roundtrip)) // 1000
}
当然，这种转换通常也可以在泛型中完成