Cree una matriz en Swift desde un object NSData

Estoy intentando almacenar rápidamente una matriz de integers en el disco. Puedo hacer que entren en un object NSData para almacenar, pero es difícil recuperarlos en una matriz. Puedo get un COpaquePointer sin COpaquePointer para los datos con data.bytes pero no puedo encontrar una manera de inicializar una nueva matriz rápida con ese puntero. Alguien sabe como hacerlo?

 import Foundation var arr : UInt32[] = [32,4,123,4,5,2]; let data = NSData(bytes: arr, length: arr.count * sizeof(UInt32)) println(data) //data looks good in the inspector // now get it back into an array? 

Puede usar el método NSData de NSData :

 // the number of elements: let count = data.length / sizeof(UInt32) // create array of appropriate length: var array = [UInt32](count: count, repeatedValue: 0) // copy bytes into array data.getBytes(&array, length:count * sizeof(UInt32)) print(array) // Output: [32, 4, 123, 4, 5, 2] 

Actualización para Swift 3 (Xcode 8): Swift 3 tiene un nuevo tipo struct Data que es un contenedor para datos NS(Mutable)Data con una semántica de valor adecuada. Los methods de acceso son ligeramente diferentes.

Array a datos:

 var arr: [UInt32] = [32, 4, UInt32.max] let data = Data(buffer: UnsafeBufferPointer(start: &arr, count: arr.count)) print(data) // <20000000 04000000 ffffffff> 

Datos a la matriz:

 let arr2 = data.withUnsafeBytes { Array(UnsafeBufferPointer<UInt32>(start: $0, count: data.count/MemoryLayout<UInt32>.size)) } print(arr2) // [32, 4, 4294967295] 

También es posible hacer esto utilizando un UnsafeBufferPointer , que es esencialmente un "puntero de matriz", ya que implementa el protocolo de Sequence :

 let data = NSData(/* ... */) // Have to cast the pointer to the right size let pointer = UnsafePointer<UInt32>(data.bytes) let count = data.length / 4 // Get our buffer pointer and make an array out of it let buffer = UnsafeBufferPointer<UInt32>(start:pointer, count:count) let array = [UInt32](buffer) 

Esto elimina la necesidad de inicializar una matriz vacía con elementos duplicates primero, para luego sobrescribirla, aunque no tengo idea si es más rápida. Como utiliza el protocolo de Sequence esto implica iteración en lugar de copy de memory rápida, aunque no sé si está optimizado cuando se pasa un puntero de búfer. Por otra parte, no estoy seguro de qué tan rápido es el inicializador "crear una matriz vacía con elementos idénticos X".

Aquí hay una forma genérica de hacerlo.

 import Foundation extension Data { func elements <T> () -> [T] { return withUnsafeBytes { Array(UnsafeBufferPointer<T>(start: $0, count: count/MemoryLayout<T>.size)) } } } let array = [1, 2, 3] let data = Data(buffer: UnsafeBufferPointer(start: array, count: array.count)) let array2: [Int] = data.elements() array == array2 // IN THE PLAYGROUND, THIS SHOWS AS TRUE 

Debe especificar el tipo en la línea array2 . De lo contrario, el comstackdor no puede adivinar.

Si está tratando con Data to Array (sé con certeza que mi matriz será [String]), estoy bastante contento con esto:

NSKeyedUnarchiver.unarchiveObject (con: yourData)

Espero que ayude