Go语言入门【1】数据类型、变量、常量

常见基本数据类型

uint8：无符号8位整形，取值范围：0-255

uint16：无符号16位整形，取值范围：0-65535

uint32：无符号32位整形，取值范围：0-4294967295

uint64：无符号64位整形，取值范围：0-18446744073709551615

uint：32 或 64 位

int8：有符号8位整形，取值范围：-128-127

int16：有符号16位整形，取值范围：-32768-32767

int32：有符号32位整形，取值范围：-2147483648-2147483647

int64：有符号64位整形，取值范围：-9223372036854775808-9223372036854775807

int：与uint一样大小

byte：类似 uint8

rune：类似 int32

float32：32位浮点类型

float64：64位浮点类型

string：字符串

bool：布尔类型，取值true或false

变量

Go 语言变量名由字母、数字、下划线组成，首字符不能为数字，不能使用关键字作为变量名。

Go语言中的25个关键字：

使用关键字var，并指定变量类型

// 声明单个变量
var 变量名 变量类型
// 声明多个变量
var 变量名1, 变量名2 变量类型
1
2
3
4

初始化变量

// 声明并初始化单个变量
var 变量名 变量类型 = 值
// 声明并初始化多个变量
var 变量名1, 变量名2 变量类型 = 值1, 值2
1
2
3
4

示例1，当只声明不初始化变量时，则输出默认值，int类型默认值为0，string默认值为""空字符串，bool类型默认false

package main

import "fmt"

func main() {
	var s string
	fmt.Println(s)						// 输出
	var a, b int
	fmt.Println(a, b)					// 输出0 0
}
1
2
3
4
5
6
7
8
9
10

示例2：声明并初始化变量

package main

import "fmt"

func main() {
	var s string = "hello world"
	fmt.Println(s)						// 输出hello world
	var a, b int = 1, 2
	fmt.Println(a, b)					// 输出1 2
}
1
2
3
4
5
6
7
8
9
10

使用关键字var，不指定类型

var 变量名 = 值
1

示例：

package main

import "fmt"

func main() {
	var s = "hello world"
	fmt.Println(s)				// 输出hello world
	var a, b = 1, 2
	fmt.Println(a, b)			// 输出1 2
}
1
2
3
4
5
6
7
8
9
10

使用:=

变量名 := 值
1

示例：

package main

import "fmt"

func main() {
	s := "hello world"
	fmt.Println(s)				// 输出hello world
	a, b := 1, 2
	fmt.Println(a, b)			// 输出1 2
}
1
2
3
4
5
6
7
8
9
10

使用该方法，如果某个变量在之前已经使用var的方式进行了声明，再使用:=方式会出现编译错误，但是可以使用=进行复制不会报错。

多变量声明

该方法声明变量多用于声明全局变量

var(
    变量名1 变量类型 = 值1		// 同样可以不指定变量类型，使用 变量名 = 值 的形式，但是不能使用 := 
    变量名2 变量类型 = 值2
)
1
2
3
4

示例：

package main

import "fmt"

var (
	s string = "hello world"
	a int = 1
	b int = 2
)

func main() {
	fmt.Println(s)				// 输出hello world
	fmt.Println(a, b)			// 输出1 2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

变量注意事项

1. 在GO语言中，如果声明了一个变量，就必须使用，如果变量声明了但是不使用就会报错。
2. 全局变量可以只声明不使用不会报错。

常量

常量就是不会改变的值，一般用于用于在程序运行期间不会被改变的值，常量和变量的声明类似，只是将var关键字变成了const。与变量不同的是，常量在声明的时候必须赋值。

使用const定义常量

示例：

package main

import "fmt"

// 多常量声明
const (
	s = "hello world"
	a = 1
)

func main() {
	const PI = 3.1415							// 不指定常量类型
	const E float32 = 2.7182			// 指定常量类型
	fmt.Println(s)								// 输出hello world
	fmt.Println(a)								// 输出1
	fmt.Println(PI)								// 输出3.14
	fmt.Println(E)								// 输出2.7182
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

iota

iota是Go语言中的常量计数器，只能在常量的表达式中使用，iota在const出现时被初始化为0，在const中每增加一个常量定义，则iota加1。

示例：

package main

import "fmt"

// 多常量声明
const (
	a = 1					// iota = 0
	b = 2					// iota = 1
	c = iota				// iota = 2
)

func main() {
	const d = iota			// iota = 0
	fmt.Println(d)			// 输出0
	fmt.Println(c)			// 输出2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16