swift中的进制转换，以及玩转二进制

swift中的进制转换，以及玩转二进制

在日常开发中我们很少用到进制转换，或操作二进制的情况。但是如果你处理一些底层的代码，你会经常与二进制打交道，所以接下来我们先来了解一下二进制。

二进制（binary），是在数学和数字电路中以2为基数的记数系统，是以2为基数代表系统的二进位制。这一系统中，通常用两个不同的符号0（代表零）和1（代表一）来表示。数字电子电路中，逻辑门的实现直接应用了二进制，现代的计算机和依赖计算机的设备里都使用二进制。每个数字称为一个比特（Bit，Binary digit的缩写）【摘自百度百科】

因此在计算机的世界里只有0和1。

在swift中为我们提供了存储不同长度bit的基本类型，例如UInt8（无符号的8bit，我们常说是无符号的8位Int型），Int8（有符号的8bit）等。符号位一般是二进制的最高位表示，0：正数，1：负数。

我们以十进制+8和-8来举例8位二进制中的符号位（这里操作小端模式举例，关于大小端模式的介绍，可以看这里）：

+8的二进制：00001000，最高位这里是0，因此代表正数

-8的二进制：10001000，最高位这里是1，因此代表负数

进制的表示法

二进制：b（Binary），swift中可以这样表示：let a = 0b0000_1001

八进制：o（Octal），swift中可以这样表示：let a = 0o11

十进制：d（Decimal），swift中可以这样表示：let a = 9

十六进制：x（Hexadecimal），swift中可以这样表示：let a = 0x9

接下来就来讲讲进制之间的转换原理

二进制——>十进制

00001001——>9

转换原理：（因为是小端模式，二进制的有效位是从右到左的）1*2^0 + 0*2^1 + 0*2^2 + 1*2^3 + 0*2^4+ 0*2^5+ 0*2^6+ 0*2^7 = 9

swift代码实现：

func decimal(_ v: String) -> Int {
    guard v.count > 0 else { return 0 }
    let l = v.count
    var isSkip = true
    var sum: Int = 0
    var idx = 0, skipCount = 0
    for i in v.indices {
        if let a = Int(String(v[i])) {
            if isSkip && a > 0{
                isSkip = false
            }
            if isSkip {
                skipCount += 1
                continue
            }
            sum += a*Int(pow(2, Double(l-skipCount-1-idx)))
            idx += 1
        }
    }
    return sum
}

swift自带的api

let b = 0b0000_1001
let s = String(b, radix: 10) // 转成10进制字符
print("---: \(s)")

// 输出结果：---: 9

十进制——>二进制

9——>00001001

转换原理：（根据二进制 转 十进制可以推导出，注意这里是小端模式，因此每次计算出来的bit顺序应该是从右到左，因为我们只要8位长度的二进制，因此这里需要计算8次）

func toBinary(_ v: UInt8) -> String {
    var str: String = ""
    var i = v
    while str.count < v.bitWidth {
        str.insert(Character("\(i % 2)"), at: str.startIndex)
        i /= 2
    }
    return str
}

swift自带api

let a: UInt8 = 9
let str = String(a, radix: 2)
print("str: \(str)")

// 输出：str: 1001
// 它输出的字符串只包括有效二进制位

二进制——>八进制

00001001——>11

转换原理：（因为是小端模式，二进制的有效位是从右到左的）二进制每三位一组（不够三位补0），分别计算对应的十进制值，计算结果的组合就是一个八进制数。

1、分组：000（不足三位补0），001，001

2、每组分别计算十进制值：0*2^0 + 0*2^1 + 0*2^2 = 0，1*2^0 + 0*2^1 + 0*2^2 = 1，1*2^0 + 0*2^1 + 0*2^2 = 1

3、每组的结果从左到右组合：0，1，1，最终的八进制数字为：11

swift代码实现：

func octal(_ v: String) -> String {
    guard v.count > 0 else { return "" }
    var res = ""
    var idx = 0
    var sum = 0
    for i in v.indices.reversed() {
        if let a = Int(String(v[i])) {
            sum += a*Int(pow(2, Double(idx)))
            if idx >= 2 {
                res.insert(Character("\(sum)"), at: res.startIndex)
                idx = 0
                sum = 0
            }else {
                idx += 1
            }
        }
    }
    return res
}

print("----o: \(octal("00001011"))")

// 输出：----o: 13

