网址：https://tour.go-zh.org/welcome/1

如果是为了将代码编译成一个可执行程序，那么package必须是main

fmt 是go的一个系统库

fmt.println()则可以打印输出

定义变量和赋值可以一步完成通过: 变量名 := 值

var 变量名 变量类型；变量名 = 值。这里需要注意：go语言中定义的变量必须被用到，否则会报错

go的结构开发规范：

// 当前程序的包名
package main
//导入其他的包
import "fmt"
//常量的定义
const PI=3.14
//全局变量的声明和赋值
var name = "gopher"
//一般类型声明
type newType int
//结构的声明
type gopher struct{}
//接口的声明
type golang interface{}
//由main函数作为程序入口点启动
func main(){
  fmt.Println("Hello world! 你好世界")
}

defer 语句会将函数推迟到外层函数返回之后执行。推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

package main

import "fmt"

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

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

  fmt.Println("done")
}

打印：counting done 9 8 7 6 5 4 3 2 1 0

go指针

Go 拥有指针。指针保存了值的内存地址。类型 *T 是指向 T 类型值的指针。其零值为 nil。

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21     // 通过指针 p 设置 i

package main
import "fmt"
func main() {
i, j := 42, 2701
p := &i     // 指向 i
fmt.Println(*p) // 通过指针读取 i 的值
*p = 21     // 通过指针设置 i 的值
fmt.Println(i) // 查看 i 的值
p = &j     // 指向 j
*p = *p / 37  // 通过指针对 j 进行除法运算
fmt.Println(j) // 查看 j 的值
}
//42 31 73

package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
v := Vertex{1, 2}
v.X = 4
fmt.Println(v.X)
fmt.Println(v.Y)
}
//4 2 

结构体字段可以通过结构体指针来访问。如果我们有一个指向结构体的指针 p，那么可以通过 (*p).X 来访问其字段 X。直接写 p.X 就可以。

特殊的前缀 & 返回一个指向结构体的指针。

package main
import "fmt"
type Vertex struct {
X, Y int
}
var (
v1 = Vertex{1, 2} // 创建一个 Vertex 类型的结构体
v2 = Vertex{X: 1} // Y:0 被隐式地赋予
v3 = Vertex{}   // X:0 Y:0
p = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)
func main() {
fmt.Println(v1, p, v2, v3)
}
//{1 2} &{1 2} {1 0} {0 0}

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

package main
import "fmt"
func main() {
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1])
fmt.Println(a)
primes := [6]int{2, 3, 5, 7, 11, 13}
fmt.Println(primes)
}
//Hello World
//[Hello World]
//[2 3 5 7 11 13]

类型 []T 表示一个元素类型为 T 的切片。切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔：

a[low : high] 它会选择一个半开区间，包括第一个元素，但排除最后一个元素。

更改切片的元素会修改其底层数组中对应的元素。与它共享底层数组的切片都会观测到这些修改。切片的零值是 nil。

package main
import "fmt"
func main() {
names := [4]string{
"John",
"Paul",
"George",
"Ringo",
}
fmt.Println(names)
a := names[0:2]
b := names[1:3]
fmt.Println(a, b)
b[0] = "XXX"
fmt.Println(a, b)
fmt.Println(names)
}
//[John Paul George Ringo]
//[John Paul] [Paul George]
//[John XXX] [XXX George]
//[John XXX George Ringo]

切片下界的默认值为 0，上界则是该切片的长度。

切片的长度就是它所包含的元素个数。切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获龋

package main
import "fmt"
func main() {
s := []int{2, 3, 5, 7, 11, 13}
printSlice(s)
// 截取切片使其长度为 0
s = s[:0]
printSlice(s)
// 拓展其长度
s = s[:4]
printSlice(s)
// 舍弃前3个值
s = s[3:]
printSlice(s)
}
func printSlice(s []int) {
fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}
//len=6 cap=6 [2 3 5 7 11 13]
//len=0 cap=6 []
//len=4 cap=6 [2 3 5 7]
//len=1 cap=3 [7]

%d 十进制表示

%v 相应值的默认格式

切片可以用内建函数 make 来创建，这也是创建动态数组的方式。a := make([]int, 5) // len(a)=5

要指定它的容量，需向 make 传入第三个参数： b := make([]int, 0, 5) // len(b)=0, cap(b)=5

//注意这里的参数
package main
import "fmt"
func main() {
a := make([]int, 5)
printSlice("a", a)
b := make([]int, 0, 5)
printSlice("b", b)
c := b[:2]
printSlice("c", c)
d := c[2:5]
printSlice("d", d)
}
func printSlice(s string, x []int) {
fmt.Printf("%s len=%d cap=%d %v\n",
s, len(x), cap(x), x)
}
//a len=5 cap=5 [0 0 0 0 0]
//b len=0 cap=5 []
//c len=2 cap=5 [0 0]
//d len=3 cap=3 [0 0 0]

Println 与 Printf 的区别：

fmt 包实现了格式化 I/O 函数，类似于 C 的 printf 和 scanf。Println 与Printf 都是fmt 包中的公共方法，在需要打印信息时需要用到这二个函数。

Println :可以打印出字符串，和变量。Printf 在使用时需要给它指定一个格式化规则，即第一个参数。注意参数输出数量和占位符数量要一致。
Printf : 只可以打印出格式化的字符串,可以输出字符串类型的变量，不可以输出整形变量和整形。

也就是说，当需要格式化输出信息时一般选择 Printf，其他时候用 Println 就可以了，比如：

a := 10
fmt.Println(a)//right
fmt.Println("abc")//right
fmt.Printf("%d",a)//right
fmt.Printf(a)//error

向切片追加元素：Go 提供了内建的 append 函数。append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。append 的结果是一个包含原切片所有元素加上新添加元素的切片。

package main
import "fmt"
func main() {
var s []int
printSlice(s)
// 添加一个空切片
s = append(s, 0)
printSlice(s)
// 这个切片会按需增长
s = append(s, 1)
printSlice(s)
// 可以一次性添加多个元素
s = append(s, 2, 3, 4)
printSlice(s)
}
func printSlice(s []int) {
fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}
//len=0 cap=0 []
//len=1 cap=2 [0]
//len=2 cap=2 [0 1]
//len=5 cap=8 [0 1 2 3 4]

指针接收者的方法可以修改接收者指向的值。

package main
import (
"fmt"
"math"
)
type Vertex struct {
X, Y float64
}
func (v Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func (v *Vertex) Scale(f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
func main() {
v := Vertex{3, 4}
v.Scale(10)
fmt.Println(v.Abs())
}
//50
//移除第 16 行 Scale 函数声明中的 *，输出5

带指针参数的函数必须接受一个指针，而以指针为接收者的方法被调用时，接收者既能为值又能为指针。

for 循环的 range 形式可遍历切片或映射。当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。可以将下标或值赋予 _ 来忽略它。

package main
import "fmt"
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
for i, v := range pow {
fmt.Printf("2**%d = %d\n", i, v)
}
}
//2**0 = 1
//2**1 = 2
//2**2 = 4
//2**3 = 8
//2**4 = 16

映射将键映射到值

映射的创建方式：

func main() {
  map1 := make(map[string]string) // map1: map[]
  map2 := make(map[string]string,5) // map2: map[]
  map3 := map[string]string{"num1":"num1","num2":"num2"} // map3: map[num1:num1 num2:num2]
  map4 := map[string]string{} // map4: map[]
}

package main
import "fmt"
type Vertex struct {
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
func main() {
fmt.Println(m)
}
//map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]