分门别类输入输出,Go lang1.18入门精炼教程，由白丁入鸿儒，go lang基本数据类型和输入输出EP03

前文再续，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()  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

程序返回：

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
1
2
3
4
5
6
7
8
9
10
11

这里我们使用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 使用小写表示
1
2
3
4
5
6
7
8
9
10
11
12
13

一般情况下，在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()  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

程序返回：

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

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

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()  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

程序返回：

float64 3.14
1

字符 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()  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

系统输出：

x = A  
y = A  
x = A  
x 占用 1 个字节  
y = A  
y 占用 4 个字节
1
2
3
4
5
6

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

字符串 string

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

package main  
  
import (  
	"fmt"  
)  
  
func main() {  
  
	mystring := "hello\tgolang1.18"  
  
	fmt.Println(mystring)  
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13

有些字符串没有现成的文字代号，所以只能用转义字符来表示，比如这里的\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()  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

程序返回：

a= true  
b= false  
true && false =  false  
true || false =  true
1
2
3
4

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

数据运算

常见的数学运算符：

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

常见的比较运算符：

== != > < >= <=
1

逻辑运算符：

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

以及位运算：

&	二进制与操作副本位的结果，如果它存在于两个操作数	(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
1
2
3
4
5
6

最后是赋值运算符：

=	简单的赋值操作符，分配值从右边的操作数左侧的操作数	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
1
2
3
4
5
6
7
8
9
10
11

和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)  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

终端运行：

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

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

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)  
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

终端运行：

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

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

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

非常方便。

结语

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