swift自带api：

let a = 0b0000_1011
let str = String(a, radix: 8)
print("str: \(str)")

// 输出：str: 13

八进制——>二进制

11——>00001001

原理：（利用二进制 转 八进制 反推导可知，对八进制的每位分别进行转3位的二进制数，然后将每位的结果拼接）1->001，1->001，最后拼接得到二进制：001001

swift实现代码：

func octalToBinary(_ v: String) -> String {
    guard v.count > 0 else { return "" }
    var res = ""
    for i in v.indices {
        if let a = Int(String(v[i])) {
            var n = a
            var s = ""
            for _ in 0..<3 {
                s.insert(Character("\(n % 2)"), at: s.startIndex)
                n /= 2
            }
            res.append(s)
        }
    }
    return res
}

print("----b: \(octalToBinary("11"))") // 八进制：11转二进制

// 输出：----b: 001001

swift自带api

let a = 0o11
let str = String(a, radix: 2)
print("str: \(str)")

// 输出：str: 1001

二进制——>十六进制

00101011——>2b

原理：二进制每四位一组（不够四位补0），分别计算对应的十进制值，计算结果的组合就是一个八进制数

1、分组：0010，1001

2、分别计算每组的十进制值：0*2^0 + 1*2^1 + 0*2^2 + 0*2^3 = 2，1*2^0 + 0*2^1 + 0*2^2 + 1*2^3 = 11（因为在16进制的表示中是从0到f的，因此11对应的是b）

3、组合结果：2b

swift代码实现：

func hex(_ v: String) -> String {
    guard v.count > 0 else { return "" }
    var res = ""
    var idx = 0, sum = 0
    for i in v.indices.reversed() {
        if let a = Int(String(v[i])) {
            sum += (a*Int(pow(2, Double(idx))))
            if idx >= 3 {
                res.insert(Character(String(format: "%x", sum)), at: res.startIndex)
                idx = 0
                sum = 0
            }else {
                idx += 1
            }
        }
    }
    if sum > 0 {
        res.insert(Character("\(sum)"), at: res.startIndex)
    }
    return res
}

print("----hex: \(hex("101011"))") // 二进制：101011转十六进制

// 输出：----hex: 2b

swift自带api：

let a = 0b0010_1011
let str = String(a, radix: 16)
print("str: \(str)")

// 输出：str: 2b

十六进制——>二进制

2b——>00101011

原理：（根据二进制 转 十六进制 可推导出，对十六进制的每位分别进行转4位的二进制数，然后将每位的结果拼接）2——>0010，b——>1011

swift实现代码：

