狂神说Go语言学习笔记（二）

狂神说Go语言学习笔记（一）
狂神说Go语言学习笔记（三）
狂神说Go语言学习笔记（四）

一、匿名变量

匿名变量的特点是一个下划线 “_”，它本身就是一个特殊的标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用。

func test() (int, int) {
	return 100, 200
}

func main() {
	a, _ := test()
	_, b := test()
	fmt.Println(a, b) //100 200
}
1
2
3
4
5
6
7
8
9

在编码的过程中，可能会遇到没有名称的变量、类型或者方法。虽然这不是必须的，但有时候这样做可以极大地增强代码的灵活性，这些变量被统称为匿名变量。
匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

二、变量的作用域

一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量

func main() {

	//声明局部变量
	var a int = 3
	var b int = 4

	//声明局部变量
	c := a + b

	fmt.Printf("a = %d,b = %d,c = %d", a, b, c) 
	//a = 3,b = 4,c = 7
}
1
2
3
4
5
6
7
8
9
10
11
12

全局变量

在函数体外声明的变量称之为全局变量，只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用 import 关键字 引入
全局变量必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写

// 声明全局变量
var c int

func main() {

	//声明局部变量
	var a, b int
	a = 3
	b = 4
	c = a + b
	fmt.Printf("a = %d,b = %d,c = %d", a, b, c) //a = 3,b = 4,c = 7
}
1
2
3
4
5
6
7
8
9
10
11
12

Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑！

// 声明全局变量
var a float32 = 3.14

func main() {
	//声明局部变量
	var a int = 3
	fmt.Println(a)  //3
}
1
2
3
4
5
6
7
8
9

三、常量

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型

const identifier [type] = value
1

你可以省略说明符 [type] ，因为编译器可以根据变量的值来推断其类型
多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2
1

常量的定义：const

func main() {

	//显示定义
	const a int = 3

    //隐式定义
	const b = "只因"

	const c, d, e = false, "下蛋", "哥哥"

	fmt.Println(a, b)//3 只因
	
	fmt.Println(c, d, e) //false 下蛋 哥哥
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

四、常量iota

iota,特殊常量，可以认为是一个可以被编译器修改的常量，iota是Go语言的常量计数器
iota在const关键字出现时将被重置为0

func main() {

	const (
		a = iota
		b
		c
		e = "只因"
		d
		f = "哥哥"
		g
		h = iota
	)

	const (
		i = iota
		j
	)
	fmt.Println(a, b, c, d, e, f, g, h) //0 1 2 只因 只因 哥哥 哥哥 7
	fmt.Println(i, j)                   //0 1
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

五、布尔类型

func main() {

	// bool : true false
	// bool 默认值是 false

	var isFlag bool = true

	fmt.Println(isFlag) //true
	fmt.Printf("%T,%t\n", isFlag, isFlag)  //bool,true

}
1
2
3
4
5
6
7
8
9
10
11

六、数字类型

func main() {
	/**
	别名
	byte unit8
	rune int32
	int  int64
	 */
	
	//定义一个整型
	var age int = 18

	//定义一个浮点型
	//默认是六位小数打印
	var money float64 = 3.14

	fmt.Printf("%T,%d\n", age, age)     //int,18
	fmt.Printf("%T,%f\n", money, money) //float64,3.140000
	//指定小数位 但是有可能丢失精度
	fmt.Printf("%T,%.2f\n", money, money) //float64,3.14
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

七、字符与字符串

Go语言的字符串的字节使用UTF-8编码表示Unicode文本

    var str string = "只因"
	fmt.Printf("%T,%s\n", str, str) //string,只因

	//单引号 字符，整型——ASCII字符码
	v1 := '中'
	v2 := 'A'

	//编码表 ASCII字符码
	//扩展：
	//所有的中国字的编码表：GBK
	//全世界的编码表：Unicode编码表
	fmt.Printf("%T,%d\n", v1, v1) //int32,20013
	fmt.Printf("%T,%d\n", v2, v2) //int32,65	 

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

Go语言的字符串连接可以通过+实现

//字符串连接 +
	fmt.Println("hello," + "giegie")
1
2

转义字符

//转义字符
	fmt.Println("hello\"giegie") // hello
	fmt.Println("hello\ngiegie") //n 换行   
	fmt.Println("hello\tgiegie") //t 制表符  hello   giegie
1
2
3
4

八、数据类型的转换

在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明：

valueOfTypeB = typeB(valueOfTypeA)
1

类型B的值 = 类型B（类型A的值）

    a := 5.0    //float
	b := int(a) //转换为int

	fmt.Printf("%T,%f\n", a, a) //float64,5.000000
	fmt.Printf("%T,%d\n", b, b) //int,5

	//不能转换为bool类型
	//e := bool(a)
1
2
3
4
5
6
7
8

类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型（将 int16 转换为 int32）当从一个取值范围较大的类型转换到取值范围较小的类型时（将 int32 转换为 int16 或者将 float 转换为 int），会发生精度丢失的情况

九、算数运算符

    var a int = 10
	var b int = 3

	fmt.Println(a + b)
	fmt.Println(a - b)
	fmt.Println(a * b)
	fmt.Println(a / b)
	fmt.Println(a % b)
	a++
	fmt.Println(a)
	a--
	fmt.Println(a)
1
2
3
4
5
6
7
8
9
10
11
12

十、逻辑运算符

	var a int = 10
	var b int = 11

	// == 等于 = 赋值
	//关系运算符 结果都是bool
	fmt.Println(a == b)
	fmt.Println(a != b)
	fmt.Println(a > b)
	fmt.Println(a < b)
	fmt.Println(a >= b)
	fmt.Println(a <= b)

	if a > b {
	} else {
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15