Go编程语言指南学习笔记

如果是为了将代码编译成一个可执行程序，那么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]