func hexToBinary(_ v: String) -> String {
    guard v.count > 0 else { return "" }
    var res = ""
    let map = ["1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, "a": 10, "b": 11, "c": 12, "d": 13, "e": 14, "f": 15]
    for i in v.indices {
        if let a = map[String(v[i])] {
            var n = a
            var s = ""
            for _ in 0..<4 {
                s.insert(Character("\(n % 2)"), at: s.startIndex)
                n /= 2
            }
            res.append(s)
        }
    }
    return res
}

print("----b: \(hexToBinary("2b"))") // 十六进制：2b转二进制

// 输出：----b: 00101011

swift自带api

let a = 0x2b
let str = String(a, radix: 2)
print("str: \(str)")

// 输出：str: 101011

八进制——>十进制

0o1101——>577

原理：（类似于二进制 转 十进制，因为是小端模式，分别从右往左对八进制每位进行加权计算，然后将所有加权的值累加即为 十进制结果）

1*8^0 + 0*8^1 + 1*8^2 + 1*8^3  = 557

swift实现代码：

func octalToDecimal(_ v: String) -> Int {
    guard v.count > 0 else { return 0 }
    var idx = 0, sum = 0
    for i in v.indices.reversed() {
        if let a = Int(String(v[i])) {
            sum += (a*Int(pow(8, Double(idx))))
            idx += 1
        }
    }
    return sum
}

print("----d: \(octalToDecimal("1101"))") // 八进制：1101转十进制

// 输出：----d: 577

swift自带api：

let a = 0o1101
let str = String(a, radix: 10)
print("str: \(str)")

// 输出：str: 577

十进制——>八进制

577——>1101

原理：（根据八进制 转 十进制 可推导出，对十进制数 除以 8，余数作为二进制有效位，商>0，继续对商进行上面的操作，直到商==0为止）

swift实现代码：

func decimalToOctal(_ v: Int) -> String {
    guard v > 0 else { return "0" }
    var str = ""
    var a = v
    while a > 0 {
        str.insert(Character("\(a % 8)"), at: str.startIndex)
        a /= 8
    }
    return str
}

print("---o: \(decimalToOctal(577))") // 十进制：577 转 八进制

// 输出：---o: 1101

swift自带api：

let a = 577
let str = String(a, radix: 8)
print("str: \(str)")

// 输出：str: 1101

八进制——>十六进制

1271——>2b9

原理：（中转法）现将八进制 转成 二进制 或 十进制，然后通过二进制 或 十进制 再转 十六进制。

swift自带api：

let a = 0o1271
let str = String(a, radix: 16)
print("str: \(str)")

// 输出：str: 2b9

十六进制——>八进制

2b9——>1271

原理：（中转法）现将十六进制 转成 二进制 或 十进制，然后通过二进制 或 十进制 再转 八进制。

swift自带api：

let a = 0x2b9
let str = String(a, radix: 8)
print("str: \(str)")

// 输出：str: 1271

以上就是全部的进制之间的转化过程，接下来介绍一下对二进制操作常用到的位运算符

“&”运算符

两个二进制对应位都为1，该位的结果才为1，否则为0。如下：

第一个二进制	0	1	0	1	1	0	0	1
第二个二进制	0	0	1	1	1	0	1	0
&运算后的结果	0	0	0	1	1	0	0	0

&运算符在日常开发中用处比较多，举个最长用到的例子，在OC开发中，我们定义枚举，经常会利用&来判断一个包含多个枚举值的情况：

NS_ENUM(NSInteger, MyType) {

    MyType1 = 1 << 0,
    MyType2 = 1 << 1,
    MyType3 = 1 << 2,
};

enum MyType type = MyType1 | MyType2;

if ((type & MyType1) == MyType1) {
    NSLog(@"-----type中包含MyType1枚举值");
}else {
    NSLog(@"-----type中不包含MyType1枚举值");
}

if ((type & MyType2) == MyType2) {
    NSLog(@"-----type中包含MyType2枚举值");
}else {
    NSLog(@"-----type中不包含MyType2枚举值");
}

if ((type & MyType3) == MyType3) {
    NSLog(@"-----type中包含MyType3枚举值");
}else {
    NSLog(@"-----type中不包含MyType3枚举值");
}

// 输出：
// -----type中包含MyType1枚举值
// -----type中包含MyType2枚举值
// -----type中不包含MyType3枚举值

我们也可以利用&运算符来判断一个数是奇数还是偶数，只要二进制位第0位=1，那这个数必定是奇数，如果=0，那就是偶数。为什么？根据上面介绍的二进制转十进制可知：第一位的值要么是0（0*2^0），要么是1（1*2^0），而后面位数对应的值都是2的倍数（偶数），因此一个偶数+1=奇数。这样我们只需要判断第一位是1还是0，就可以判断出这个数是奇还是偶 。如何判断二进制第一位是1还是0呢，我们可以让这个数与1进行&运算，即x & 0000 0001 = 1（奇数），x & 0000 0001 = 0（偶数），如下：

let x = 123
if x & 1 == 0 {
    print("偶数")
}else {
    print("奇数")
}

“|”运算符

两个二进制对应位只要有一个为1，该位的结果就为1，否则为0。如下：

第一个二进制	0	1	0	1	1	0	0	1
第二个二进制	0	0	1	1	1	0	1	0
|运算后的结果	0	1	1	1	1	0	1	1

|运算符常用于将多个枚举值合并，例如上面的例子中，将两个枚举值合并到一个type变量中。

“^”（异或）运算符

两个二进制对应位不相同结果则为1，相同则为0。如下：

第一个二进制	0	1	0	1	1	0	0	1
第二个二进制	0	0	1	1	1	0	1	0
^运算后的结果	0	1	1	0	0	0	1	1

^运算符也有一些使用的场景，例如我们可以利用该运算符实现 不占用额外空间交换两个变量的值。如下：

var x = 1024, y = 4201

x = x^y
y = x^y // x
x = x^y // y

print("x: \(x), y: \(y)")

// 输出：x: 4201, y: 1024

我们用一个简单的两个二进制数解释上面的例子：

数字1：	0	0	0	0	0	0	0	1
数字2：	0	0	0	0	0	0	1	0
^结果	0	0	0	0	0	0	1	1

^结果与 数字1 再次进行^运算

数字1	0	0	0	0	0	0	0	1
^结果	0	0	0	0	0	0	1	1
结果	0	0	0	0	0	0	1	0

它的结果正是数字2。同样的道理，让^结果与 数字2 再次进行 ^运算，结果将会是数字1。

另外^运算还有个特性，那就是任何一个数与自己^运算，相当于将自己至为0。

var x = 100123
x ^= x
print("x: \(x)")

// 输出：x: 0

“~”（取反）运算符

对一个二进制取反就是对二进制中的每位取反，例如0取反就是1,1取反就是0。如下：

一个二进制	0	1	0	1	1	0	0	1
~结果	1	0	1	0	0	1	1	0

我们可以利用取反运算符和&运算结合，从而实现从多个合并的枚举中删除指定的枚举。如下：

NS_ENUM(NSInteger, MyType) {

    MyType1 = 1 << 0,
    MyType2 = 1 << 1,
    MyType3 = 1 << 2,
};

enum MyType type = MyType1 | MyType2;
if ((type & MyType1) == MyType1) {
    NSLog(@"-----type中包含MyType1枚举值");
    // 删除枚举值 MyType1
    type &= ~MyType1;

    if ((type & MyType1) == 0) {
        NSLog(@"枚举MyType1从type变量中移除");
    }
}

我们也可以通过该运算符计算一个数的相反数，如下：（一个数x的相反数=~x + 1）

let x = -123
print("x: \(~x + 1)") // 计算x的相反数

// 输出：x: 123

“<<”左移运算符

对二进制的每位进行左移，右侧空出的位用0补，运算符后面跟着移动的位数，例如：x << 2，对x进行左移2位。

一个二进制	0	0	0	0	1	1	1	1
<<4结果	1	1	1	1	0	0	0	0

由于二进制每位之间都相差2^n倍数，因此对一个数进行左移运算，相当于这个数乘以2^n（n：移动的位数）

“>>”右移运算符

与左移运算符相反，它是对对二进制的每位进行右移，左侧空出的位用0补，运算符后面跟着移动的位数，例如：x >> 2，对x进行右移2位。

右移运算相当于这个数除以2^n（n：移动的位数）

一个二进制	1	1	1	1	0	0	0	0
>>4结果	0	0	0	0	1	1	1	1

左移与右移运算也在开发中常用到，一般用于取指定位的值，例如：要取一个八位无符号的二进制的前4位的数值，如下：

1、二进制：1111 0000

2、对二进制右移4位：0000 1111

3、计算十进制数值：1*2^0 + 1*2^1 + 1*2^2 + 1*2^3 = 15

在取一个图片中指定像素点的色值的时候，我们就会用到移位算法。一个色值是包括r、g、b、a四个分量，根据不同的颜色通道的mode，它们的排列顺序也不同。一般以r、g、b、a顺序居多。颜色的每个分量采用8位二进制数表示，因此一个色值的位数可以是32位。根据它们的排列顺序，我们就可以通过移位运算，来分别取出每个分量值。例如：

----------------x----------------

---r----   ---g---   ---b---   ---a---

00000100   00001001  00000010  00000001

r：x >> 24

g：(x << 8) >> 24

b：(x << 16) >> 24

a：(x << 24) >> 24

其实对于上面的取值还有一些技巧，比如在取b分量的值时，我们可以通过x&00000000_00000000_11111111_00000000来快速取值，这样就不需要移位了。一般我们会采用十六进制来表示这样的一串二进制数。我们知道十六进制中最大值是F，而每个十六进制数占4位，因此8位的最大值就是八个1，用十六进制表示就是：FF。

下面将展示不通过移位方法来去各个分量的值。

r：x & 0xFF000000

g：x & 0x00FF0000

b：x & 0x0000FF00

a：x & 0x000000FF

这种计算方法会减少很多移位的步骤，因此这样计算的效率肯定比移位方法要高。

“>>>”（无符号右移）运算符（某些开发语言中不支持该运算符，例如：swift、OC）

这个运算符跟>>运算符类似，都是将二进制位右移，而>>>在移动时不会考虑符号位，会将符号位用0补。而>>在移动的时候会考虑符号位，并不会用0来补充符号位。因此通过>>>运算后得到的值肯定是一个正数。