前文再续，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基础语法和设计理念的进一步认识和反思。
