如何将 Int 附加到新的 Data 结构（Swift 3）答案

【问题标题】：How to append Int to the new Data struct (Swift 3)如何将 Int 附加到新的 Data 结构（Swift 3）
【发布时间】：2016-06-20 12:13:27
【问题描述】：

使用NSMutableData，我可以创建Int's 或Float 的数组并将它们存储到磁盘。

protocol BinaryConvertible
{
    init()
}

extension Int : BinaryConvertible {}


struct Storage<T: BinaryConvertible>
{
let data = NSMutableData()

func append(value: T)
{
    var input = value
    data.append(&input, length: sizeof(T))
}

func extract(index: Int) -> T
{
    var output = T()
    let range = NSRange(location: index * sizeof(T), length: sizeof(T))
    data.getBytes(&output, range: range)
    return output
}
}

Swift 3 有一个新的Data 类型，它在底层使用NSData。喜欢String 和NSString。我不知道如何添加例如使用新方法的Double。

append 函数现在需要一个 UnsafePointer<UInt8>，但是如何从 Double 或任何随机结构创建它？

【问题讨论】：

Cast a Swift struct to UnsafeMutablePointer<Void>的可能重复
我不这么认为。在 swift 3 Data 中需要 UnsafePointer。注意 UInt8 类型。到目前为止，我发现的所有内容都与 UnsafePointer 指针有关。我需要获取字节，以便将它们写入磁盘，然后再读取这些字节。
我没看到。如何将 double 转换为可以附加到 Data 的一系列字节 Uint8（不是 NSData 或 NSMutableData，而是新的 Swift 3 Data 结构）？然后做相反的事情：读取字节并将它们转换回 Double。

标签： nsdata swift3

【解决方案1】：

使用指针是我在 Swift 中最不喜欢做的事情之一，但它也提供了良好的学习体验。这对我有用：

struct Storage<T: BinaryConvertible>
{
    var data = Data()

    mutating func append(value: T)
    {
        var input = value
        let buffer = UnsafeBufferPointer(start: &input, count: 1)
        self.data.append(buffer)
    }

    func extract(index: Int) -> T
    {
        let startIndex = index * sizeof(T)
        let endIndex = startIndex + sizeof(T)

        var output = T()
        let buffer = UnsafeMutableBufferPointer(start: &output, count: 1)
        let _ = self.data.copyBytes(to: buffer, from: startIndex..<endIndex)

        return output
    }
}

var s = Storage<Double>()
s.append(value: M_PI)
s.append(value: 42)
s.append(value: 100)

print(s.extract(index: 0))
print(s.extract(index: 1))
print(s.extract(index: 2))

【讨论】：

嗨，我在文档中找不到 BinaryConvertible，这是你编的协议/类吗？在这种情况下将如何实现？谢谢

【解决方案2】：

我喜欢使用 + 或 +=

public protocol DataConvertible {
    static func + (lhs: Data, rhs: Self) -> Data
    static func += (lhs: inout Data, rhs: Self)
}

extension DataConvertible {
    public static func + (lhs: Data, rhs: Self) -> Data {
        var value = rhs
        let data = Data(buffer: UnsafeBufferPointer(start: &value, count: 1))
        return lhs + data
    }

    public static func += (lhs: inout Data, rhs: Self) {
        lhs = lhs + rhs
    }
}

extension UInt8 : DataConvertible { }
extension UInt16 : DataConvertible { }
extension UInt32 : DataConvertible { }

extension Int : DataConvertible { }
extension Float : DataConvertible { }
extension Double : DataConvertible { }

extension String : DataConvertible {
    public static func + (lhs: Data, rhs: String) -> Data {
        guard let data = rhs.data(using: .utf8) else { return lhs}
        return lhs + data
    }
}

extension Data : DataConvertible {
    public static func + (lhs: Data, rhs: Data) -> Data {
        var data = Data()
        data.append(lhs)
        data.append(rhs)

        return data
    }
}

样本

var data = Data()
data += 1
data += 1.0
data += UInt8(1)
data += "1"

【讨论】：