往返Swift数字类型到/从数据

let input = 42.13 // implicit Double
let bytes = input.data
let roundtrip = bytes.to(Double) // --> 42.13

如何从值创建数据

struct Data有一个初始化器

public init(bytes: UnsafeRawPointer,count: Int)

其可以以与对问题的各种答案类似的方式使用
How to convert a double into a byte array in swift?
您链接到：

let input = 42.13
var value = input
let data = withUnsafePointer(to: &value) {
    Data(bytes: UnsafePointer($0),count: MemoryLayout.size(ofValue: input))
}
print(data as NSData) // <713d0ad7 a3104540>

因为@zneak已经说过，你可以只取一个变量的地址，
因此，使用var value = value创建一个变量副本。
在早期的Swift版本中，你可以通过做
函数参数本身是一个变量，这不再支持了。

但是，使用初始化程序更容易

public init<SourceType>(buffer: UnsafeBufferPointer<SourceType>)

代替：

let input = 42.13
var value = input
let data = Data(buffer: UnsafeBufferPointer(start: &value,count: 1))
print(data as NSData) // <713d0ad7 a3104540>

请注意，通用占位符SourceType将从中自动推断
上下文。

如何从数据中检索值

NSData有一个bytes属性来访问底层存储。
struct数据有一个通用

public func withUnsafeBytes<ResultType,ContentType>(_ body: @noescape (UnsafePointer<ContentType>) throws -> ResultType) rethrows -> ResultType

相反，它可以这样使用：

let data = Data(bytes: [0x71,0x3d,0x0a,0xd7,0xa3,0x10,0x45,0x40])
let value = data.withUnsafeBytes { (ptr: UnsafePointer<Double>) -> Double in
    return ptr.pointee
}
print(value) // 42.13

如果ContentType可以从上下文推断，则不需要指定它
在闭包中，这样可以简化为

let data = Data(bytes: [0x71,0x40])
let value: Double = data.withUnsafeBytes { $0.pointee }
print(value) // 42.13

通用解决方案#1

以上转换现在可以轻松实现为struct的通用方法Data：

extension Data {

    init<T>(from value: T) {
        var value = value
        self.init(buffer: UnsafeBufferPointer(start: &value,count: 1))
    }

    func to<T>(type: T.Type) -> T {
        return self.withUnsafeBytes { $0.pointee }
    }
}

例：

let input = 42.13 // implicit Double
let data = Data(from: input)
print(data as NSData) // <713d0ad7 a3104540>

let roundtrip = data.to(type: Double.self)
print(roundtrip) // 42.13

类似地，您可以将数组转换为数据并返回：

extension Data {

    init<T>(fromArray values: [T]) {
        var values = values
        self.init(buffer: UnsafeBufferPointer(start: &values,count: values.count))
    }

    func toArray<T>(type: T.Type) -> [T] {
        return self.withUnsafeBytes {
            [T](UnsafeBufferPointer(start: $0,count: self.count/MemoryLayout<T>.stride))
        }
    }
}

例：

let input: [Int16] = [1,Int16.max,Int16.min]
let data = Data(fromArray: input)
print(data as NSData) // <0100ff7f 0080>

let roundtrip = data.toArray(type: Int16.self)
print(roundtrip) // [1,32767,-32768]

通用解决方案#2

上述方法有一个缺点：
How to convert a double into a byte array in swift?，
它实际上只与“简单”
类型如整数和浮点类型。 “复杂”类型如Array
和String有(隐藏)指向底层存储的指针，不能
通过只复制结构本身传递。它也不会工作
引用类型只是指向真实对象存储的指针。

所以解决这个问题，一个可以

>定义一个协议，定义转换为数据并返回的方法：

protocol DataConvertible {
    init?(data: Data)
    var data: Data { get }
}

>在协议扩展中将转换实现为默认方法：

extension DataConvertible {

    init?(data: Data) {
        guard data.count == MemoryLayout<Self>.size else { return nil }
        self = data.withUnsafeBytes { $0.pointee }
    }

    var data: Data {
        var value = self
        return Data(buffer: UnsafeBufferPointer(start: &value,count: 1))
    }
}

我在这里选择一个可用的初始化程序，检查提供的字节数
匹配类型的大小。
>最后声明符合所有类型，可以安全地转换为数据并返回：

extension Int : DataConvertible { }
extension Float : DataConvertible { }
extension Double : DataConvertible { }
// add more types here ...

这使得转换更加优雅：

let input = 42.13
let data = input.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 self.data(using: .utf8)!
    }
}

或者在你自己的类型中实现转换方法来做任何事情必须这样序列化和反序列化一个值。