前文再续，Go lang和Python一样，基础数据类型有着很多分类，分门别类，一应俱全。它们对应着不同的使用场景，分别是：整形、浮点、字符、字符串、布尔等等。常用的基本数据类型经常会参与日常业务逻辑的运算、判断以及输入输出操作。

整形 int

整形顾名思义，就是存储的数据类型是整数，Go lang中分为有符号和无符号，简单理解就是存储范围上的差异：

有符号整型：int8、int16、int32、int64、int。

无符号整型：uint8、uint16、uint32、uint64、uint。

package main  
  
import (  
    "fmt"  
    "math"  
    "unsafe"  
)  
  
// 有符号整型  
func Integer() {  
    var num8 int8 = 127  
    var num16 int16 = 32767  
    var num32 int32 = math.MaxInt32  
    var num64 int64 = math.MaxInt64  
    var num int = math.MaxInt  
    fmt.Printf("num8的类型是 %T, num8的大小 %d, num8是 %d\n",  
        num8, unsafe.Sizeof(num8), num8)  
    fmt.Printf("num16的类型是 %T, num16的大小 %d, num16是 %d\n",  
        num16, unsafe.Sizeof(num16), num16)  
    fmt.Printf("num32的类型是 %T, num32的大小 %d, num32是 %d\n",  
        num32, unsafe.Sizeof(num32), num32)  
    fmt.Printf("num64的类型是 %T, num64的大小 %d, num64是 %d\n",  
        num64, unsafe.Sizeof(num64), num64)  
    fmt.Printf("num的类型是 %T, num的大小 %d, num是 %d\n",  
        num, unsafe.Sizeof(num), num)  
}  
  
// 无符号整型  
func unsignedInteger() {  
    var num8 uint8 = 128  
    var num16 uint16 = 32768  
    var num32 uint32 = math.MaxUint32  
    var num64 uint64 = math.MaxUint64  
    var num uint = math.MaxUint  
    fmt.Printf("num8的类型是 %T, num8的大小 %d, num8是 %d\n",  
        num8, unsafe.Sizeof(num8), num8)  
    fmt.Printf("num16的类型是 %T, num16的大小 %d, num16是 %d\n",  
        num16, unsafe.Sizeof(num16), num16)  
    fmt.Printf("num32的类型是 %T, num32的大小 %d, num32是 %d\n",  
        num32, unsafe.Sizeof(num32), num32)  
    fmt.Printf("num64的类型是 %T, num64的大小 %d, num64是 %d\n",  
        num64, unsafe.Sizeof(num64), num64)  
    fmt.Printf("num的类型是 %T, num的大小 %d, num是 %d\n",  
        num, unsafe.Sizeof(num), num)  
}  
  
func main() {  
    Integer()  
    println("---------------------------------------")  
    unsignedInteger()  
}

程序返回：

num8的类型是 int8, num8的大小 1, num8是 127  
num16的类型是 int16, num16的大小 2, num16是 32767  
num32的类型是 int32, num32的大小 4, num32是 2147483647  
num64的类型是 int64, num64的大小 8, num64是 9223372036854775807  
num的类型是 int, num的大小 8, num是 9223372036854775807  
---------------------------------------  
num8的类型是 uint8, num8的大小 1, num8是 128  
num16的类型是 uint16, num16的大小 2, num16是 32768  
num32的类型是 uint32, num32的大小 4, num32是 4294967295  
num64的类型是 uint64, num64的大小 8, num64是 18446744073709551615  
num的类型是 uint, num的大小 8, num是 18446744073709551615

这里我们使用fmt.Printf将对应的整形数据类型打印出来，和Println不同的是，Printf可以使用通配符将变量嵌入到打印语句中，但也需要注意类型的一致性：

