La conversion de NSData en Entier en Swift

En Objective-C du code regardé aimé ce et a fonctionné parfaitement,

NSInteger random = arc4random_uniform(99) + 1 
NSData *data = [NSData dataWithBytes:& random length: sizeof(random)];
int value = *(int*)([data bytes]);

Comment cela peut-il être fait dans Swift?

OriginalL'auteur dhint4 | 2014-10-07

14

Comme ceci:
```
var src: NSInteger = 2525
var out: NSInteger = 0

let data = NSData(bytes: &src, length: sizeof(NSInteger))
data.getBytes(&out, length: sizeof(NSInteger))
println(out) // ==> 2525
```
Absolument parfait! Merci!!!!
ou sizeofValue(random)
Dans Swift3: sizeof(NSInteger) devient MemoryLayout<NSInteger>.la taille et la println devient d'impression.
Notez que pour obtenir la taille directement à partir du type de l'objet dans Swift 3 ou version ultérieure de sizeofValue est MemoryLayout.size(ofValue: value)

OriginalL'auteur findall
7

Dans Swift 4:

Il ya un couple de choses à considérer lors de l'extraction d'une valeur de nombre entier à partir d'un Data flux. Ce paramètre et Endianess. Donc, je suis venu avec une fonction dans une extension de Data qui déduit ce paramètre du type d'entier que vous voulez extraire et passe Endianess et Index en tant que paramètres. Les types d'entiers qui peuvent être extraites sont tous conformes à la FixedWidthInteger protocole.

Rappel: Cette fonction ne vérifie pas si le Index gamme est à l'intérieur des limites de la Data tampon de sorte qu'il peut se bloquer en fonction de la taille du type de l'extraction par rapport à la fin de la mémoire tampon.
```
extension Data {
    enum Endianness {
        case BigEndian
        case LittleEndian
    }
    func scanValue<T: FixedWidthInteger>(at index: Data.Index, endianess: Endianness) -> T {
        let number: T = self.subdata(in: index..<index + MemoryLayout<T>.size).withUnsafeBytes({ $0.pointee })
        switch endianess {
        case .BigEndian:
            return number.bigEndian
        case .LittleEndian:
            return number.littleEndian
        }
    }
}
```
Exemple:
```
let data = Data(bytes: [0xFF,0x1F,0x1F,0xFF])

let number1 = data.scanValue(at: 0, endianess: .LittleEndian) as UInt16
let number2 = data.scanValue(at: 0, endianess: .BigEndian) as UInt16

let number3: Int16 = data.scanValue(at: 2, endianess: .LittleEndian)
let number4: Int16 = data.scanValue(at: 2, endianess: .BigEndian)
```
Résultats:

number1 is 8191

number2 is 65311

number3 is -225

number4 is 8191

Observer les appels de fonction pour voir comment le type extrait est déduite. Bien sûr Endianess ne fait pas de sens pour Int8 ou UInt8, mais la fonction fonctionne comme prévu.

Valeurs peuvent ensuite être jeté à Int si nécessaire.

Hi - Ont u obtenu une solution beaucoup plus simple pour juste la conversion des données <02> UInt8 2 ou 2 Int?
La façon la plus simple d'obtenir un UInt8 est de simplement utiliser un indice si vous savez exactement à l'index de l'octet que vous voulez: data[index]
Data.Index à l'intérieur d'un Data extension est redondante. Utiliser seulement Index

OriginalL'auteur Gustavo Seidler
6

