package main

import (
	"fmt"
	"math"
)

/*
类型零值：
1.零值并不等于空值，而是当变量被声明为某种类型后的默认值
2.通常情况下值类型的默认值为0，bool为false，string为空字符串  */
func main()  {
	var a int		//零值为：0
	var b string	//零值为：空
	var c bool		//零值为：false
	var d []int		//在数组中没有指定容量，则为切片
	var e [1]int	//真正意义上的数组是又一个容量值的，此处数组容量设为[1]，数组类型为int型的零值为:[0]
	var f [1]bool	//bool型数组零值：false
	var g [1]byte	//字节型数组零值：0
	fmt.Println("a:",a)
	fmt.Println("b:",b)
	fmt.Println("c:",c)
	fmt.Println("d:",d)
	fmt.Println("e:",e)
	fmt.Println("f:",f)
	fmt.Println("g:",g)
	fmt.Println(math.MinInt8)	//math包可以用来检查变量赋值是否有溢出范围
	fmt.Println(math.MinInt16)
	fmt.Println(math.MinInt32)
	fmt.Println(math.MaxInt32)
}

//输出结果：
/*
a: 0
b:
c: false
d: []
e: [0]
f: [false]
g: [0]
-128
-32768
-2147483648
2147483647
 */ 

//类型别名与变量赋值
package main

import "fmt"

//单个变量的声明与赋值
/*
1.变量的声明格式：var <变量名称> <变量类型>
2.变量的赋值格式：<变量名称> = <表达式>
3.声明的同时赋值：var <变量名称> [变量类型] = <表达式>
 */

type (
	文本 string		//把文本设置为string的别名
)

