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