GO语言学习笔记(一)

每个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

fmt.Println(``)用于多行输出