func main(){
	var s 文本            //使用类型别名
	s = "你好"
	fmt.Println(s)

	var a int		//变量的声明
	a = 111			//变量的赋值
	var b int = 222	//变量声明的同时赋值
	var c = 333		//也可以省略数据类型，由系统推断
	d := 444		//变量声明与赋值的最简单写法

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

package main

import (
	"fmt"
	"strconv"
)

func main()  {
	var a int = 65
	b := string(a) //string()表示将数据转换成文本格式，因为计算机中存储的任何东西;本质上都是数字，因此此函数自然地认为我们需要的是用数字65表示的文本A

	c := strconv.Itoa(a)	//将整型65转换成字符型的65
	a, _ = strconv.Atoi(c)	//将字符型65转换成整型的65

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

//输出结果：
/*
A
65
65
 */　　 

//常量的定义
/*
1.常量的值在编译时就已经确定
2.常量的定义格式与变量基本相同
3.等号右侧必须是常量或者常量表达式
4.常量表达式中的函数必须是内置函数
 */
package main
import "fmt"

//定义单个常量
const a int = 12
const b  = \'A\'
const (
	text = "123"
	length = len(text)
	num = b * 23
	c = d
	d = a+1
	e = a+2
	f,g = 3,"4"
	h,i			//h,i套用了上面f,g 的常量表达式格式后，则f,g的常量值分别赋值于h,i
)

//同时定义多个常量
const j,k ,l = 1,"2","3"
const  (
	text1 = "456"
	length1 = len(text)
	num1 = b * 24
)
func main()  {
	fmt.Println(a,b,c,d,e,f,g,h,i,j,k,l,text,length,num,text1,length1,num1)
} 

//常量的初始化规则与枚举
package main

import "fmt"

//常量名一般大写
//在定义常量组时，如果不提供初始值，则表示将使用上行的表达式
const (
	a = 1
	b
	c
	d,e = 3,"4"
	f,g
)

//iota是常量的计数器，从0开始，组中每定义1个常量自动递增1,第一个常量从0计数开始
const (
	a1 = "A"
	b1
	c1 = iota	//此处iota的值为2，因为已经定义了3个常量(包括本身)，所以c1值是2
	d1			//d1值是3
)

//通过初始化规则与iota可以达到枚举的效果
const (
	Sunday = iota	//第一个常量不可省略表达式
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

//每遇到一个const关键字，iota就会重置为0
const (
	e1 = iota   //定义了一个常量，e1值为0
	f1			//所以f1值为1
)

func main()  {
	fmt.Println(a,b,c,d,e,f,g)
	fmt.Println(a1,b1,c1,d1,e1,f1)
	fmt.Println(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday)
}

//输出结果：
/*
1 1 1 3 4 3 4
A A 2 3 0 1
0 1 2 3 4 5 6
 */ 

//运算符

/*
Go中的运算符均是从左至右结合
优先级（从高到低）

^ ;  !            （一元运算符）
*;  /;  %;  << >>;  &;  &^
+ ;  -; |;  ^     （二元运算符）
==;   != ;  < ;   <= ;   >= ;   >
<-                （专门用于channel）
&&   如果左边的条件不成立，那么右边的表达式不再执行；GO语言中一般使用&&,而不使用&
||
 */

package main

import "fmt"

func main()  {
	//一元运算
	fmt.Println(^1)
	fmt.Println(!true)
	fmt.Println("--------------------")

	fmt.Println(2*4)
	fmt.Println(34/2)
	fmt.Println(7%2)
	fmt.Println(1<<10)
	fmt.Println(1>>10)
	fmt.Println("--------------------")

	/*
6:   0110
11:  1011
----------------	//运算后再输出十进制
&	 0010 = 2		// 两个值同时为真，则为真
|	 1111 = 15		// 两个值有一个为真，则为真
^	 1101 = 13		// 两个值一个为真，另一个为假；则运算后为真；同时为真或假，均为假
&^	 0100 = 4		// 第二个值为1时，则把第一个值改为0；为0时，则为1
*/
	fmt.Println(6&11)
	fmt.Println(6|11)
	fmt.Println(6^11)
	fmt.Println(6&^11)
	fmt.Println("--------------------")

	//运算符&&的用法
	a := 1
	if a>0 && (10/a)>2{
		fmt.Println("ok")
	}

}

//请尝试结合常量的iota与<<运算符实现计算机储存单位的枚举
package main

import "fmt"

const (
	_		    = iota
	KB  float64 =  1 << (iota * 10)
	MB
	GB
	TB
	PB
	EB
	ZB
	YB
)

func main()  {
	fmt.Println(KB)
	fmt.Println(MB)
	fmt.Println(GB)
	fmt.Println(TB)
	fmt.Println(PB)
	fmt.Println(EB)
	fmt.Println(ZB)
	fmt.Println(YB)

}

//输出结果：
/*
1024
1.048576e+06
1.073741824e+09
1.099511627776e+12
1.125899906842624e+15
1.152921504606847e+18
1.1805916207174113e+21
1.2089258196146292e+24

 */　　

//指针
/*
Go虽然保留了指针，但与其它编程语言不同的是，在Go当中不
支持指针运算以及”->”运算符，而直接采用”.”选择符来操作指针
目标对象的成员
1.操作符”&”取变量地址，使用”*”通过指针间接访问目标对象
2.默认值为 nil 而非 NULL
 */
 package main

import "fmt"

func main()  {
	a := 1
	a++			//在Go当中，++ 与 -- 是作为语句,而并不是作为表达式
	var P *int = &a		//&a 表示变量a的地址

	fmt.Println(P)	 //输出P指针指向a的地址
	fmt.Println(*P)	 //输出P指针指向a的值
	a--
	fmt.Println(*P)

}

//输出结果：
/*
0xc042050080
2
1
*/

//判断语句if-else
/*
1.条件表达式没有括号
2.支持一个初始化表达式（可以是并行方式）
3.左大括号必须和条件语句或else在同一行，{}也支持单行模式
4.初始化语句中的变量为block级别，同时隐藏外部同名变量
*/
package main
import "fmt"

func main()  {
	a := true

	// if 变量初始化;条件语句 ， 可同时进行；也可以只写条件语句
	if a,b,c := 1,2,3;a+b+c > 6{	// 条件表达式没有括号，a,b,c的作用域仅在if-elae语句块中，在该语句块之外无法使用
		fmt.Println("大于6")		// if-else语句块中的a会覆盖语句块之外的a
	}else {
		fmt.Println("小于等于6")
		fmt.Println(a)		// 只输出if-else语句块中的a
	}
	fmt.Println(a)		// 输出if-else语句块之外的a
}

//输出结果：
/*
小于等于6
1
true
 */

// for循环语句形式一
package main

import "fmt"

func main()  {
	a := 1
	for{			// 无条件语句的for循环
		a++
		if a > 3{
			break
		}
		fmt.Println(a)
	}
	fmt.Println("for over")
	fmt.Println(a)
}

//输出结果：
/*
2
3
for over
4
*/　　

// for循环语句形式二
package main

import "fmt"

func main()  {
	a := 1
	for a <= 3{		//带有条件语句的for循环
		a++
		fmt.Println(a)
	}
	fmt.Println("for over")
	fmt.Println(a)
}

//输出结果：
/*
2
3
4
for over
4
*/　　

package main

import "fmt"

func main()  {
	a := 1
	for i := 0; i < 3; i++{		// 经典形式：带有步进表达式的for循环
		a++
		fmt.Println(a)
	}
	fmt.Println("for over")
	fmt.Println(a)
}

//输出结果：
/*
2
3
4
for over
4
*/　　

package main

import "fmt"

func main()  {
	a := "string"
	l := len(a)		// 一般是把函数的值赋予一个变量，然后用于for循环的条件语句中
	//for i := 0; i < len(a); i++{		//最好不要在for循环的条件语句中使用函数，函数内部复杂会很耗时
	for i := 0; i < l; i++{
		fmt.Println(i)
	}
	fmt.Println("for over")
	fmt.Println(a)
}

 //输出结果：
 /*
0
1
2
3
4
5
for over
string
 */　　

//switch语句形式一
package main

import "fmt"

func main()  {
	a := 1
	switch a {
	case 0:				 //case语句块为true,则执行该代码块；为false则跳过该代码块
		fmt.Println("a=0")
	case 1:
		fmt.Println("a=1")
	default:
		fmt.Println("None")
	}
	fmt.Println(a)
}

//输出结果
/*
a=1
1
*/

//switch语句形式二
package main

import "fmt"

func main()  {
	a := 1
	switch   {
	case a >= 0:		//如果此处条件表达式为true,则执行该代码块后自动跳出switch语句块，不再执行下一个case语句块
		fmt.Println("a=0")
		fallthrough		//加上关键字fallthrough后，则第一个case语句执行后，继续检查第二个case条件语句；为true时，继续执行
	case a >= 1:
		fmt.Println("a=1")
	default:
		fmt.Println("None")
	}
	fmt.Println(a)
}

//输出结果：
/*
a=0
a=1
1
*/　　

//continue的用法
package main

import "fmt"

func main()  {
	LABEL1:
		for i := 0; i < 3; i++ {
			fmt.Println("hello")  //此处循环输出3次
			for {
				fmt.Println("inside1")  //此处循环输出3次
				continue LABEL1				//终止当前循环，跳转到LABEL1继续执行下面的循环语句
				//goto LABEL1				//运行到此处，立即调整到LABEL1重新执行，无限循环上面的输出语句
				fmt.Println("inside2")	//此处永远不会被执行
			}
		}
		fmt.Println("outside")
}

//输出结果：
/*
hello
inside1
hello
inside1
hello
inside1
outside
*/　　

//go语言版冒泡排序
package main

import "fmt"

func main() {
	a := [...]int{5, 2, 6, 3, 9}
	fmt.Println("排序前：",a)

	num := len(a)
	for i := 0; i < num; i++ {
		for j := i + 1; j < num; j++ {
			if a[i] < a[j] {
				temp := a[i]
				a[i] = a[j]
				a[j] = temp
			}
		}
	}
	fmt.Println("排序后：",a)
}

//输出结果：
/*
排序前： [5 2 6 3 9]
排序后： [9 6 5 3 2]
 */　　

// 切片slice,本质上是一个动态数组，注意两者初始化和函数参数的区别
package main

import "fmt"

func main() {

	//初始化：数组需要指定大小，不指定也会根据初始化给出的值自动推算出大小，不可改变
	a1 := [...]int{1, 2, 3}
	a2 := [3]int{4, 5, 6}
	fmt.Println(a1, a2)
	fmt.Println("-----------------------------")

	//切片不需要指定大小
	var slice []int //定义一个空的切片,和空的数组写法相同
	s1 := []int{1, 2, 3}
	s2 := make([]int, 10)                      //切片的标准定义法，使用make()
	s3 := make([]int, 5, 10)                   //第一参数表示类型，第二参数表示切片长度，第三参数表示切片最大容量；容量不够时，系统翻倍(10*2)重新分配内存容量
	fmt.Println(s3, len(s3), cap(s3), cap(s2)) // 空的切片默认为0值；输出切片的长度和容量,如果不设置容量，则默认为元素的长度；例s2
	fmt.Println("-----------------------------")
	s4 := [10]int{9: 23}                //对索引为9的元素赋值为23
	s5 := s4[9]                         //取单个索引的元素
	var s6 []int = []int{1, 2, 3, 4, 5} //经典示例：s6切片无需指定大小，直接可与右边切片做比较
	s7 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	s8 := s7[5:10] //取索引为5到10的元素；注意：此处包含起始索引，不包含终止索引
	s9 := s7[5:]   //输出切片中第5到最后一个元素
	s10 := s7[:5]  //输出切片中第1个至第5个元素

	fmt.Println(slice)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println(s4)
	fmt.Println(s5)
	fmt.Println(s6)
	fmt.Println(s7)
	fmt.Println(s8)
	fmt.Println(s9)
	fmt.Println(s10)

}

//输出结果：
/*
[1 2 3] [4 5 6]
-----------------------------
[0 0 0 0 0] 5 10 10
-----------------------------
[]
[1 2 3]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 23]
23
[1 2 3 4 5]
[1 2 3 4 5 6 7 8 9 10]
[6 7 8 9 10]
[6 7 8 9 10]
[1 2 3 4 5]
*/

// reslice  对slice某一部分的截取称为reslice
/*
1.reslice时索引以被slice的切片为准
2.索引不可以超过被slice的切片的容量cap()值
3.索引越界不会导致底层数组的重新分配而是引发错误
*/

// append
/*
1.可以在slice尾部追加元素
2.可以将一个slice追加在另一个slice尾部
3.如果最终长度未超过追加到slice的容量则返回原始slice
4.如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据
*/

package main

import "fmt"

func main() {
	s := make([]int, 3, 6)
	fmt.Println("定义3个元素的切片s1：", s, len(s), cap(s))
	s = append(s, 1, 2, 3)                     // 向s1追加3个元素
	fmt.Println("追加3个元素：", s, len(s), cap(s))  //长度变为6，容量未超出，不需重新分配
	s = append(s, 4, 5, 6)                     //再追加3个元素
	fmt.Println("再追加3个元素：", s, len(s), cap(s)) //长度变为9，容量超出原有范围，重新翻倍分配内存容量

	a := []int{1, 2, 3, 4, 5}
	s1 := a[2:5] //输出第3个元素到第5个元素，不包含2
	s2 := a[1:3] //输出第2个元素到第3个元素，不包含1
	fmt.Println(s1, s2)
	s1[0] = 9 //此处的改变同时指向s1,s2底层的数组元素3，重新赋值为9
	fmt.Println(s1, s2)

	s3 := append(s2, 4, 5, 6, 7, 8, 9) //如果追加的元素超过最大容量，则底层数组重新分配空间；
	s1[0] = 23       //则给一个数组的元素重新赋值，另一个相同元素不会再改变
	fmt.Println(s1,s3)
}

//输出结果：
/*
定义3个元素的切片s1： [0 0 0] 3 6
追加3个元素： [0 0 0 1 2 3] 6 6
再追加3个元素： [0 0 0 1 2 3 4 5 6] 9 12
[3 4 5] [2 3]
[9 4 5] [2 9]
[23 4 5] [2 9 4 5 6 7 8 9]
 */

// copy
package main

import "fmt"

func main()  {
	s1 := []int{1,2,3,4,5,6,7,8,9}
	s2 := []int{7,8,9}
	copy(s1,s2)    //将s2数组copy到s1,所以覆盖掉前面的元素，和后面的元素组合成新的数组
	fmt.Println("s2->s1:",s1)
	s3 := []int{0,0,0,11,22,33}
	copy(s3,s1)		//将s1数组copy到s3,剩余的元素都丢弃
	fmt.Println("s1->s3:",s3)

	copy(s3,s1[1:3])
	fmt.Println(s1)
	fmt.Println(s3)
}

//输出结果:
/*
s2->s1: [7 8 9 4 5 6 7 8 9]
s1->s3: [7 8 9 4 5 6]
[7 8 9 4 5 6 7 8 9]
[8 9 9 4 5 6]
*/

package main

import "fmt"

func main() {
	s1 := []int{1, 2, 3, 4, 5, 6}
	s2 := []int{7, 8, 9, 10, 1, 1, 1, 1, 1, 1}
	copy(s2, s1[1:3]) // 表示把s1中索引为1--2的元素2，3，复制到s2的起始位置
	fmt.Println(s2)
	copy(s2[2:4], s1[1:3]) //表示把s1中索引为1--2的元素2，3复制到s2中索引为2，3的元素9，10
	fmt.Println(s2)
}

//输出结果：
/*
[2 3 9 10 1 1 1 1 1 1]
[2 3 9 10 1 1 1 2 3 1]
*/　　

// 完全拷贝
package main

import "fmt"

func main() {
	s1 := []int{1, 2, 3, 4, 5}
	s2 := s1[0:5] //将s1完全拷贝到s2
	s3 := s1[:]   //省略起始位置和终止位置，默认也是将s1全部拷贝给s2
	fmt.Println(s2)
	fmt.Println(s3)
}

//输出结果：
/*
[1 2 3 4 5]
[1 2 3 4 5]
*/　　

//第一种形式
package main

import "fmt"

func main() {
	var m map[int]string 	  //map的声明：int是key的类型，string是value的类型
	m = map[int]string{}     //必须用var关键字声明后，此处才可创建map；必须与上一行联合使用
	fmt.Println(m)
}

//第二种形式
package main

import "fmt"

func main()  {
	var m map[int]string
	m = make(map[int]string) //必须用var关键字声明后，此处才可创建map；必须与上一行联合使用
	fmt.Println(m)
}

//第三种形式
package main

import "fmt"

func main()  {
	var m  map[int]string = make(map[int]string)  //仅一行创建map
	fmt.Println(m)

}

//第四种形式
package main

import "fmt"

func main()  {
	m := make(map[int]string)
	fmt.Println(m)
}

//简单map的操作
package main

import "fmt"

func main()  {
	m := make(map[int]string)   //创建map
	m[1] = "OK"	//把“OK”存入key为1的键值中
	//delete(m,1)	//把m中键值为1的值删掉，那么下面输出为空
	a := m[1]	//把键值赋值给a,如果没有value值，则输出为空
	fmt.Println(a)
}

//输出结果：OK

//复杂map的操作一
package main

import "fmt"

func main()  {
	var m  map[int]map[int]string
	m = make(map[int]map[int]string) //只对外层map进行了初始化，第二层map未被初始化
	m[1] = make(map[int]string)	 //对第二层map中key为1的键值进行初始化，否则无法输出结果
	//m[2] = make(map[int]string)	 //对第二层map中key为2的键值进行初始化，否则无法输出结果；必须对不同的键值都初始化，才可输出结果；否则报错
	m[1][1] = "OK"
	//m[2][1] = "OK"  //对键值为2的赋值
	a := m[1][1]
	//a := m[2][1]
	fmt.Println(a)
}

//复杂map的操作二
package main

import "fmt"

func main()  {
	var m  map[int]map[int]string
	m = make(map[int]map[int]string)
	a := m[2][1]    //返回空值，表示未被初始化；但此种方法不建议使用，也可能初始化为空值
	fmt.Println(a)
}

//复杂map的操作三
package main

import "fmt"

func main() {
	var m map[int]map[int]string
	m = make(map[int]map[int]string) //当有多个嵌套map时，每一级都要make初始化，否则会报错
	a, ok := m[2][1] //第一个返回值为value值，第二个返回值为bool值，表示是否初始化；true:初始化，键值对存在；false:未初始化，键值对不存在
	fmt.Println(a,ok)  //未初始化，ok输出：false
	if !ok {
		m[2] = make(map[int]string)
	}
	m[2][1] = "GOOD"
	a,ok = m[2][1]
	fmt.Println(a, ok) //初始化，ok输出true
}

//输出结果：
/*
 false
GOOD true
*/　　

//使用for range对map和slice进行迭代操作
package main

func main() {
	for i, v := range slice { // i返回slice的索引值，v返回slice的元素值

	}

	for k, v := range map{ // k返回map的键值，v返回map的value值

	}

}

//示例1:未初始化
package main

import "fmt"

func main()  {
	sm := make([]map[int]string,5)
	for _,v := range sm {
		v = make(map[int]string,1)
		v[1] = "OK"
		fmt.Println(v)
	}
	fmt.Println(sm)

}
//输出结果：
/*
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
[map[] map[] map[] map[] map[]]
*/

//示例2:初始化map
package main

import "fmt"

func main() {
	sm := make([]map[int]string, 5)
	for i := range sm {
		sm[i] = make(map[int]string, 1)
		sm[i][1] = "OK"
		fmt.Println(sm[i])
	}
	fmt.Println(sm)

}
/*
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
[map[1:OK] map[1:OK] map[1:OK] map[1:OK] map[1:OK]]
*/　　

//对无序的map进行排序
package main

import (
"fmt"
"sort"
)

func main() {
	m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}
	s := make([]int, len(m))
	i := 0
	for k,_ := range m {
		s[i] = k
		i++
	}
	sort.Ints(s)   //加上sort排序后，每次运行都是有序的，不加则每次运行都是无序输出
	fmt.Println(s)
}　　

// 函数function
package main

import "fmt"

func main() {

}

func A(a int, b string) int {        //定义函数A，两个参数int型的a,string型的b; 函数返回值为int型，单个返回值不需要括号

}

func B(a int, b string) (int, string, int) {      //同上，函数返回值为三个，用括号括起来

}

func C(a, b, c int) (a, b, c int) {		  //表示三个参数均为int型，返回值也均为int型
	a,b,c = 1,2,3   //此处不需要 := 为三个变量赋值，因为在命名返回值时三个变量已经定义
	return 			//因为函数C已经命名返回值a,b,c ;所以此处不需要跟返回值，默认为上面的a,b,c
}

func D() (int,int,int) {  	//如果函数没有返回值，下面return必须跟上三个返回值
	a,b,c := 1,2,3
	return a,b,c

}

//不定量变参 a ...int 的操作
package main

import "fmt"

func main()  {
	A("ok",2,3,4,5)
}

func A(b string,a ...int)  {   //此处的a ...int参数在接收一系列实参传递后变为一个slice；是一个不定长变参，后面不可以再加任何参数;但前面可以加参数
	fmt.Println(a,b)
}

//输出结果：
/*
[1 2 3 4 5] ok
*/　

//匿名函数
package main

import "fmt"

func main()  {
	a := func() {
		fmt.Println("无函数名的称为：匿名函数")
	}
	a()
}　　

//闭包函数
package main

import "fmt"

func main() {
	f := closure(10)
	fmt.Println(f(1))
	fmt.Println(f(2))

}

func closure(x int) func(int) int {   //地址相同，表示调用的同一个x,而不是值的拷贝
	fmt.Println(&x)
	return func(y int) int {
		fmt.Println(&x)
		return x + y
	}
}

//输出结果：
/*
0xc042050080
0xc042050080
11
0xc042050080
12
*/　　

//defer
/*
1.defer的执行方式类似其它语言中的析构函数，在函数体执行结束后按照调用顺序的相反顺序逐个执行
2.即使函数发生严重错误也会执行
3.支持匿名函数的调用
4.常用于资源清理、文件关闭、解锁以及记录时间等操作
5.通过与匿名函数配合可在return之后修改函数计算结果
6.如果函数体内某个变量作为defer时匿名函数的参数，则在定义defer时即已经获得了拷贝，否则则是引用某个变量的地址
7.Go 没有异常机制，但有 panic/recover 模式来处理错误
8.Panic可以在任何地方引发，但recover只有在defer调用的函数中有效
*/
package main

import "fmt"

func main()  {
	A()
	B()
	C()
}

func A()  {
	fmt.Println("A")
}

func B()  {

	defer func() {
		if err := recover();err != nil{		//recover只有在defer调用的函数中有效，此处用来回复panic语句中的错误机制
			fmt.Println("Recover in B")
		}
	}()

	panic("panic in B")		//Panic可以在任何地方引发错误机制,执行到此处，下面的代码不再执行
}

func C()  {
	fmt.Println("C")
}

//输出 结果：
/*
A
Recover in B
C
*/　　

//结构struct的基本操作
package main

import "fmt"

type person1 struct {		//定义一个结构体person1
	Name string
	Age  int
}

type person2 struct {		//定义一个结构体person2
	Name string
	Age  int
}

func main() {
	a := person1{
	}

	b := person2{
		Name: "zgf",   //在结构体里面初始化属性值,末尾加逗号；在go语言中常用此方法进行初始化
		Age: 23,
	}

	a.Name = "raymond" //调用结构，a相当于由类创建的对象;由对象调用结构中的属性并赋值
	a.Age = 35

	fmt.Println(a, b) //没调用结构中属性时，输出int型age的默认值{0},

	A(b)		//调用函数A输出的结果
	B(b)
	fmt.Println("b->",b)
}

func A(per person2)  {
	per.Age = 13
	fmt.Println("A->",per)
}

func B(per person2)  {
	per.Age = 15
	fmt.Println("A->",per)
}

//输出结果：
/*
{raymond 35} {zgf 23}
A-> {zgf 13}
A-> {zgf 15}
b-> {zgf 23}
*/