Go基本类型

布尔型：bool

  • 长度：1字节
  • 取值范围：true, false
  • 注意事项：不可以用数字代表true或false

整型：int/uint

  • 根据运行平台可能为32或64位

8位整型：int8/uint8

  • 长度：1字节
  • 取值范围：-128127/0255

字节型：byte（uint8别名）

16位整型：int16/uint16

  • 长度：2字节
  • 取值范围：-3276832767/065535

32位整型：int32（rune）/uint32

  • 长度：4字节
  • 取值范围：-2^32/22^32/2-1/02^32-1

64位整型：int64/uint64

  • 长度：8字节
  • 取值范围：-2^64/22^64/2-1/02^64-1

浮点型：float32/float64

  • 长度：4/8字节
  • 小数位：精确到7/15小数位

复数：complex64/complex128

  • 长度：8/16字节
    足够保存指针的 32 位或 64 位整数型：uintptr

其它值类型：

  • array、struct、string
    引用类型：
  • slice、map、chan

接口类型：inteface
函数类型：func

类型零值

零值并不等于空值，而是当变量被声明为某种类型后的默认值，通常情况下值类型的默认值为0，bool为false，string为空字符串

类型别名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

type (
	byte int8
	rune int32
	文本 string
)

func main()  {
	var s 文本
	s = "类型别名"
	fmt.Println(s)
}

上面我们定义了byte、rune和文本三个类型别名，类型别名和原类型一样使用

单个变量的声明与赋值

变量的声明格式：var <变量名称> <变量类型>
变量的赋值格式：<变量名称> = <表达式>
声明的同时赋值：var <变量名称> [变量类型] = <表达式> 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import "fmt"

func main()  {
	// 变量的声明
	var a int

	// 变量的赋值
	a = 123

	// 变量声明的时候同时赋值
	var b int = 321

	// 上行的格式可省略变量类型，由系统推断
	var c = 789

	// 变量声明与赋值最简单的写法
	d := 987

	fmt.Println(a, b, c, d)
}

多个变量的声明与赋值

全局变量的声明可使用 var() 的方式进行简写
全局变量的声明不可以省略 var，但可使用并行方式
所有变量都可以使用类型推断
局部变量不可以使用 var() 的方式简写，只能使用并行方式 

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
package main

import "fmt"

// 全局变量var关键字不能省略
var (
	// 使用常规方式
	aaa = "hello"
	// 使用并行方式以及类型推断
	bbb, ccc = 1, 2
)

func main()  {
	// 多个变量的声明
	var a, b, c, d int

	// 多个变量的赋值
	a, b, c, d = 1, 2, 3, 4

	// 多个变量声明的时候同时赋值
	var e, f, g, h int = 5, 6, 7, 8

	// 省略变量类型，由系统推断
	var i, j, k, l = 9, 10, 11, 12

	// 省略变量类型，由系统推断
	i, j, k, l = 9, 10, 11, 12

	// 多个变量声明与赋值的最简写法
	m, n, o, p := 13, 14, 15, 16

	fmt.Println(aaa, bbb, ccc, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
}

变量的类型转换

Go中不存在隐式转换，所有类型转换必须显式声明
转换只能发生在两种相互兼容的类型之间
类型转换的格式：

1
<ValueA> [:]= <TypeOfValueA>(<ValueB>)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main()  {
	// 在相互兼容的两种类型之间进行转换
	var a float32 = 1.1
	b := int(a)
	fmt.Println(b)

	/* 以下表达式无法通过编译
	var c bool = true
	d := int(c)
	 */
}

思考问题

请尝试运行以下代码，看会发生什么，并思考为什么

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main()  {
	var a int = 65
	b := string(a)
	fmt.Println(b)
}

最后会输入字母：A
string() 表示将数据转换成文本格式，因为计算机中存储的任何东西本质上都是数字，因此此函数自然地认为我们需要的是用数字65表示ASCII码中的文本 A

如果真要实现整形转字符串和看到的一样，可以这样来实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
	"fmt"
	"strconv"
)

func main()  {
	var a int = 65
	// 整形转字符串
	b := strconv.Itoa(a)
	fmt.Println(b)
	// 字符串转整形，使用到了赋值多变量，_代表忽略该参数
	c, _ := strconv.Atoi(b)
	fmt.Println(c)
}

输出：

1
2
65
65