package main //定义一个包名位main，main是可执行程序的包名，所有Go源文件必须有一个包声明语句，通过包名管理命名空间

//第一个简单的HelloGo程序hello.go
import (
	"fmt"	//import 引入一个外部包 fmt，
)


func main2(){ //func 关键字声明定义一个函数，函数名为main，main代表程序的入口函数
	fmt.Println("da") //调用fmt包里的Println函数打印一句话

	// 注意
	//main函数所在的包名必须是main
	//标识符区分大小写


	//标识符和关键字
	//标识符用来定义变量、类型、常量等语法对象的符号名称，不能使用语言预留的标识符，会导致歧义
	//关键字：语言保留的特定语法含义的标识符
	//Go是强类型静态编译型语言，可以自动推到类型，但定义新的类型时必须指定类型标识符
	//空白标识符：_用来声明一个匿名的变量，在赋值表达式的左端，空白标识符也通常被用作占位，比如忽略多个返回值中的一个


	//常量：
	const a int =1 //显式定义
	const b = 1   //隐式定义
	const c, d, e = 1, false, "str" //多重赋值

	//变量：
	var s string = "hehe"
	fmt.Println(s)
	name := "hehe" //简化的声明方式，不需显示声明变量类型也省去了var，变量的类型由go根据值推导出来
	fmt.Println(name)
	//操作符
	//赋值： =,:=
	//数值运算： +（相加）,-（相减）,*（相乘）,/（相除）,%（求余）,++（自增）,--（自减）
	//比较运算： >,<,==,>=,<=,!=
	//逻辑运算： &&,||,!
	//位运行： >>,<<,^,&（与）,|（或）,^x(取反)
	//其他： &（变量存储地址）,*(指针变量)
	//i, j := true, "hello" //无需指定类型即可赋值
	_ = 5 //_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
	//fmt.Println(j)



	// 大小写标记访问权限：在go中不能随便使用大小写的问题，是因为大小写具有特殊意义，在go中，大写字母开头的变量或者函数等是public的，可以被其他包访问；
	// 小写的则是private的，不能被其他包访问到。这样就省去了public和private声明的烦恼，使代码变的更简洁。

	/**
	关键字
	package	代码所属包
	import	导入依赖包,不能导入不使用的包
	main	主函数入口,无参数无返回值,命令行参数保存在os.Args中
	func	函数声明
	go	开启协程(并发核心)
	map	字典类型, map[string]bool
	delete	专用来删除字典中的元素
	chan	通道,协程通信核心
	select	同时读取多个chan的信息
	close	用来关闭通道
	make	用来创建chan或map
	type	类型定义,定义任意需要的类型
	struct	C中的结构体,但可以定义方法以实现类功能
	interface	接口类型,用来定义接口
	new	新建对象, 并获得它的指针
	range	类似python的range,配合for遍历列表、数组或map的元素
	defer	自动关闭资源，退出代码体(一般是函数)时执行
	error	error接口,只要实现Error()string方法就是一个error接口
	panic	抛出异常,如果不用recover捕获则会终止程序
	recover	捕获panic异常,防止程序终止，与recover结合
	 */

	/**
	流程控制：
	条件语句	说明
	if	if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
	if…else	if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
	if 嵌套	你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
	switch	switch 语句用于基于不同条件执行不同动作。
	select	select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。
	 */

	// 相比于其他语言，Go语言的条件判断语句不需要小括号。
	if i :=2;i>0{
		fmt.Print("i=",i)
	}


	//switch,case
	//Go语言的 switch 不需要 break 来跳出一个 case。
	/**
	switch i {
	case 0:
	// ...
	case 1:
	// ...
	default:
	// ...
	}

	 */


	/**
	select
	可以看做是专用于通信的switch语句，每一个case必须是一个通信操作，要么是发送要么是接收。
	select执行逻辑：随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。

	select {
	case communication clause  :
	   statement(s);
	case communication clause  :
	   statement(s);
	//你可以定义任意数量的 case
	default : // 可选
		statement(s);
	//1.如果有 default 子句，则执行该语句。
	//2.如果没有 default 字句，select 将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。
	//每个 case 都必须是一个通信
	//如果有多个 case 都可以运行，select 会随机公平地选出一个执行。其他不会执行。
	*/

	// Go语言中的for循环与Java、C#等的区别就是三个由 ;（分号）分开的组成部分不需要小括号括起来：
	sum :=0
	for i := 0; i < 10; i++ {
		sum += i
	}
	fmt.Println(sum)
	//Go语言中没有其他语言中while的用法，for 在Go语言中可以当做 while 来用：
	dd :=1
	//循环条件
	for dd < 10 {
		dd += dd
	}


	/**
	break	经常用于中断当前 for 循环或跳出 switch 语句
	continue	跳过当前循环的剩余语句，然后继续进行下一轮循环。
	goto	将控制转移到被标记的语句。
	 */
	// label 就是用来标志的文本，statement 是一个普通的Go语句，goto label执行之后，程序将调到 statement 然后顺序往下执行。
	/**
	goto label
	..
	.
	label: statement
	 */



	//函数
	/**
	func 方法名称([传入参数表]) [返回结果数据类型]{
	    //函数体
	}
	//上面使用[]符号括起来的部分表示 非必须 的，可根据使用情况决定是否可以不写，
	例如无需传入参数时，传入参数列表可以省略。
	注意：传入的参数列表中形式参数定义的格式也是：变量名在前，变量类型在后。
	 */
	//调用函数
	xx,yy := swap("a","b")
	fmt.Println(xx)
	fmt.Println(yy)


	//函数作为值
	/* 声明函数变量 */
	getSquare := func(x float64) float64 {
		return x*x
	}
	/* 使用函数 */
	fmt.Println(getSquare(3))


	//闭包
	//闭包，是匿名函数（一个“内联”语句或表达式）的一种声明方式，好处就是可以直接使用函数内的变量不必声明：
	//没调用一次getSequence，i就自增1
	//函数的返回结果是另一个函数。
	//getSequence()


	//方法
	//与函数略有不同，方法声明时会指定其所附的是命名类型或结构类型的一个值或者是一个指针，所有给定类型的方法属于该类型的方法集。
	var cir Circle
	cir.radius = 1
	fmt.Println("Area of cir = ", cir.getArea())


	//指针
	//一个 指针变量 可以指向任何一个值的内存地址，使用指针前需要声明，声明格式如下：
	//var var_name *var-type  //var_name 是变量名，var-type 是指针类型，例如：
	var aa int = 1
	//创建指针变量
	var ptr *int // 此指针只能指向整型
	//指针赋值(指向变量a的地址)
	ptr = &aa
	/* 指针变量的存储地址 */
	fmt.Printf("ptr 变量储存的指针地址: %x\n", ptr )
	/* 使用指针访问值 */
	fmt.Printf("*ptr 变量的值: %d\n", *ptr )

	// 取址符：
	//Go语言中，使用 & 作 取址符，假如放在变量前可以返回相应变量的内存地址：
	var aaa int = 1
	fmt.Printf("变量的地址: %x\n", &aaa  )


	//空指针：
	//Go语言中的空指针是 nil ，表示没有分配到任何变量，判断指针是否为空指针：
	//声明指针，不赋值
	var ptr1 *int
	if ptr1 == nil{
		//条件执行块
		fmt.Println( "空指针")
	}


	//结构体
	//以关键字 type 和 struct 来一起声明一个结构体，格式如下：
	//定义
	type Info struct{
		id int
		name string
	}
	//声明
	var mInfo Info
	//赋值
	mInfo.id = 1
	mInfo.name = "linsh"
	fmt.Println(mInfo.name)


	//使用首字母大写的名称定义的属性或者方法可以被导入了此包的脚本调用
	/**
	package Test
	func SetName(_name string){

	}
	func setName(_name string){

	}
	 */
	//在 main 中先 import Test，然后只能调用 SetName 函数而不能调用 setname。




}
//定义函数
func swap(x, y string) (string, string) {
	return y, x
}

func getSequence() func() int {
	i:=0
	return func() int {
		i+=1
		return i
	}
}
//定义结构体
type Circle struct {
	radius float64
}
//此属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
	//c.radius 即为 Circle 类型对象中的属性
	return 3.14 * c.radius * c.radius
}