Swift中基本数据类型与NSData转换
Swift中基本数据类型与NSData转换
hejunbinlan 发表于2年前
Swift中基本数据类型与NSData转换
  • 发表于 2年前
  • 阅读 1051
  • 收藏 0
  • 点赞 0
  • 评论 0

新睿云服务器60天免费使用,快来体验!>>>   

摘要: Swift中基本数据类型与NSData转换
  1. 1. Swift中基本数据类型与NSData转换
    1. 1.1. big-endian and little-endian
    2. 1.2. 基础数据与NSData的转换
      1. 1.2.1. Int32与Int64
      2. 1.2.2. Float32与Float64
      3. 1.2.3. Bool
      4. 1.2.4. String
    3. 1.3. 总结

Swift中基本数据类型与NSData转换

最近由于程序的需要,要与JAVA的服务端进行Socket的交互,那么这就牵涉到了数据的交互.Socket的数据交互一般都是直接采用二进制Bytes的方式来传递,那么就需要把Swift中的各种基本数据转换成为JAVA服务器可以认可的Bytes字节数组,以及把JAVA的字节数组反序列化为Swift中的基本数据.

big-endian and little-endian

要在不同程序中进行字节数组的数据交换,有个很重要的东西就是字节序.字节序顾名思义就是字节的顺序,也就是大于1个字节类型的数据在内存中存放的顺序.这个在跨平台以及网络程序交互中非常的重要.

常见的字节序主要有两类:Big-EndianLittle-Endian.它们的定义为:

  • Big-Endian:高位字节排放在内存的低地址端,地位字节排放在内存的高地址端.
  • Little-Endian:地位字节排放在内存的低地址端,高位字节排放在内存的高地址端.
    这样说可能比较抽象,我们来举个例子就非常清楚了:
    比如一个32位的Int类型数据: let a = Int32(2)分别采用Big-EndianLittle-Endian的情况如下:
字节号 0 1 2 3
Big-endian 00 00 00 02
Little-Endian 02 00 00 00

也就是他们两个是相反的.Big-EndianLittle-Endian跟CPU的指令有关,每一种CPU不是Big-Endian就是Little-Endian.常见的IA架构的CPU,比如Intel或AMD的都是使用的Little-Endian,而PowerPC活着SPARC的处理器则是Big-Endian的.而在互联网的网络交互以及TCP协议中使用的是Big-Endian,JAVA的虚拟机中的字节序是Big-Endian的.而Swift由于是运行在IA架构的CPU上的,因此,它的字节序是Little-Endian的.

正是由于运行在X86上的SwiftJAVA的字节序是相反的,因此,它们两个进行跨语言的网络数据交互的时候,就需要对数据进行字节序的转换.否则就会出现数据读取错误的情况,比如用JAVA采用Big-Endian序的Int3202000000,Swift采用Little-Endian序解析出来是33554432而不是期望的2.

在Swift中,Apple在CoreFoundation中提供了一些列的函数来提供字节序的转换.它们都在CFByteOrder中有所定义:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public func CFSwapInt16BigToHost(arg: UInt16) -> UInt16

public func CFSwapInt32BigToHost(arg: UInt32) -> UInt32

public func CFSwapInt64BigToHost(arg: UInt64) -> UInt64

public func CFSwapInt16HostToBig(arg: UInt16) -> UInt16

public func CFSwapInt32HostToBig(arg: UInt32) -> UInt32

public func CFSwapInt64HostToBig(arg: UInt64) -> UInt64

public func CFSwapInt16LittleToHost(arg: UInt16) -> UInt16

public func CFSwapInt32LittleToHost(arg: UInt32) -> UInt32

public func CFSwapInt64LittleToHost(arg: UInt64) -> UInt64

public func CFSwapInt16HostToLittle(arg: UInt16) -> UInt16

public func CFSwapInt32HostToLittle(arg: UInt32) -> UInt32

public func CFSwapInt64HostToLittle(arg: UInt64) -> UInt64

public func CFConvertFloat32HostToSwapped(arg: Float32) -> CFSwappedFloat32

public func CFConvertFloat32SwappedToHost(arg: CFSwappedFloat32) -> Float32

