типы номеров Swift туда и обратно в / из данных

как создать Data С

struct Data имеет инициализатор

public init(bytes: UnsafeRawPointer, count: Int)

, которые могут быть использованы аналогичным образом, как и в различных ответах на вопрос как преобразовать double в массив байтов в swift? что вы связали с:

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

как уже сказал @zneak, вы можете взять адрес только a переменная, поэтому переменная копия создается с помощью 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 автоматически выводится из контекст.

как получить значение из Data

NSData у bytes свойство для получения доступа к базовому хранилищу. struct Data есть универсальный

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, 0x3d, 0x0a, 0xd7, 0xa3, 0x10, 0x45, 0x40])
let value: Double = data.withUnsafeBytes { .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 { .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

аналогично, вы можете конвертировать массивы до Data и снова:

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: , 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

вышеуказанный подход имеет один недостаток: как в как преобразовать double в массив байтов в swift?, это на самом деле работает только с "простой" типы, такие как целые числа и с плавающей запятой. "Сложные" типы, такие как Array и String имеют (скрытые) указатели на базовое хранилище и не могут быть передавали, просто копируя сама структура. Он также не будет работать с ссылочные типы, которые являются просто указателями на реальное хранилище объектов.

так что решить эту проблему можно

• определите протокол, который определяет методы преобразования в Data и снова:

  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 { .pointee }
      }
  
      var data: Data {
          var value = self
          return Data(buffer: UnsafeBufferPointer(start: &value, count: 1))
      }
  }
  

  я выбрал a failable инициализатор здесь проверяет, что количество предоставленных байтов соответствует размеру типа.

• и, наконец, объявить соответствие всем типам, которые могут быть безопасно преобразованы в Data и снова:

  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)!
    }
}

или реализовать методы преобразования в ваших собственных типов, чтобы сделать все, что есть надо так сериализовать и десериализовать значение.