GoDoc-1.基础

1. 包

go是由包来组织的。
程序从main包的main函数开始。
使用引入的包时，以最后一个包名开始：

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    fmt.Println("My favorite number is", rand.Intn(10))//Println以fmt开始，Intn以rand开始
}

2. 包可见性

在go中一个方法或变量的开头字母大写，则这个方法或变量是可以被其他包引入的。否则不可以。

3. 函数

func swap(x, y string) (string, string) {//go可以返回多个值，参数可以写成x,y string形式
    return y, x
}
func split(sum int) (x, y int) { // 命名返回值
    x = sum * 4 / 9
    y = sum - x
    return
}

命名返回值即相当于x和y在函数开始定义，然后直接return返回。--这种用法容易造成歧义，不建议使用

4. 基本类型

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
    // 表示一个 Unicode 码点

float32 float64 //浮点型

complex64 complex128 // 复数

int/uint/uintptr在32为系统占32位，在64位系统占64位。--Java的类型和系统无关，所以说Java是系统无关性的语言，而go不是。

当变量没有赋值时，则系统默认赋0值。数字型零值是0，布尔值零值是false，字符串零值是""

5. 类型转换

go里不允许隐式转换，必须显示转换
类型转换的语法--和Java不同

var a int = 123
float64 b = float64(a)

6. for

go里面唯一的循环就是for，go里没有while

for i := 0; i < 10; i++ { // 注意没有小括号，使用分号分隔
        sum += i
}

sum := 1
for sum < 1000 { // 当第一和第三个子句没有时，可以省略两个分号
    sum += sum
}

7. if

if x < 0 { // 也是没有小括号，大括号是必须的
    return sqrt(-x) + "i"
}

if v := math.Pow(x, n); v < lim { // 可以在判断语句之前有一个小的语句，但注意此时的v的作用域只在if语句块内（包括下面的else）
    return v
} else {
   return v
}

8. switch

var linux = "linux"
switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("OS X.")
case linux:
    fmt.Println("Linux.")
default:
    // freebsd, openbsd,
    // plan9, windows...
    fmt.Printf("%s.", os)
}

使用方式和Java几乎一样，但有两点不同：

每个case后系统自动加了break
case中的东西可以不是常量且不一定是整数。

switch i {
case 0:
case f():
}

如果i的值为0，则f就不会执行

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("Good morning!")
case t.Hour() < 17:
    fmt.Println("Good afternoon.")
default:
    fmt.Println("Good evening.")
}

switch可以没有条件，达到更好看的if-else if-else效果

9. defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

func main() {
    fmt.Println("counting")

    for i := 0; i < 3; i++ {
        defer fmt.Println(i)
    }

    fmt.Println("done")
}

输出

counting done 2 1 0

10. 指针

var p *int
a := 123
p = &a
*p = 234

用法和C++中的几乎一样

11. 结构体

就是字段的集合

type Vertex struct {
    X int
    Y int
}

func main() {
    v := Vertex{1, 2}
    v.X = 4 // 使用.来访问
    p := &v
    p.X = 1e9 // 正常是(*p).X，但也可以直接使用指针p.X的方式。
    fmt.Println(v.X)
}

初始化一个结构体的方式：

type Vertex struct {
    X, Y int
}

var (
    v1 = Vertex{1, 2}  // has type Vertex
    v2 = Vertex{X: 1}  // Y:0 is implicit -- 这个还是比较新颖的
    v3 = Vertex{}      // X:0 and Y:0
    p  = &Vertex{1, 2} // has type *Vertex
)

12. 数组

var a [10]int
p := [10]int{1,2,3,4,5,6,7,8,9,10} // 数组的初始化

13. 切片

其实就是数组的一个引用。

var a []int //定义一个切片 此时 a == nil
primes := [6]int{2, 3, 5, 7, 11, 13}

var s []int = primes[1:4] //从下标1开始到下标4，包括1不包含4，总共4-1=3个元素
s[1] = 100 // 此时会修改primes数组的元素
println(primes)

切片并不存储任何数据，它只是描述了底层数组中的一段。
更改切片的元素会修改其底层数组中对应的元素。

q := []int{2, 3, 5, 7, 11, 13} //初始化一个切片

上述代码的含义就是创建一个长度6的数组，然后用一个切片p来指向它。

var a [10]int
以下切片是等价的：

a[0:10]
a[:10]
a[0:]
a[:]

即可以省略start和end，默认start=0，end=数组长度（最大下标+1）

切片的长度和容量

var a [10]int
var p []int = a[3:5]
len(p) // 长度 5-3=2
cap(p) //容量 3~10  10-3=7

长度就是切片包含的元素个数
容量就是切片对应的数组开始下标到数组结尾的元素个数

使用make来创建切片

a := make([]int, 5)  // len(a)=5 此时创建一个长度为5的数组，数组的每个元素为零值，然后返回这个数组的引用(切片)
b := make([]int, 0, 5) // len(b)=0, cap(b)=5 还可以指定长度和容量

切片可以是多维的

board := [][]string{
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
    }

向切片追加元素，使用内置append函数

func append(s []T, vs ...T) []T // 内置append函数
s = append(s, 2, 3, 4) //注意如果底层数组足够存放，则此函数会修改底层数组的值

当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

总结：创建一个切片的三种方法

var a []int = make([]int, 10) //创建即零值
var b []int = []int{1,2} //创建且赋初值
var c []int = p[1:3] //创建一个指向某个数组的引用

14. range

range和for在一起使用，可以遍历切片或映射的每个元素。

for i, v := range pow { //会返回下标和值
    fmt.Printf("2**%d = %d\n", i, v)
}
for _, v := range pow { // 只关心value
    fmt.Printf(" %d\n", v)
}
for i := range pow { //只关心下标
    fmt.Printf("%d\n", i)
}

15. 映射

就是Java中的Map

var m map[string]string // 此时 m == nil
创建map的两种方法：
m = make(map[string]string) //使用make
m["abc"] = "123"

var m = map[string]string{ //创建并初始化
    "abc" : "123",
    "def" : "456"
}

增加和修改元素都很简单，这里说一下删除和判无

delete(m, key) // 删除m映射中key的元素

elem = m[key] // 如果不存在则返回零值
elem, ok := m[key] //存在ok等于true，否则ok等于false

16. 函数参数值

函数本身其实和变量是一样的，可以当做参数

hypot := func(x, y float64) float64 { //可以把函数使用一个变量表示
        return math.Sqrt(x*x + y*y)
}
func compute(fn func(float64, float64) float64) float64 { //参数可以是一个函数
    return fn(3, 4)
}

甚至可以将函数当做另一个函数的返回值

func adder() func(int) int {
    return func(x int) int {
        return x + 1
    }
}
a := adder()
println(a(2))

17. 函数闭包

先看一下计算机科学上闭包的含义：

是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 3; i++ {
        fmt.Println(
            pos(i),
            neg(-2*i),
        )
    }
}

0 0
1 -2
3 -6
就是说sum这个变量随着函数返回一起存在，pos和neg分别对应两个函数以及函数一起存在的sum。
所以每次调用pos/neg都会使用之前的sum值。
其实这点有点类似于C++中的static变量--具有记忆性