public func CFConvertFloat64HostToSwapped(arg: Float64) -> CFSwappedFloat64

public func CFConvertFloat64SwappedToHost(arg: CFSwappedFloat64) -> Float64

public func CFConvertFloatHostToSwapped(arg: Float) -> CFSwappedFloat32

public func CFConvertFloatSwappedToHost(arg: CFSwappedFloat32) -> Float

public func CFConvertDoubleHostToSwapped(arg: Double) -> CFSwappedFloat64

public func CFConvertDoubleSwappedToHost(arg: CFSwappedFloat64) -> Double

使用这些函数就可以对字节序进行转换. 更多的可以参考Apple的官方手册

2016-02-16 Update
最新的swift中,对UInt64UInt32,已经自带了成员方法:public var bigEndian: UInt32 { get } public var littleEndian: UInt32 { get }等等. 也就是说,不需要使用CFSwapInt32BigToHost(val)这样转换了,直接val.bigEndian即可.

基础数据与NSData的转换

为了能让Swift和JAVA进行网络的交互,那么就必须把它们的基础数据转换成为Bytes字节数组.
在Swift中使用NSData或者NSMutableData来表示.因此,也就是需要把基础数据放入到NSData中.

Int32与Int64

在Swift中,Int是一个特殊的整数类型,它的长度与当前平台的原生字长相同:

  • 在32位平台上,IntInt32长度相同
  • 在64位平台上,IntInt64长度相同.相当于C中的Long.

因此,在网络传输的时候,是需要区分的对待Int32和Int64的.需要把一个Int类型强转为需要的长度.
具体的代码为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public extension NSMutableData {
    
    public func appendInt(value:Int){
        var networkOrderVal = CFSwapInt32HostToBig(UInt32(value))
        self.appendBytes(&networkOrderVal, length: sizeof(UInt32))
    }
    
    public func appendLong(value:Int) {
        var networkOrderVal = CFSwapInt64HostToBig(UInt64(value));
        self.appendBytes(&networkOrderVal, length: sizeof(UInt64))
    }
    
    public func getInt(range:NSRange = NSRange(location:0,length:sizeof(UInt32))) -> Int {
        var val: UInt32 = 0
        self.getBytes(&val, range: range)
        return Int(CFSwapInt32BigToHost(val))
    }
    
    public func getLong(range:NSRange = NSRange(location:0,length:sizeof(UInt64))) -> Int {
        var val: UInt64 = 0
        self.getBytes(&val, range: range)
        return Int(CFSwapInt64BigToHost(val))
    }
}

这里使用了扩展机制,直接在NSMutableData上增加扩展.

首先,使用CFSwapInt32HostToBig函数把字节序给改变了.然后调用NSMutableData.appendBytes方法,赋值给NSData.由于NSMutableData现在还是Objective-C的实现,因此,调用方式稍微有点奇怪,是使用指针的方式进行赋值的.更多的可以参见Using Swift with Cocoa and Objective-C.

反序列化也是相似的,首先定义了一个变量.然后使用NSMutableData.getBytes,同样传入一个指针以及数据的返回.然后最后在进行一次字节序的转换即可.

2016-02-16 Update:
对于需要在网络传输中传输负数的情况需要先把负数的Int转换为无符号的整数UInt.在计算机中,负数的表示方法是采用补码的形式.在swift中,可以使用UInt32(bitPattern:Int32)以及Int32(bitPattern:UInt32)方法来相互的转换.比如,-5转换为无符号的补码形式为:fffffffb. 因此我们的appendIntgetInt可以改成这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public func appendInt(value:Int){
       var networkOrderVal = UInt32(bitPattern:Int32(value)).bigEndian
       self.appendBytes(&networkOrderVal, length: sizeof(UInt32))
   }
   
   public func appendLong(value:Int) {
       var networkOrderVal = UInt64(bitPattern:Int64(value)).bigEndian
       self.appendBytes(&networkOrderVal, length: sizeof(UInt64))
   }
   
   public func getInt(range:NSRange = NSRange(location:0,length:sizeof(UInt32))) -> Int {
       var val: UInt32 = 0
       self.getBytes(&val, range: range)
       return Int(Int32(bitPattern:val.bigEndian))
   }
   
   public func getLong(range:NSRange = NSRange(location:0,length:sizeof(UInt64))) -> Int {
       var val: UInt64 = 0
       self.getBytes(&val, range: range)
       return Int(Int64(bitPattern:val.bigEndian))
   }