Pour Swift 3, vous pouvez le faire (petit-boutiste, mais similaire pour les grands):
```
func getInt(fromData data: Data, start: Int) -> Int32 {
  let intBits = data.withUnsafeBytes({(bytePointer: UnsafePointer<UInt8>) -> Int32 in
    bytePointer.advanced(by: start).withMemoryRebound(to: Int32.self, capacity: 4) { pointer in
      return pointer.pointee
    }
  })
  return Int32(littleEndian: intBits)
}
```
Vous pouvez modifier, ajouter les génériques, etc. pour s'adapter à d'autres types primitifs (et varient en fonction de l'endianness des octets de données).

C'est vraiment la chose qui ne m'irrite un peu à propos de Swift. C'est extrêmement compliqué les choses pour quelque chose qui est techniquement très simple. Je me demande si le compilateur optimise tous les bs loin

OriginalL'auteur benasher44
5

Vous pourriez trouver cette méthode utile si vous faites beaucoup de choses:
```
func readInteger<T : IntegerType>(data : NSData, start : Int) -> T {
    var d : T = 0
    data.getBytes(&d, range: NSRange(location: start, length: sizeof(T)))
    return d
}
```
La fonction prend comme paramètre la position de départ dans les données à lire le type numérique et elle renvoie une valeur de type inféré à partir de ce que vous êtes en l'assignant à.

Par exemple:
```
let i : UInt32 = readInteger(data, 10);
```
lit un 4 octets entier à partir de la position 10 dans les données.

Si vous modifiez UInt32 à UInt16 il va lire deux octets.

veuillez élaborer un peu plus sur la façon de l'utiliser et quels sont les paramètres à passer... merci.

OriginalL'auteur rghome

Données entier merci @rghome

//MARK: - Extensions Data

extension Data {

    ///To interger Data by range
    ///
    ///- Parameters:
    ///  - data:       Data
    ///  - startRange: StartRange
    ///  - endRange:   EndRange
    ///- Returns:      Integer Typed
    func toInterger<T : Integer>(withData data: NSData, withStartRange startRange: Int, withSizeRange endRange: Int) -> T {
        var d : T = 0
        (self as NSData).getBytes(&d, range: NSRange(location: startRange, length: endRange))
        return d
    }
}

101010
let value:Int = Data().toInterger(withStartRange: 0, withEndRange: 2)
get 10
get 2 Int

merci à @rghome 🙂

OriginalL'auteur YannickSteph

Ma contribution avec une swift 3.1 extension :

extension NSData{
    var int :  Int{
        var out: Int = 0
        self.getBytes(&out, length: MemoryLayout<Int>.size)
        return out
    }
}

Appelez simplement .int pour obtenir votre valeur, juste comme ça :

let value = 50
let data = NSData(bytes: &value, length: 4)
print(data.int)

OriginalL'auteur Kevin ABRIOUX

Vous pouvez prolonger le protocole de Données, créer un générique metho, retourner les octets de la mémoire de données de la mémoire et de le jeter ou de définir le type obtenu explicitement en tant que de besoin:

extension Data {
    func object<T>() -> T {
        precondition(MemoryLayout<T>.size == count)
        return withUnsafeBytes{ $0.pointee }
    }
}

let data = Data([0xFF, 0x1F])   //2 bytes

let uint16: UInt16 = data.object()      //8191  littleEndian
let number1 = uint16.littleEndian       //8191
let number2 = uint16.bigEndian          //65311

let int16: Int16 = data.object()        //8191   littleEndian
let number3 = int16.littleEndian        //8191
let number4 = int16.bigEndian           //-225

print(number1) //8191
print(number2) //65311
print(number3) //8191
print(number4) // -225

Tests avec Int

let random = Int.random(in: 1...100)    //15 UInt32
let data = random.data                  // 8 bytes  [15, 0, 0, 0, 0, 0, 0, 0]

Tests avec UInt32

let random = UInt32.random(in: 1...100)  //90 UInt32
let data = random.data                   // 4 bytes  [90, 0, 0, 0]

Tests avec Double

let random = Double.random(in: 0...1)  //0.2463145485351322 Double
let data = random.data                 // 8 bytes  [12, 99, 62, 49, 60, 135, 207, 63]

Si vous voulez extraire une subdata simplement indice de vos données:

let data = Data([0xFF, 0x1F, 0x1F, 0xFF])      //4 bytes
let startIndex = 2

let uint16: UInt16 = data[startIndex..<startIndex.advanced(by: MemoryLayout<UInt16>.size)].object()       // 65311 littleEndian
let number1 = uint16.littleEndian              //65311
let number2 = uint16.bigEndian                 //8191

let int16: Int16 = data[startIndex..<startIndex.advanced(by: MemoryLayout<Int16>.size)].object()       //-225   littleEndian
let number3 = int16.littleEndian               //-225
let number4 = int16.bigEndian                  //8191

number1 //65311
number2 //8191
number3 //-225
number4 // 8191

OriginalL'auteur Leo Dabus

Vous devez vous connecter pour publier un commentaire.

Dans Swift 4: