《Go程序设计语言》第一，二章笔记

第一章:
	·必须精确导入需要的包，否则出现编译错误
	·GO不需要在语句或声明的后面加分号，除非有多个语言出现在同一行，换行符会被转化为分号
	·在doc下使用go fmt + 文件 可以格式化源代码(就是有的你后面加上分号，go fmt会帮你去掉)
	·在go中，所有的索引都是半开区间，即是包含第一个索引，不包含最后一个索引。比如[m:n]表示第m个元素到第n-1个元素
	·os.Args可以获取在doc下的参数，os.Args的第一个元素是命令本身的名字，
		所以你想要获取你输入的参数是 slice[1，len(os.Args)](从第二个元素开始)
		如果是slice[m,n]中的m或n缺失，即slice[:n]或slice[m:] 这两个表示的范围分别是 slice[0:n]和slice[m:len(os.Args)]
	·var s,seq string ->变量可以在声明的时候进行初始化，
		如果变量没有明确的初始化，它将隐式得初始化为这个类型的空值，对于数字初始化为 0 ，字符串初始化为 ""
	·递增语句 i++ 是对i进行加 1，j = i++是不合法的。并且仅支持后缀 --i是不合法的
	·for 是 Go里面唯一的循环语句，它有几种表达形式
	
		形式1 : for init;condition; post {}
		for循环的三个组成部分两边不用小括号，大括号是必须的。init可省，循环开始之前执行，post也可以省略，就是形式2
		
		形式2 : for post {}
		类似传统的 while循环
		
		形式3 ；for {}
		这种是无限的循环，需要通过break或者是return来终止
		
		形式4 : 迭代循环 -->在字符串或者是slice数据上迭代，类型 foreach迭代
		for key : value := rang os.Args[1:] {
			fmt.Println(key + value)
		}
		如果不需要key可以不要
		for _ : value := rang os.Args[1:] {}
		
		迭代你从命令行输入的参数
	·string.Join(os.Args[1:]," ") --> 以空串分割输出的命令行参数
	·maps := make(map[string]int)
		内置的make函数可以用来新建map，该map的键是string类型，值是int类型
		使用for迭代可以对map进行遍历，例如
		for key : value := range maps {}
		
	·使用bufio包 ，可以高效地处理输入和输出
		input := bufio.NewScanner(os.Stdin)
		每一次调用 input.Scan()读取下一行，函数返回的类型是 bool
		调用input.Text()可以获取输入的结果
		
	·fmt.Printf() 格式化格式化输出
		%d : 十进制
		%x,%o,%b : 十六，八，二进制
		%f,%g,%e : 浮点数
		%t : 布尔型
		%c : 字符型
		%s : 字符串
		%v ：内置格式的任何值
	
	·maps := make(map[string]int)
		当maps作为实参传递给别人的时候，形参的改变会改变实参的值，传递的是引用
		
	·goroutine是一个并发执行的函数 --> go + 函数名。 
	·通道是一种可以在一个协程向另一个协程传递指定类型值的通信机制  --> ch := make(chan string)
	·if 语句在使用前可以进行初始化一次（这样会很方便，比如一个局部变量的声明）
		if init; condition {}
		eg: if err := r.read(); err != nil {}
	
	·对于switch只会执行其中的一条，从上到下优先，没有适合的执行default
	·使用&操作符可以获取一个变量的地址，使用*操作符可以获取指针引用的变量的值，但是指针不支持算术运算
	
	
第二章
	·三十多个内置的预声明的常量，类型和函数
		常量: true,false,iota,nil
		类型：int,int8,int16,int32,int64
			  uint,uint8,uint16,uint32,uint64,uintptr
			  float32,float64,complex128,complex64
			  bool,byte,rune,string,error
		函数：make,len,cap,new,append,copy,close,delete
			  complex,real,image
			  panic,recocer
			  
	·函数的第一个字母是大写的话就是public，小写的话就是private
	·包级别的声明对同一个包内的所有源文件都是可见的
	
	·变量声明: 
		var name type = 表达式
		type和表达式，其中一个可以省略，但是不能两个都省略
		->如果是类型省略，那么变量的类型由表达式确定
		->如果表达式省略，其初始值对应于类型的零值--数字的零值是0，bool的零值是false，
		  字符串的零值是 ""，接口和引用类型的零值是nil，想数组或者是结构体的零值是所有成员的零值
		  
	·灵活的声明方式:
		->var i,j,k int
		->var b,f,s = true,2.3,"haha"
		var f,err = os.Open(filename)

	·短变量声明 : 用来声明或初始化局部变量
		name := expression  (优点:短小灵活，主要用在局部变量)
		i := 12 或
		i,j := 12,true  //也可以是不同类型的，go语言会自动进行类型的推导
		:= 表示声明，=表示赋值
		注意: 对于以声明过的变量，再次使用短变量声明，那么这就是赋值，例如
				var i int  = 123
				i,j := 12,12 //将12的值赋给i，并不会新建一个i变量，因为上面已经有了
				fmt.Println(i,j)
			但是i和j不能都已经被声明，即不能像一下这样：
				var i,j int  = 123，123
				i,j := 12,12 //这时候应该使用 = ，而不是 :=
				fmt.Println(i,j)
			
	·new函数 ： new(T) 创建一个类型为T的变量，初始化为T类型的零值，返回其地址（注意不是变量）
		p := new(int) //初始化值为零值，返回该值的指针
		fmt.Println(*p) //*+指针，获取该指针指向的内容
		*p = 2
		fmt.Println(*p)
		使用new创建的变量和普通变量并没有什么不同，只是不需要引入（声明）一个虚拟的名字
	
	·变量的声明周期
		包级别的生命周期是整个程序的执行时间
		局部变量有一个动态的生命周期，每次执行声明语句创建一个新的实体，变量一直生存到它变得不可访问，这时会被回收
		
	·函数有两个返回值，你接收函数的返回值时也必须接收两个，不需要的返回值可以给予空标识符 _
	·类型也有访问权限，第一个字母大写对其他包可见
	
	·将一个String方法绑定到一个类型上，就比如java里面的toString方法，打印输出的时候会按照String()里面的格式输出
	
	·如果有两个包名相同，但是路径不同的，那么就要对其中一个包使用别名
	
	·包的初始化
		从包级别的变量开始，按照声明的顺序初始化
		如果一个包有多个go文件，初始化按照编译器收到的文件的顺序初始化
		对于包级别的每一个变量，生命周期从其值被初始化开始
		
		·init函数，在包初始化的时候被执行。
			这个不能被调用
			
	·注意函数内和包级别的变量同名，函数的变量会屏蔽包级别的变量，eg:
		var cwd int
		func main()  {
			fmt.Println(cwd)  //打印出来的依旧是 0
		}
		func init()  {
			cwd,i := 123,123   //这时候包级别的cwd被屏蔽了，并没有完成赋值
			fmt.Println(cwd,i)
		}	
		
		解决方法 -->将 := 改为 =
		func init() {
			var i int
			cwd,i = 123,123
		}