Swift 中的位 *** 作

这种“安全第一”的方法的唯一缺点就是，当你需要进行很多类型转换时，这些截短转换会让你的代码变得臃肿。

但幸运的是，在 Swift 中，我们可以给基本类型添加新方法，通过这种方式我们可以给所有整型加入一些实用方法将他们截短为特定的尺寸，举个例子：

extension Int {    public var toU8: UInt8{ get{return UInt8(truncatingBitPattern:self)} }    public var to8: Int8{ get{return Int8(truncatingBitPattern:self)} }    public var toU16: UInt16{get{return UInt16(truncatingBitPattern:self)}}    public var to16: Int16{get{return Int16(truncatingBitPattern:self)}}    public var toU32: UInt32{get{return UInt32(truncatingBitPattern:self)}}    public var to32: Int32{get{return Int32(truncatingBitPattern:self)}}    public var toU64: UInt64{get{            return UInt64(self) //No difference if the platform is 32 or 64        }}    public var to64: Int64{get{            return Int64(self) //No difference if the platform is 32 or 64        }}}extension Int32 {    public var toU8: UInt8{ get{return UInt8(truncatingBitPattern:self)} }    public var to8: Int8{ get{return Int8(truncatingBitPattern:self)} }    public var toU16: UInt16{get{return UInt16(truncatingBitPattern:self)}}    public var to16: Int16{get{return Int16(truncatingBitPattern:self)}}    public var toU32: UInt32{get{return UInt32(self)}}    public var to32: Int32{get{return self}}    public var toU64: UInt64{get{        return UInt64(self) //No difference if the platform is 32 or 64        }}    public var to64: Int64{get{        return Int64(self) //No difference if the platform is 32 or 64        }}}var h1 = 0xFFFF04h1h1.toU8   // 替代 UInt8(truncatingBitPattern:h1)var h2:Int32 = 0x6F00FF05h2.toU16  // 替代 UInt16(truncatingBitPattern:h2)

现在，让我们通过实践来了解些常见的按位运算模式，就把这当成谈论一些真的很有用但是在 Swift 中又没法用的东西的借口吧。

AND 和右移（>>）的组合通常用于从较长的序列中截取位或者字节。让我们看个例子，在这个例子中，我们要从表示颜色的 RGB 值中取出单个颜色元素的值：

let swiftOrange = 0xED903Blet red = (swiftOrange & 0xFF0000) >> 16    //0xEDlet green = (swiftOrange & 0x00FF00) >> 8   //0x90let blue = swiftOrange & 0x0000FF           //0x3B

在这个例子中，我们通过给数据 AND 上一个位掩码来分离出我们感兴趣的位。我们感兴趣的位在结果中都是1，其他的都是0。为了得到我们所需要的部分并用8位去表示他，我们需要对 AND 运算的结果进行右移，移动16位得到红色部分(右移两个字节)，移动8位获得绿色部分（右移一个字节）。就是这样，这种掩码+移位的模式具有广泛的应用，但是用在子表达式中会使你的表达式很快变得难以阅读，那么为什么不把它写成所有整型的下标脚本呢？换言之，为什么不像数组一样，为整型添加上通过索引(index)来访问单个字节的功能呢？

举个例子，让我们给 Int32 添加下标脚本:

extension UInt32 {    public subscript(index: Int) -> UInt32 {        get {            precondition(index<4,"Byte set index out of range")            return (self & (0xFF << (index.toU32*8))) >> (index.toU32*8)        }        set(newValue) {            precondition(index<4,"Byte set index out of range")            self = (self & ~(0xFF << (index.toU32*8))) | (newValue << (index.toU32*8))        }    }}var i32:UInt32=982245678                        //HEX: 3A8BE12Eprint(String(i32,radix:16,uppercase:true))      // Printing the hex valuei32[3] = i32[0]i32[1] = 0xFFi32[0] = i32[2]print(String(i32,uppercase:true))      //HEX: 2E8BFF8B

你们中的部分人可能通过简单而无用的 XOR 密码对 XOR 有了一些了解。XOR 密码通过对位流 XOR 上一个 key 进行加密，然后通过再次 XOR 那个 key 来获取原始数据。为了简单起见，我们以相同长度的信息和 key 为例:

let secretMessage = 0b10101000111110010010101100001111000 // 0x547C95878let secretKey =  0b10101010101010000000001111111111010    // 0x555401FFAlet result = secretMessage ^ secretKey                    // 0x12894782let original = result ^ secretKey                         // 0x547C95878print(String(original,uppercase:true))           // 打印16进制值

XOR 的这个性质还能够用来做其他事，最简单的例子是 XOR swap,即不使用临时变量来交换两个整型变量的值：

var x = 1var y = 2x = x ^ yy = y ^ x   // y 现在为 1x = x ^ y   // x 现在为 2

在 Swift 中你可以用 tuple 来做同样的事儿(看看这儿的第 11 项)，所以这并没什么用=，=

另外还有件你能用 XOR 来做的事儿，但是我在这儿不细说，简而言之就是构建一个传统双向链表的变种: XOR 链表。这是 XOR 的一种更有趣的使用方法，可以在 wikipedia 查看更多详情.

类似于上面的用法的另一种常见模式，是将位掩码与双重否定结合使用，以查找输入的位序列中是否出现了特定的位或者位组合。

let input: UInt8 = 0b10101101let mask: UInt8 = 0b00001000let isSet = !!(input & mask)  // 如果输入序列的第四位为 1，那么 isSet 等于 1                              // 但这代码在 Swift 中是错的

双重否定是基于 C/C++(及其他一些语言)中逻辑否定的特殊表现的，事实上，在 C/C++ 中布尔型是用整型实现的（0 表示 false,1 表示 true),以下引用自 C99 标准：

如果逻辑否运算符 ! 的 *** 作数不为 0，则运算结果为 0，否则其运算结果为 1。运算结果为整型，表达式 !E 等同于 (0==E)。

考虑到这个，双重否定的作用就变得更加清晰了。如果我们加过掩码的输入大于 0 或者等于 0， 第一个逻辑否(NOT)运算就会分别把它转为 0 或 1(实际上把这个值取反就得到我们想要的布尔值了)。而第二个逻辑否(NOT)则把输入转回原始的布尔值，（这里只有 0 或 1 这两个选择）。也许这个解释有点混乱，但是你应该能看懂。

不过 Swift 已经有了一个特有的布尔类型，而逻辑否定只能用于这些逻辑类型，所以，我们该怎么做呢？

让我们来自定义一个运算符(通常来说，我并不喜欢它们，但在此让我们破下例)，来为 UInt8@H_404_57@ 类型加上双重否定！

prefix operator ~~ {}prefix func ~~(value: UInt8) -> UInt8 {    return (value > 0) ? 1 : 0}~~7  // 1~~0  // 0let isSet = ~~(input & mask)   // 正如所料，结果是 1