GO语言学习笔记(一)

浏览数：25 / 时间：2015年06月10日

每个Go源码文件开头都是package声明，表示Go代码所属的包
要生成Go的可执行程序，需要定义一个main的包，同时创建main目录

外部参数传入用os模块的os.Args方法获取，os.Args接收的参数下标从1开始

package main

import (
	"fmt"
	"os"
)

func main(){
	fmt.Println("Hello Test")
	fmt.Println(os.Args[1])
}

在函数返回时没有被明确赋值的返回值会被设置成默认值，例如float类型返回值会被设置成0.0，error类型返回值会被设置成为nil
6g和6l是64为版本的Go编译器和链接器，32为版本的编译器和连接器是8g和8l，gcc版本的编译器是gccgo
```
6g helloworld.go
6l helloworld.6
./6.out
输出：Hello Test
      Test os.Args
```
xxx_test.go是Go语言中单元测试的命名规则，设置好GOPATH，GOROOT环境变量后运行cmd
```
GOROOT：D:\go
GOPATH: D:\WorkSpace01\GoPractise
go test simplemath
```
const用于定义常量，iota是一个比较特殊的关键字，在下一次常量出现时自动加1，下次以常量出现则重置为0

常量枚举类型定义，小写字母为包内可见

const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
	numberOfDays
)

Go语言中的类型

布尔类型：bool
整型：int8 byte(uint8) int16 int uint uintptr
浮点类型：float32 float64
复数类型： complex64 complex128
字符串：string
字符类型：rune  fmt.Println([]rune("Hello")) 输出为转换成unicode的字符数组
错误类型：error
指针
数组
切片
字典
通道
结构体
接口

int和int32之间不会做自动类型转换，被Go语言定义为两种类型，会发生异常，除非用强制类型转换解决问题

不能用==来判断浮点数之间是否相等，这样会影响结果稳定性，建议下面方法

import "math" 
 
// p为用户自定义的比较精度，比如0.00001 
func IsEqual(f1, f2, p float64) bool { 
 return math.Fdim(f1, f2) < p 
}

Go语言目前只支持utf8和unicode两种编码格式

map用法示例

package main

import (
	"fmt"
)

type PersonInfo struct {
	Name string
	Age int
	Sex bool
}

func mapDecalre() {
	var personDB map[string] PersonInfo
	personDB = make(map[string] PersonInfo)
	personDB["1"] = PersonInfo{"Lucy",20,true}
	personDB["2"] = PersonInfo{"Lily",21,true}
	personDB["3"] = PersonInfo{"Lilei",22,false}
	person,ok := personDB["1"]
	if ok {
		fmt.Println(person.Name == "Lucy")
		fmt.Println("OK")
	} else {
		fmt.Println("Fail")
	}
}

func main() {
	mapDecalre()
}

条件语句的语句体必须用花括号括起来，同时不允许将最终的return语句放到条件判断中否则编译报错
```
func example(x int) int { 
 if x == 0 { 
 return 5 
 } else { 
 return x 
 } 
} 
编译报错
```

switch...case语句中switch后的条件语句可以不是必须的

switch { 
 case 0 <= Num && Num <= 3: 
 fmt.Printf("0-3") 
 case 4 <= Num && Num <= 6: 
 fmt.Printf("4-6") 
 case 7 <= Num && Num <= 9: 
 fmt.Printf("7-9") 
}

在switch...case中使用fallthrough来执行紧跟的case语句

switch i { 
 case 0: 
 fmt.Printf("0") 
 case 1: 
 fmt.Printf("1") 
 case 2: 
 fallthrough 
 case 3: 
 fmt.Printf("3") 
 case 4, 5, 6: 
 fmt.Printf("4, 5, 6") 
 default: 
 fmt.Printf("Default") 
} 
运行上面的案例，将会得到如下结果： 
 i = 0时，输出0； 
 i = 1时，输出1； 
 i = 2时，输出3；  
 i = 3时，输出3； 
 i = 4时，输出4, 5, 6； 
 i = 5时，输出4, 5, 6； 
 i = 6时，输出4, 5, 6； 
 i = 其他任意值时，输出Default。

switch同时支持类型判断

func MyPrintf(args ...interface{}) {
	for _, arg := range args {
		switch arg.(type) {
		case int:
			fmt.Println(arg, "is an int value.")
		case string:
			fmt.Println(arg, "is a string value.")
		case int64:
			fmt.Println(arg, "is an int64 value.")
		default:
			fmt.Println(arg, "is an unknown type.")
		}
	}
}

goto和break语句

func gotoFunc() {
	i := 0
	HERE:
	 fmt.Println("HERE")
	 i ++
	 if i < 10 {
	 	goto HERE
	 }
}

func breakFunc() {
	JLoop:
		for j := 0; j < 5; j ++ {
			for i := 0; i < 10; i ++ {
				if i > 5 {
					break JLoop
				}
				fmt.Println(i)
			}
		}
}
执行结果
HERE
HERE
HERE
HERE
HERE
HERE
HERE
HERE
HERE
HERE
0
1
2
3
4
5

小写字母开头的函数只在本包内可见，大写字母开头的函数才能被其他包使用。这个规则也适用于类型和变量的可见性。

不定参数传递

func myfunc(args ...int) { 
 
 // 按原样传递 
 myfunc3(args...) 
 
 // 传递片段，实际上任意的int slice都可以传进去 
 myfunc3(args[1:]...) 
}

任意类型参数传递可以使用interface{}

func Printf(format string, args ...interface{}) { 
 // ... 
}

匿名函数调用
```
	func(i int) {
		fmt.Println(i)
	}(1)	
```

匿名函数调用

var j int = 5
	a := func()(func()) {
		var i int = 10
		fmt.Println(i)
		return func() {
			fmt.Println(j)
		}
	}()  //看看去掉括号会如何
 	a()

不去括号输出 10 5
去掉括号输出10
去掉括号这种情况是因为只拿到返回值并没有执行返回值中的内容

一个函数中可以存在多个defer语句，因此需要注意的是，defer语句的调用是遵照先进后出的原则，即最后一个defer语句将最先被执行

flag包是Go标准库用来提供快速解析命令行参数的一个包

package main

import (
	"flag"
	"fmt"
)

var infile *string = flag.String("i","infile","File contains values for sorting")
var outfile *string = flag.String("o","outfile","File to receive sorted values")
var algorithm *string = flag.String("a","qsort","Sort algorithm")

func main() {
	flag.Parse()
	if infile != nil {
		fmt.Println("infile =", *infile, "outfile =", *outfile, "algorithm =", *algorithm)
	}
}

命令行参数：-i unsorted.dat -o sorted.dat -a bubblesort
运行结果：infile = unsorted.dat outfile = sorted.dat algorithm = bubblesort
如果去掉：flag.Parse()
运行结果：infile = infile outfile = outfile algorithm = qsort