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

最新推荐文章于 2022-07-17 13:26:46 发布
最新推荐文章于 2022-07-17 13:26:46 发布
阅读量1.4k 收藏 1
点赞数
文章标签： swift java 移动开发
原文链接：https://my.oschina.net/hejunbinlan/blog/717727
版权
  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-Endian和Little-Endian.它们的定义为:

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

也就是他们两个是相反的.Big-Endian和Little-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上的Swift和JAVA的字节序是相反的,因此,它们两个进行跨语言的网络数据交互的时候,就需要对数据进行字节序的转换.否则就会出现数据读取错误的情况,比如用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中,对UInt64和UInt32,已经自带了成员方法: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位平台上,Int与Int32长度相同
  • 在64位平台上,Int与Int64长度相同.相当于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. 因此我们的appendInt和getInt可以改成这样:

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的字节数组来表示这个字符串的长度.

因此,我们在转换String到NSData的时候,实际上是两个步骤.首先计算出字符串的字节长度.然后把这个字节长度放入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数组的.至于其他的数据类型,或者自定义的数据结构,无外乎都是从这几种基础数据类型上拼接出来的,稍微灵活修改下即可.

转载于:https://my.oschina.net/hejunbinlan/blog/717727

chunqingtai2922
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
NSData与NSDictionary、JSON数据类型相互转换
05-06
NSData在IOS开发中是一个神奇的数据类型。比如说NSData可以与...NSData与JSON数据类型转换也是目前常用的热点。本文章是在实践基础上，给出示例代码来说明如何使用NSData，以及NSData与JSON,还有其他类型的转换。
iOS Swift数据类型与Data的转换
Lee坚武的博客
08-04 1963
本人亲测有效！更多交流可以家魏鑫：lixiaowu1129，公重好：iOS过审汇总，一起探讨iOS技术！ 字符串与Data的转换 var send: String  = "hello"let data: Data = send.data(using: .utf8)!let receive: String = String(data: data, en
（iOS, Swift）十六进制字符串转(Hex)Data，Data转十六进制String Data,NSData,bytes[UInt8]互转
baidu_40537062的博客
01-07 1万+
（iOS, Swift）十六进制转Data，十六进制转整形，Data转String
Swift model 数据解析及转换
Mackellen的专栏
11-02 2050
enum MKError: Error { case message(String) } struct MKDecoder { public static func decode<T>(_ type: T.Type, param: [String: Any]) throws -> T? where T: Decodable { if param.isEmpty { return nil } gua.
[Swift]常见数据类型之间的转换
Gamin
03-12 5330
// Data转JSON字符串 func DataToJSONString(data: Data) -> String? { let JSONString = String(data: data, encoding: String.Encoding(rawValue: String.Encoding.utf8.rawValue)); return JSONString; }...
ios学习笔记之基础数据类型的转换
09-01
众多数据中，NSString、NSData、NSArray、 NSDictionary等数据类型是常用的，对付它们容易，但是在多个数据类型之间转换就需要技巧了。本文主要给大家介绍ios中基础数据类型的转换，有需要的下面来一起看看吧。
数据类型之间的转换
07-24
ios相关数据类型之间的互换//NSData 转 NSString //NSString 转 NSData//NSArray 转 NSString char 转NSString
swift-一行代码搞定NSString和NSData的md5加密
08-15
一行代码搞定NSString和NSData的md5加密
RicdeTmp#TechNote#NSArray、NSDictionary与NSData的相互转换1
07-25
// 方法1：NSKeyedUnarchiver// 方法2：NSJSONSerialization// 方法1：NSKeyedArchiver// 方法2：N
Swift中Data,String,[UInt8]的相互转换
热门推荐
天道酬勤
07-03 1万+
[UInt8],Data,String互转
Swift5.0的Data类型
华山论码
07-22 3677
二进制是计算机的基本进制，存储在硬盘、内存包括网络传输的数据都是以二进制存在。在实际开发中，经常会碰到普通数据与二进制数据的互换。 Swift 用Data表示二进制数据，同样也是一个结构体。 从 Swift 5 开始，Data只用于表达连续的数据。Apple 引入了ContiguousBytes协议来表示数据的连续。遵守这个协议表示该类型提供以连续的方式直接访问底层原始数据的能力。以后不需要担心有时内存占用会莫名变大的问题了。 字符串与Data的转换 var send: String = "hello"
Swift调用OC之数据存储-NSData
渔歌子的程序人生
03-11 2327
//************************************* // // Swift调用OC之数据存储NSData // // NSData的对象可以看做是缓冲区 // NSData是静态缓冲区(大小固定)，NSMutableData是动态的 //  // 1.创建NSData // 2.访问数据(读取NSData) // 3.比较数据是否相同 // 4.字节
Swift 二进制数据与16进制字符串的相互转换
jjf19891208的专栏
07-17 1547
Swift二进制数据与16进制字符串的相互转换。
swift : NSData数据类型与String字符串类型的转换方法
qj918的博客
03-05 9416
1 String 类型转 NSData 类型        dataUsingEncoding函数： 将字符串类型（String）的数据转换成数据类型(NSData) 的数据。        在 String类中有自带的函数方法：    public func dataUsingEncoding(encoding: NSStringEncoding, allowLossyC
Swift学习之五：Bool类型
标哥
06-08 1万+
Swift中的基本类型Bool，Bool值是逻辑值，因为Bool会上
苹果新的编程语言 Swift 语言进阶（二）－－基本数据类型
weixin_30906671的博客
06-12 70
一 、 常量和变量 Swift语言对常量和变量的声明进行了明确的区分 Swift语言的常量类型比C 语言的constants类型更加强大，语义更加明确。 常量和变量的区别是常量在设置或初始化后其值不允许改变，而变量允许，除此之外，Swift语言中变量类型能使用的地方，常量类...
IOS Swift 3.0 NSData与String相互转化
appiox8的博客
05-24 1883
var testString = "This is a test string" var nsdata = testString.data(using: String.Encoding.utf8)//NSData 类型 var strdata = String(data: nsdata !, encoding: String.Encoding.utf8) as String!//String
iOS nsdata 转base64
最新发布
07-28
在iOS中，你可以使用`NSData`和`Base64`来实现将数据转换为Base64编码的字符串。以下是一个示例代码： ```swift import Foundation // 将NSData转换为Base64编码的字符串 func nsdataToBase64(_ data: NSData) -> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值