Konvertieren NSData an Integer in Swift

In Objective-C code sah diese und funktionierte einwandfrei,

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

Wie kann man das in Swift?

InformationsquelleAutor dhint4 | 2014-10-07

14

Wie diese:
```
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
```
- Absolut perfekt! Danke!!!
- oder sizeofValue(random)
- In Swift3: sizeof(NSInteger) wird MemoryLayout<NSInteger>.Größe und println wird gedruckt.
- Beachten Sie, dass für Sie immer die Größe, die direkt von der Art nicht das Objekt in Swift 3 oder einer späteren version von sizeofValue ist MemoryLayout.size(ofValue: value)
InformationsquelleAutor findall
8

Im Swift 4:

Gibt es ein paar Dinge zu beachten, wenn man ein integer-Wert aus einer Data stream. Fehler und endian Typ. So kam ich mit einer Funktion in eine extension zu Data folgert, dass Fehler vom Typ integer, die Sie extrahieren möchten, und übergibt endian Typ und Index als Parameter. Die Typen der ganzen zahlen, die extrahiert werden können, sind alle, die sich konform zu FixedWidthInteger Protokoll.

Erinnerung: Diese Funktion nicht überprüfen, ob die Index Bereich ist innerhalb der Grenzen des Data Puffer auf, so dass es Abstürzen kann, abhängig von der Größe des Typs, die extrahiert wird, in Bezug auf das Ende des Puffers.
```
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
        }
    }
}
```
Beispiel:
```
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)
```
Ergebnisse:

number1 is 8191

number2 is 65311

number3 is -225

number4 is 8191

Beachten Sie die Funktion Aufrufe um zu sehen, wie der Typ, der extrahiert werden, ist zufällig. Natürlich endian Typ macht keinen Sinn für Int8 oder UInt8, aber die Funktion arbeitet wie erwartet.

Werte kann später umgewandelt werden, um Int wenn nötig.
- Hi - Habe u hab eine viel einfachere Lösung nur für die Umwandlung von Daten <02> zu UInt8 2 oder 2 Int?
- Der einfachste Weg, um einen UInt8 ist einfach zu benutzen, eine Tiefstellung wenn Sie genau wissen, der index der byte, die Sie wollen: data[index]
- Data.Index innerhalb einer Data Erweiterung überflüssig ist. Verwenden Sie nur Index
- Ich denke, Sie sollten mit MemoryLayout.stride - nicht size. Siehe die Dokumentation für stride, die es definieren als "Die Anzahl der bytes vom Anfang einer Instanz von T, um den Anfang des nächsten, wenn gespeichert in zusammenhängenden Speicher oder in einem Array<T>" und "die Anzahl der bytes verschoben werden, wenn ein UnsafePointer<T> Instanz ist erhöht"
InformationsquelleAutor Gustavo Seidler
6

Für Swift 3, können Sie dies tun (little-endian, aber ähnlich groß):
```
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)
}
```
Können Sie ändern, ergänzen generics, etc. passen andere primitive Typen (und variieren je nach den endian der Daten-bytes).
- Das ist wirklich die Sache, das ärgert mich ein bisschen über Swift. Dies ist eine äußerst komplizierte Dinge, für etwas, das ist technisch extrem einfach. Ich Frage mich, ob der compiler optimiert alle bs Weg
InformationsquelleAutor benasher44
5

Finden Sie vielleicht diese Methode ist nützlich, wenn Sie es tun, eine Menge:
```
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
}
```
Die Funktion nimmt als parameter den start-position in den Daten zu Lesen, die einen numerischen Typ, und es gibt einen Wert zurück, der eine Art abgeleitet werden, was Sie sind zuweisen.

Beispiel:
```
let i : UInt32 = readInteger(data, 10);
```
liest eine 4-byte-Ganzzahl von position 10 in den Daten.

Wenn Sie ändern UInt32 zu UInt16 es liest zwei bytes.
- bitte erläutern Sie einige mehr, wie man es benutzt und was sind die Parameter zu übergeben... danke.
InformationsquelleAutor rghome

Daten zu interger danke @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

danke an @rghome 🙂

InformationsquelleAutor YannSteph

Mein Beitrag mit einer raschen 3.1 Erweiterung :

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

Einfach anrufen .int, um Ihren Wert, genau wie dieser :

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

InformationsquelleAutor Kevin ABRIOUX

Erweitern zu können, Daten-Protokoll, erstellen Sie eine Allgemeine metho, Rückkehr der bytes von Speicher Daten-Speicher und wandeln Sie Sie oder setzen Sie den resultierenden Typ ausdrücklich als gebraucht:

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 mit 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 mit UInt32

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

Tests mit Doppel -

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

Wenn Sie möchten, zu extrahieren, eine subdata einfach Tiefgestellt Ihre Daten:

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

InformationsquelleAutor Leo Dabus

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Im Swift 4: