本文将介绍go语言基本数据类型（整型、浮点型、字符串、布尔型等）、常量、变量，下文通过实例和文字描述上述内容。

1 基本数据类型

1.1 整型

整型分为无符号整型和有符号整型
uint8 无符号8位整型 （取值范围：0到255）
uint16 无符号16位整型 （取值范围：0到65535）
uint32 无符号32位整型 （取值范围：0到4294967295 约43亿）
uint64 无符号64位整型 （取值范围：0到18446744073709551615）

int8 有符号8位整型 （取值范围：-128到127）
int16 有符号16位整型 （取值范围：-32768到32767）
int32 有符号32位整型 （取值范围：-2147483648到2147483647 约43亿）
int64 有符号64位整型 （取值范围：-9223372036854775808 到9223372036854775807）

提示：
如果是64位操作系统, int默认是int64；32位操作系统默认是int32

1.2 浮点型

浮点型分为浮点数、实数和虚数
float32 32位浮点数
float64 64位浮点数
complex64 32位实数和虚数
complex128 64位实数和虚数

提示：
float不存在这个类型

1.3 字符串

字符串为一串固定长度的字符组合起来的字符序列。GO语言的字节使用UTF-8编码标识Unicode文本

1.4 布尔型

布尔型的值为常量true或false

1.5 其它派生类型

指针类型 （pointer）
数组类型 （array）
结构体类型（struct）
函数类型 （func）
切片类型 （slice）
集合类型 （set）
通道类型 （channel）
接口类型 （interface）

2 变量和常量

2.1 变量

三种声明方式

（1）指定变量类型，使用默认值（不赋值）
如： var v_val int (v_val默认为0)
提示：

• bool型默认为false；
• int 型默认为0；
• float型默认为0；
• pointer型默认为nil；

（2）根据值自动判定变量类型
如： var v_val = 10 (v_val默认为int型)

（3）省略var，自动判定变量及类型
如： v_val := 10 (v_val默认为int型)
提示： v_val不能是已经申明的变量，不能是全局变量

例子： 三种变量声明方式

1. package main
3. import . "fmt"
5. func main() {
6. var v_val1 int
7. var v_val2 = 10
8. v_val3 := 10
10. Println(v_val1)
11. Println(v_val2)
12. Println(v_val3)
13. }
15. [[email protected] ex]# go run ./ex.go
16. 0
17. 10
18. 10

例子：整型、浮点型、bool型和指针的默认值

1. package main
3. import . "fmt"
5. func main() {
6. var val1 int
7. var val2 float32
8. var val3 bool
9. var val4 *int
11. Println(val1)
12. Println(val2)
13. Println(val3)
14. Println(val4)
15. }
17. [[email protected] ex]# go run ./ex.go
18. 0
19. 0
20. false
21. <nil>

全局和局部变量

全局变量：在函数体之外，可以被当前文件以及其他文件访问的变量
局部变量：在函数体之内，作用范围是该函数体的变量

多个变量声明

声明方式1，一般用于局部变量
var val1, val2, val3 int
val1, val2 val3 = 10, 11, 12

声明方式2，一般用于局部变量
var val1, val2, val3 = 10, 11.1, true

声明方式3，用于局部变量，不能用于全局变量
val1, val2, val3 := 10, 11.1, true

声明方式4，一般用于全局变量
var (
val1 int
val2 bool
)

例子

1. package main
3. import . "fmt"
5. var (
6. val1 int
7. val2 bool
8. )
10. var val3, val4 int
11. var val5, val6, val7 = 10, "cc", 1.1 /* 不能直接忽略某个元素*/
13. func main(){
14. val5 = 100 /* 全局定义重赋值, 使用val5 = 1.1报错，类型一致*/
15. Println(val1, val2, val3, val4, val5, val6, val7)
16. val5, val6 := 1.2, "cerry" /* 重新申明val5、val6的类型*/
17. Println(val5, val6)
18. }
20. [[email protected] ex]# go run ./ex.go
21. 0 false 0 0 100 cc 1.1
22. 1.2 cerry

提示： 声明的变量必须被使用，否则报错

2.2 常量

一般常量

（1）显式类型定义
const str1 string = “hello”
(2) 隐式类型定义
const str2 = “hello”
（3）多个相同类型的声明
const str1, val1, val2 = “abc”, 4, 5.1
(4) 常量枚举
const (
default = 0
apple = 1
banana = 2
)

扩展知识： 使用unsafe包，计算所占字节大小

1. package main
3. import . "fmt"
4. import "unsafe"
6. const (
7. a = "hello"
8. b = len(a)
9. c = unsafe.Sizeof(a)
10. )
12. func main(){
13. Println(a, b, c)
14. }
16. [[email protected] ex]# go run ./ex.go
17. hello 5 16

特殊常量iota

iota 表示默认从 0 开始自动加 1

1. package main
3. import . "fmt"
5. func test() {
6. const (
7. a = iota //0
8. b //1
9. c //2
10. d = "cc" //独立值，iota += 1
11. e //继承d， "cc" iota += 1
12. f = 100 //iota +=1
13. g //继承f, 100 iota +=1
14. h //继承f, 100 iota +=1
15. i = iota //7,恢复计数
16. j //8
17. )
18. Println(a,b,c,d,e,f,g,h,i,j)
19. }
21. const (
22. i=1<<iota // 1 << 0 = 1
23. j=3<<iota // 3 << 1 = 6
24. k // 3 << 2 = 12
25. l // 3 << 3 = 24
26. )
29. func main() {
31. Println("i=",i)
32. Println("j=",j)
33. Println("k=",k)
34. Println("l=",l)
36. test()
37. }
39. [[email protected] ex]# go run ./iota.go
40. i= 1
41. j= 6
42. k= 12
43. l= 24
44. 0 1 2 cc cc 100 100 100 8 9

版权声明：B链网原创，严禁修改。转载请注明作者和原文链接
http://www.360bchain.com/article/141.html