Golang学习，指针，循环控制相关

这里总结的Golang 笔记只适合有点编程基础的人看，比如Java

==补充：==语言规范，由26个英文字符，0-9，_去做命名的，且不能以数字开头，严格区分大小写，不能出现空格。（这里需要注意的是_不能单独作为变量名去使用，单独的情况下只能作为占位符去使用）。
eg：fmt下面的这个库函数使用

func main()  {
	var a int
	b,_ := fmt.Scanf("%d", &a)
	fmt.Println("a的值： ", a, "b的值： ", b)
}
// 打印的结果 a的值：  5 b的值：  1

如上图所示：_这个就是作为占位使用，你不能在输出函数中输出，会直接报错的。

指针

指针是什么

Go语言中的函数传参都是值拷贝，当我们想要修改某个变量的时候，我们可以创建一个指向该变量地址的指针变量。传递数据使用指针，而无须拷贝数据。类型指针不能进行偏移和运算。Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值）。

以下代码就是创建变量的指针变量传递，然后交换值，如果不创建指针变量的话直接传递值的话，交换值的话，实际i，j的值不会发生变化，发生变换的只是函数存储区域的副本交换。

func main() {
	// 值类型都有对应的指针类型
	var i = 10
	var j = 20
	var ptr1 *int = &i
	var ptr2 *int = &j
	swap(ptr1, ptr2)
	fmt.Printf("i: %d  j:  %d", i, j)
}

func swap(num1 *int, num2 *int)  {
	tmp := *num1
	*num1 = *num2
	*num2 = tmp
}

指针使用

&（取地址）和（根据地址取值）。*
这里需要注意 a存储的其实只是num的地址，*a地址存储的值，*a = 10 的话num也就会变为10，这里修改的是a存储这个地址下的值。根据打印结果对应关系。

func main()  {
	var num int = 32
	var a *int = &num
	fmt.Println(*a)
	fmt.Println("num地址：", &num)
	fmt.Println("a地址：", &a)
	fmt.Println("a的值", a)
	fmt.Println("num的值：", *a)
}

指针存储图结构

值类型

值类型：变量直接存储值，内存通常在栈中分配

引用类型

引用类型：变量存储的是一个地址，这个地址对于的空间才是真正的存储数据（值），内存通常在堆上分配，当没有任何变量引用这个地址时，改地址对应的数据空间就成为了一个垃圾，由GC来回收

Switch介绍

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。 Golang switch 分支表达式可以是任意类型，不限于常量。可省略 break，默认自动终止。（这里与java中是不同的，java中是需要break）

注意：

• Switch 中case表达式后的语句可以有多个，多个语句之间用逗号分隔。
• switch 之后的数据类型和case之后的数据类型必须保持一致。
• case后面的值如果是常量值的时候，那么值是不能重复的。

基本使用

package main
import "fmt"
func main() {
	var day int = 1
	switch day {
	case 1:
		fmt.Println("星期一")
	case 2:
		fmt.Println("星期二")
	}
}

fallthrough使用

fallthrough 可以穿透一层case，直接执行下一层的case

package main
import "fmt"
func main() {
	var day int = 1
	switch day {
	case 1:
		fmt.Println("星期一")
		fallthrough // 这个关键词只可以穿透一层
	case 2:
		fmt.Println("星期二")
	}
}

如上打印的值：
星期一
星期二

Switch实现if作用

package main
import "fmt"
func main() {
	var score int = 10
	switch {
	case score > 100:
		fmt.Println("不符合规范")
	case score < 100 && score >= 60:
		fmt.Println("成绩合格")
	}
}

switch后跟函数

这里的函数其实也可以理解为一个变量，这个函数的返回值去和case后的做匹配，最终实现效果

func main() {
	fmt.Println()

	var operate byte
	fmt.Scanf("%c", &operate)
	fmt.Println(operate)

	var result int
	// golang 中case之后可以有多个表达式，表达式中的常量不能重复
	switch oper(operate) {
	case 'a':
		fmt.Println("a")
	case 'b':
		fmt.Println("b")
	case 'c':
		fmt.Println("c")
	case 'd':
		fmt.Println("d")
	}

	fmt.Println("result: " , result)
}

func oper(s byte) byte {
	return s + 1
}

switch中还有一种就是后跟初始化语句 switch i := x.(type)，这里不做演示。

戒骄戒躁，冲冲冲