Float32与Float64

它的情况与Int的非常相似.同样需要经历字节序的转换,以及NSMutableData.appendBytes的调用.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public extension NSMutableData {
    
    // MARK: Float32与Float64
    
    public func appendFloat(value:Float) {
        var networkOrderVal = CFConvertFloat32HostToSwapped(Float32(value))
        self.appendBytes(&networkOrderVal, length: sizeof(Float32))
    }
    
    public func appendDouble(value:Double) {
        var networkOrderVal = CFConvertFloat64HostToSwapped(Float64(value))
        self.appendBytes(&networkOrderVal, length: sizeof(Float64))
    }
    
    
    public func getFloat(range:NSRange = NSRange(location:0,length:sizeof(Float32))) -> Float {
        
        var val: CFSwappedFloat32 = CFSwappedFloat32(v: 0)
        self.getBytes(&val, range: range)
        let result = CFConvertFloat32SwappedToHost(val)
        return result
    }
    
    public func getDouble(range:NSRange = NSRange(location:0,length:sizeof(Float64))) -> Double {
        var val: CFSwappedFloat64 = CFSwappedFloat64(v: 0)
        self.getBytes(&val, range: range)
        let result = CFConvertFloat64SwappedToHost(val)
        return result
    }
}

Bool

Bool类型由于是单字节的数据,不存在字节序的问题.因此,它与NSData的转换最为简单.

1
2
3
4
5
6
7
8
9
10
11
12
public extension NSMutableData {
	// MARK: Bool
    public func appendBool(var val:Bool){
        self.appendBytes(&val, length: sizeof(Bool))
    }
    
    public func getBool(range:NSRange = NSRange(location:0,length:sizeof(Bool))) -> Bool {
        var val:Bool = false
        self.getBytes(&val, range: range)
        return val
    }
}

String

字符串的处理又相对的要麻烦些了.因为字符串的长度是可变的.不像其他的数据类型是有固定的长度的.因此,一般在网络传输中,都会在字符串的bytes前接上一个Int32的字节数组来表示这个字符串的长度.

因此,我们在转换StringNSData的时候,实际上是两个步骤.首先计算出字符串的字节长度.然后把这个字节长度放入NSData中,接着,再把字符串的内容转换为字节数组放入NSData中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public extension NSMutableData {
	// MARK: String
    public func appendString(val:String,encoding:NSStringEncoding = NSUTF8StringEncoding){
        
        //获取到字节的长度,使用某一种编码
        let pLength : Int = val.lengthOfBytesUsingEncoding(encoding)

        //放入字符串的长度
        self.appendInt(pLength)
        
        //把字符串按照某种编码转化为字节数组
        let data = val.dataUsingEncoding(encoding)
        
        //放入NSData中
        self.appendData(data!)
    }

    public func getString(location:Int = 0,encoding:NSStringEncoding = NSUTF8StringEncoding) throws -> (String,Int){
        
        //先获取到长度
        let len = self.getInt(NSRange(location:location,length:sizeof(UInt32)))
        
        //找到子字节数组
        let subData = self.subdataWithRange(NSRange(location: location+sizeof(UInt32), length: len))
        
        //直接使用String的构造函数,采用某种编码格式获取字符串
        let string = String(data: subData, encoding: encoding)
        
        //如果凑不起字符串,就表示数据不正确,那么就抛出异常
        guard let _string = string else {
            throw AppException.FormatCastException
        }
        
        //返回结果
        return (_string,len+sizeof(UInt32))
    }
}

总结

以上就是简单的介绍了在Swift中如何把几种常用的数据类型转换为网络交互格式的Bytes数组的.至于其他的数据类型,或者自定义的数据结构,无外乎都是从这几种基础数据类型上拼接出来的,稍微灵活修改下即可.

  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 37
博文 529
码字总数 21018
×
hejunbinlan
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: