go-08-基本数据类型-整型

一、 介绍

Go 提供了 10 类型用于表示整数，它们被统称为整数类型（integer)。
整型不会出现浮点型的精度问题。

在 Go 中提供的 10 中类型的整型中还分为有符号的 5 种整型和无符号的 5 中类型，这就以为着它们可以表示正整数和负整数。
有符号的表示方式是: int 、int8、int16、int32 、int64
无符号的表示方式是: uint 、uint8、uint16、uint32 、uint64
其中最常用的也是最典型的是: int 和 uint, 这两个都是与计算机架构有关的整型表示方式。

也就是在 32 位架构中 int 就会是 32 位的值, 在64位架构中 int 就会是 64 位的值， uint 也是同样的道理。
但要记住 int 不是其他任何类型的别名，int 、int32 和 int64 实际上是 3 种不同的类型。

每种整型的取值范围都不一样，下表是与计算机架构无关的整数类型的取值范围和内存使用情况

二、声明整型变量

Go 在进行类型推断的时候总是会选择 int 类型作为整数值的类型。
下面的声明变量是同样的含义:

year =: 2022
var year = 2022
var year int = 2018
1
2
3

三、打印整型值

整型包含二进制、八进制、十进制、十六进制

a := 12
fmt.Printf("Type %T for %[1]v\n", a) // "Type int for 10"
fmt.Printf("转为十六进制 %02x\n", a)     // "转为十六进制 0c"
1
2
3

[1] 表示使用前一个占位符使用的变量，这样可以避免重复使用变量。
%02x 中的 x 表示打印的是一个十六进制的数字，02 表示总供打印的宽度是 2 个字符，不够 2 个字符的使用零进行填充。

四、整数回绕

Go 中当一个整数超过整数类型的取值范围时，就会出现整数回绕现象。

例如，8 位无符号整数 uint8 类型的取值范围是 0~255, 如果对其最大值进行增量操作，其值就会回绕至 0。这个现象同样适用与 int8 已经其他的整型。

var n uint8 = 255
n++
fmt.Println(n)

var m int8 = 127
m++
fmt.Println(m)
1
2
3
4
5
6
7

要想理解这个现象，可以使用 %08b 打印出这些值的二进制

var j uint8 = 3
fmt.Printf("%08b\n", j) // 00000011
j++
fmt.Printf("%08b\n",j)  // 00000100

var n8 uint8 = 255
fmt.Printf("%09b\n", n8) // 011111111
n8++
fmt.Printf("%09b\n", n8) // 000000000
1
2
3
4
5
6
7
8
9

速练

var red uint8 = 255
red += 2
fmt.Println(red)  // 1

var number int8 = 127
number += 3
fmt.Println(number) // -126

red = 0
red --
fmt.Println(red) // 255

number = -128
number--
fmt.Println(number) //127

var green uint16 = 65535
green++
fmt.Println(green) // 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

避免时间回绕

基于 Unix 操作系统都是使用 UTC 1970 年 1 月 1 日以来的秒数表示时间，但这个秒数在 2038 年将超过 20 亿，相当于 int32 的最大值.

所以2038年以后的时间可以使用 64 位的整数表示。

time 包中有个 Unix 的函数，它接收两个 int64 类型的值作为参数，两个参数分别代表 1970 年 1 月 1 日以来的秒数和纳秒数。

package main

import (
    "fmt"
    "time"
)

func main(){
    future := time.Unix(12622780800, 0)
    fmt.Println(future) // 2370-01-01 08:00:00 +0800 CST
}
1
2
3
4
5
6
7
8
9
10
11