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