%%  一个%字面量  
%b  一个二进制整数值(基数为 2)，或者是一个(高级的)用科学计数法表示的指数为 2 的浮点数  
%c  字符型。可以把输入的数字按照 ASCII 码相应转换为对应的字符  
%d  一个十进制数值(基数为 10)  
%f  以标准记数法表示的浮点数或者复数值  
%o  一个以八进制表示的数字(基数为 8)  
%p  以十六进制(基数为 16)表示的一个值的地址，前缀为 0x,字母使用小写的 a-f 表示  
%q  使用 Go 语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字  
%s  字符串。输出字符串中的字符直至字符串中的空字符（字符串以’\0‘结尾，这个’\0’即空字符）  
%t  以 true 或者 false 输出的布尔值  
%T  使用 Go 语法输出的值的类型  
%x  以十六进制表示的整型值(基数为十六)，数字 a-f 使用小写表示  
%X  以十六进制表示的整型值(基数为十六)，数字 A-F 使用小写表示

一般情况下，在32位系统下是采用32位整形， 64 位系统下则是64位整形。

浮点 float

浮点型表示存储的数据是实数，比如 3.1415926。

package main  
  
import (  
    "fmt"  
    "math"  
)  
  
func showFloat() {  
    var num1 float32 = math.MaxFloat32  
    var num2 float64 = math.MaxFloat64  
    fmt.Printf("num1的类型是%T,num1是%g\n", num1, num1)  
    fmt.Printf("num2的类型是%T,num1是%g\n", num2, num2)  
}  
  
func main() {  
    showFloat()  
}

程序返回：

num1的类型是float32,num1是3.4028235e+38  
num2的类型是float64,num1是1.7976931348623157e+308

我们还可以针对浮点进行保留小数操作，比如百分位展示：

package main  
  
import (  
    "fmt"  
    //"math"  
    "reflect"  
    "strconv"  
)  
  
func showFloat() {  
  
    numF := 3.1415926  
    value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", numF), 64)  
    fmt.Println(reflect.TypeOf(value), value)  
}  
  
func main() {  
    showFloat()  
}

程序返回：

float64 3.14

字符 byte/rune

组成字符串的每一个元素叫做字符：

package main  
  
import (  
    "fmt"  
    //"math"  
    //"reflect"  
    "unsafe"  
)  
  
func showChar() {  
    var x byte = 65  
    var y uint8 = 65  
    fmt.Printf("x = %c\n", x) // x = A  
    fmt.Printf("y = %c\n", y) // y = A  
}  
  
func sizeOfChar() {  
    var x byte = 65  
    fmt.Printf("x = %c\n", x)  
    fmt.Printf("x 占用 %d 个字节\n", unsafe.Sizeof(x))  
  
    var y rune = 'A'  
    fmt.Printf("y = %c\n", y)  
    fmt.Printf("y 占用 %d 个字节\n", unsafe.Sizeof(y))  
}  
  
func main() {  
    showChar()  
    sizeOfChar()  
}

系统输出：

x = A  
y = A  
x = A  
x 占用 1 个字节  
y = A  
y 占用 4 个字节

一望而知，byte 类型只能表示 28个值，所以你想表示其他一些值，例如中文的话，就得使用 rune 类型。

字符串 string

字符串几乎是最常用的数据类型之一，使用起来也很方便：

package main  
  
import (  
    "fmt"  
)  
  
func main() {  
  
    mystring := "hello\tgolang1.18"  
  
    fmt.Println(mystring)  
  
}

有些字符串没有现成的文字代号，所以只能用转义字符来表示，比如这里的\t。

布尔 bool

布尔通常情况下表示真或者假，通常出现在条件语句中：

package main  
  
import (  
    "fmt"  
)  
  
func showBool() {  
    a := true  
    b := false  
    fmt.Println("a=", a)  
    fmt.Println("b=", b)  
    fmt.Println("true && false = ", a && b)  
    fmt.Println("true || false = ", a || b)  
}  
  
func main() {  
    showBool()  
}

程序返回：

a= true  
b= false  
true && false =  false  
true || false =  true

在Python中，布尔数据类型可以参与数值运算，也可以与其他类型进行转换。但是在 Go 中，真值是用 true 表示，并且 不与 1 相等；同样地，假值是用 false 表示，并且不与 0 相等，使用上相对严格，没有Python那么挥洒自如。

数据运算

常见的数学运算符：

+ - * / %(求余) ++ --

常见的比较运算符：

== != > < >= <=

逻辑运算符：

&&  所谓逻辑与运算符。如果两个操作数都非零，则条件变为真  
||  所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真  
!   所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假

以及位运算：

&   二进制与操作副本位的结果，如果它存在于两个操作数    (A & B) = 12, 也就是 0000 1100  
|   二进制或操作副本，如果它存在一个操作数 (A | B) = 61, 也就是 0011 1101  
^   二进制异或操作副本，如果它被设置在一个操作数就是按位取非    (A ^ B) = 49, 也就是 0011 0001  
&^  二进制位清空&^    (A&^B)=48，也就是110000  
<<  二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数    A << 2 =240 也就是 1111 0000  
>>  二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动   A >> 2 = 15 也就是 0000 1111

最后是赋值运算符：

=   简单的赋值操作符，分配值从右边的操作数左侧的操作数   C = A + B 将分配A + B的值到C  
+=  相加并赋值运算符，它增加了右操作数左操作数和分配结果左操作数  C += A 相当于 C = C + A  
-=  减和赋值运算符，它减去右操作数从左侧的操作数和分配结果左操作数 C -= A 相当于 C = C - A  
*=  乘法和赋值运算符，它乘以右边的操作数与左操作数和分配结果左操作数    C *= A 相当于 C = C * A  
/=  除法赋值运算符，它把左操作数与右操作数和分配结果左操作数    C /= A 相当于 C = C / A  
%=  模量和赋值运算符，它需要使用两个操作数的模量和分配结果左操作数 C %= A 相当于 C = C % A  
<<= 左移位并赋值运算符   C <<= 2 相同于 C = C << 2  
>>= 向右移位并赋值运算符  C >>= 2 相同于 C = C >> 2  
&=  按位与赋值运算符    C &= 2 相同于 C = C & 2  
^=  按位异或并赋值运算符  C ^= 2 相同于 C = C ^ 2  
|=  按位或并赋值运算符   C |= 2 相同于 C = C | 2

和Python如出一辙，Golang在数据运算方面的设计相对克制，不像Ruby，语法糖如繁星满天，数不数胜。

基本数据的输入输出

Go lang可以捕获到用户在终端的数据输入：

package main  
  
import (  
    "fmt"  
)  
  
func main() {  
    var x int  
    var y float64  
    fmt.Println("请输入一个整数，一个浮点类型：")  
    fmt.Scanln(&x, &y) //读取键盘的输入，通过操作地址，赋值给x和y   阻塞式  
    fmt.Printf("x的数值：%d，y的数值：%f\n", x, y)  
  
    fmt.Scanf("%d,%f", &x, &y)  
    fmt.Printf("x:%d,y:%f\n", x, y)  
}

终端运行：

C:\Users\liuyue\www\tornado6>go run test.go  
请输入一个整数，一个浮点类型：  
1 3.14  
x的数值：1，y的数值：3.140000  
  
x:1,y:3.140000

藉此，我们就可以完成一个小型的计算器应用了：

package main  
  
import (  
    "fmt"  
)  
  
func main() {  
    var x int  
    var y int  
    fmt.Println("请输入一个整数")  
    fmt.Scanln(&x)  
    fmt.Println("请再输入一个整数")  
    fmt.Scanln(&y)  
    sum := x + y  
    fmt.Printf("两数的和为：%d", sum)  
  
}

终端运行：

C:\Users\liuyue\www\tornado6>go run test.go  
请输入一个整数  
1  
请再输入一个整数  
2  
两数的和为：3

然后通过之前提到过的编译命令，直接打包成应用程序：

C:\Users\liuyue\www\tornado6>go build test.go  
  
C:\Users\liuyue\www\tornado6>test.exe  
请输入一个整数  
1  
请再输入一个整数  
2  
两数的和为：3  
C:\Users\liuyue\www\tornado6>

非常方便。

结语

基础数据类型是代码逻辑的最小单位，它将作为元素，存储在之后的复合数据类型中，同时，也会参与到分支、循环、判断等逻辑中。通晓基础数据类型，有助于加强我们对golang基础语法和设计理念的进一步认识和反思。