Go 学习总结

Go语言基本语法注意点

匿名变量

_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃：

	_, i, _, j := 1, 2, 3, 4

	func test() (int, string) {
	    return 250, "sb"
	}

	_, str := test()

iota枚举

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

    const (
        x = iota // x == 0
        y = iota // y == 1
        z = iota // z == 2
        w  // 这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota"
    )

    const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0

    const (
        h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同
    )

    const (
        a       = iota //a=0
        b       = "B"
        c       = iota             //c=2
        d, e, f = iota, iota, iota //d=3,e=3,f=3
        g       = iota             //g = 4
    )
    
    const (
        x1 = iota * 10 // x1 == 0
        y1 = iota * 10 // y1 == 10
        z1 = iota * 10 // z1 == 20
    )

fmt包的格式化输出输入

	格式	含义
	%%	一个%字面量
	%b	一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数
	%c	字符型。可以把输入的数字按照ASCII码相应转换为对应的字符
	%d	一个十进制数值(基数为10)
	%e	以科学记数法e表示的浮点数或者复数值
	%E	以科学记数法E表示的浮点数或者复数值
	%f	以标准记数法表示的浮点数或者复数值
	%g	以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出
	%G	以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出
	%o	一个以八进制表示的数字(基数为8)
	%p	以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示
	%q	使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字
	%s	字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符）
	%t	以true或者false输出的布尔值
	%T	使用Go语法输出的值的类型
	%U	一个用Unicode表示法表示的整型码点，默认值为4个数字字符
	%v	使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话
	%x	以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示
	%X	以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示

类型转换

Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。

流程控制的特殊点

if … else if … else：
其中a的作用域在后面的大括号代表的块里。

    if a := 3; a > 3 {
        fmt.Println("a>3")
    } else if a < 3 {
        fmt.Println("a<3")
    } else if a == 3 {
        fmt.Println("a==3")
    } else {
        fmt.Println("error")
    }

switch语句：
Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码：
switch s3 := 90; { //只有初始化语句，没有条件
case s3 >= 90: //这里写判断语句
fmt.Println(“优秀”)
case s3 >= 80:
fmt.Println(“良好”)
default:
fmt.Println(“一般”)
}

for（只有一种循环结构）：

死循环：

    for {
        //循环体
    }

迭代：
关键字 range 会返回两个值，第一个返回值是元素的数组下标，第二个返回值是元素的值。

    for i, c := range s {
        fmt.Printf("%d, %c\n", i, c)
    }

函数的特殊点

函数声明：
//求2个数的最小值和最大值
func MinAndMax(num1 int, num2 int) (min int, max int) {
// 第一个（）内是参数，第二个（）是返回值
if num1 > num2 { //如果num1 大于 num2
min = num2
max = num1
} else {
max = num2
min = num1
}

	    return  // return会自动识别返回
	}

	func main() {
	    min, max := MinAndMax(33, 22)
	    fmt.Printf("min = %d, max = %d\n", min, max) //min = 22, max = 33
	}

延迟调用defer：
关键字 defer ⽤于延迟一个函数或者方法（或者当前所创建的匿名函数）的执行。注意，defer语句只能出现在函数或方法的内部。多个defer语句，按先进后出的方式执行。

	func main() {
	    defer fmt.Println("this is a defer") //main结束前调用
	    fmt.Println("this is a test")
	    defer fmt.Println("this is a defer2")
	    /*
	        运行结果：
	        this is a test
	        this is a defer2
	        this is a defer
	    */
	}

工作区的概念

Go代码必须放在工作区中。工作区其实就是一个对应于特定工程的目录，它应包含3个子目录：src目录、pkg目录和bin目录。

	src目录：用于以代码包的形式组织并保存Go源码文件。（比如：.go .c .h .s等）
	pkg目录：用于存放经由go install命令构建安装后的代码包（包含Go库源码文件）的“.a”归档文件。
	bin目录：与pkg目录类似，在通过go install命令完成安装后，保存由Go命令源码文件生成的可执行文件。

包的概念

所有 Go 语言的程序都会组织成若干组文件，每组文件被称为一个包。这样每个包的代码都可以作为很小的复用单元，被其他项目引用。
一个包的源代码保存在一个或多个以.go为文件后缀名的源文件中，通常一个包所在目录路径的后缀是包的导入路径。

在Go语言中，代码包中的源码文件名可以是任意的。但是，这些任意名称的源码文件都必须以包声明语句作为文件中的第一行，每个包都对应一个独立的名字空间：
	package calc

包中成员以名称首字母大小写决定访问权限：
	public: 首字母大写，可被包外访问
	private: 首字母小写，仅包内成员可以访问

注意：同一个目录下不能定义不同的package。

====== main包 ======

  在 Go 语言里，命名为 main 的包具有特殊的含义。 Go 语言的编译程序会试图把这种名字的包编译为二进制可执行文件。所有用 Go 语言编译的可执行程序都必须有一个名叫 main 的包。一个可执行程序有且仅有一个 main 包。

   当编译器发现某个包的名字为 main 时，它一定也会发现名为 main()的函数，否则不会创建可执行文件。 main()函数是程序的入口，所以，如果没有这个函数，程序就没有办法开始执行。程序编译时，会使用声明 main 包的代码所在的目录的目录名作为二进制可执行文件的文件名。

====== main函数和init函数 ======

	Go里面有两个保留的函数：init函数（能够应用于所有的package）和main函数（只能应用于package main）。这两个函数在定义时不能有任何的参数和返回值。虽然一个package里面可以写任意多个init函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个package中每个文件只写一个init函数。

	Go程序会自动调用init()和main()，所以你不需要在任何地方调用这两个函数。每个package中的init函数都是可选的，但package main就必须包含一个main函数。

	每个包可以包含任意多个 init 函数，这些函数都会在程序执行开始的时候被调用。所有被
	编译器发现的 init 函数都会安排在 main 函数之前执行。 init 函数用在设置包、初始化变量或者其他要在程序运行前优先完成的引导工作。

	程序的初始化和执行都起始于main包。如果main包还导入了其它的包，那么就会在编译时将它们依次导入。
	有时一个包会被多个包同时导入，那么它只会被导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。

	当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数（如果有的话），依次类推。等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。

指针相关注意点

Go语言虽然保留了指针，但与其它编程语言不同的是：

 默认值 nil，没有 NULL 常量
 操作符 “&” 取变量地址， “*” 通过指针访问目标对象
 不支持指针运算，不支持 “->” 运算符，直接⽤ “.” 访问目标成员

切片相关注意点

切片存在的意义：数组的长度在定义之后无法再次修改；数组是值类型，每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。Go语言提供了数组切片（slice）来弥补数组的不足。

切片并不是数组或数组指针，它通过内部指针和相关属性引用数组片段，以实现变长案。

slice和数组的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。

====== 切片做函数参数 ======

切片本身即是一种引用。

		func test(s []int) { //切片做函数参数
		    s[0] = -1
		    fmt.Println("test : ")
		    for i, v := range s {
		        fmt.Printf("s[%d]=%d, ", i, v)
		        //s[0]=-1, s[1]=1, s[2]=2, s[3]=3, s[4]=4, s[5]=5, s[6]=6, s[7]=7, s[8]=8, s[9]=9,
		    }
		    fmt.Println("\n")
		}

		func main() {
		    slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
		    test(slice)

		    fmt.Println("main : ")
		    for i, v := range slice {
		        fmt.Printf("slice[%d]=%d, ", i, v)
		        //slice[0]=-1, slice[1]=1, slice[2]=2, slice[3]=3, slice[4]=4, slice[5]=5, slice[6]=6, slice[7]=7, slice[8]=8, slice[9]=9,
		    }
		    fmt.Println("\n")
		}

map相关知识点

Go语言中的map(映射、字典)是一种内置的数据结构，它是一个无序的key—value对的集合，比如以身份证号作为唯一键来标识一个人的信息。
map格式为：
		map[keyType]valueType

======= map做函数参数 ======

在函数间传递映射并不会制造出该映射的一个副本，不是值传递，而是引用传递：

		func DeleteMap(m map[int]string, key int) {
		    delete(m, key) //删除key值为3的map

		    for k, v := range m {
		        fmt.Printf("len(m)=%d, %d ----> %s\n", len(m), k, v)
		        //len(m)=2, 1 ----> mike
		        //len(m)=2, 3 ----> lily
		    }
		}

		func main() {
		    m := map[int]string{1: "mike", 2: "yoyo", 3: "lily"}

		    DeleteMap(m, 2) //删除key值为3的map

		    for k, v := range m {
		        fmt.Printf("len(m)=%d, %d ----> %s\n", len(m), k, v)
		        //len(m)=2, 1 ----> mike
		        //len(m)=2, 3 ----> lily
		    }
		}

结构体相关概念

====== 结构体初始化 ======

普通变量：
	type Student struct {
	    id   int
	    name string
	    sex  byte
	    age  int
	    addr string
	}
	func main() {
	    //1、顺序初始化，必须每个成员都初始化
	    var s1 Student = Student{1, "mike", 'm', 18, "sz"}
	    s2 := Student{2, "yoyo", 'f', 20, "sz"}
	    //s3 := Student{2, "tom", 'm', 20} //err, too few values in struct initializer

	    //2、指定初始化某个成员，没有初始化的成员为零值
	    s4 := Student{id: 2, name: "lily"}
	}

	指针变量：
	type Student struct {
	    id   int
	    name string
	    sex  byte
	    age  int
	    addr string
	}

	func main() {
	    var s5 *Student = &Student{3, "xiaoming", 'm', 16, "bj"}
	    s6 := &Student{4, "rocco", 'm', 3, "sh"}
	}

Go的面向对象编程

尽管Go语言中没有封装、继承、多态这些概念，但同样通过别的方式实现这些特性：
 封装：通过方法实现
 继承：通过匿名字段实现
 多态：通过接口实现

====== 匿名字段 ======

	一般情况下，定义结构体的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。

		//人
		type Person struct {
		    name string
		    sex  byte
		    age  int
		}

		//学生
		type Student struct {
		    Person // 匿名字段，那么默认Student就包含了Person的所有字段
		    id     int
		    addr   string
		}

		func main() {
		    //顺序初始化
		    s1 := Student{Person{"mike", 'm', 18}, 1, "sz"}
		    //s1 = {Person:{name:mike sex:109 age:18} id:1 addr:sz}
		    fmt.Printf("s1 = %+v\n", s1)

		    //s2 := Student{"mike", 'm', 18, 1, "sz"} //err

		    //部分成员初始化1
		    s3 := Student{Person: Person{"lily", 'f', 19}, id: 2}
		    //s3 = {Person:{name:lily sex:102 age:19} id:2 addr:}
		    fmt.Printf("s3 = %+v\n", s3)

		    //部分成员初始化2
		    s4 := Student{Person: Person{name: "tom"}, id: 3}
		    //s4 = {Person:{name:tom sex:0 age:0} id:3 addr:}
		    fmt.Printf("s4 = %+v\n", s4)
		}

	====== 方法 ======

	在面向对象编程中，一个对象其实也就是一个简单的值或者一个变量，在这个对象中会包含一些函数，这种带有接收者的函数，我们称为方法(method)。 本质上，一个方法则是一个和特殊类型关联的函数。

	在Go语言中，可以给任意自定义类型（包括内置类型，但不包括指针类型）添加相应的方法。

	方法总是绑定对象实例，并隐式将实例作为第一实参 (receiver)，方法的语法如下：
			func (receiver ReceiverType) funcName(parameters) (results)

 参数 receiver 可任意命名。如方法中未曾使用，可省略参数名。
 参数 receiver 类型可以是 T 或 *T。基类型 T 不能是接口或指针。
 不支持重载方法，也就是说，不能定义名字相同但是不同参数的方法。

====== 接口 ======

在Go语言中，接口(interface)是一个自定义类型，接口类型具体描述了一系列方法的集合。

接口类型是一种抽象的类型，它不会暴露出它所代表的对象的内部值的结构和这个对象支持的基础操作的集合，它们只会展示出它们自己的方法。因此接口类型不能将其实例化。

====== 接口定义 ======
		type Humaner interface {
		    SayHi()
		}

 接口命名习惯以 er 结尾
 接口只有方法声明，没有实现，没有数据字段
 接口可以匿名嵌入其它接口，或嵌入到结构中

	== 空接口 ==
	空接口(interface{})不包含任何的方法，正因为如此，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值。它有点类似于C语言的void *类型。

	当函数可以接受任意的对象实例时，我们会将其声明为interface{}，最典型的例子是标准库fmt中PrintXXX系列的函数，例如：
		    func Printf(fmt string, args ...interface{})
		    func Println(args ...interface{})

类型查询

我们知道interface的变量里面可以存储任意类型的数值(该类型实现了interface)。那么我们怎么反向知道这个变量里面实际保存了的是哪个类型的对象呢？目前常用的有两种方法：

 comma-ok断言
 switch测试

====== comma-ok断言 ======

	Go语言里面有一个语法，可以直接判断是否是该类型的变量： value, ok = element.(T)，这里value就是变量的值，ok是一个bool类型，element是interface变量，T是断言的类型。如果element里面确实存储了T类型的数值，那么ok返回true，否则返回false。

			type Element interface{}

			type Person struct {
			    name string
			    age  int
			}

			func main() {
			    list := make([]Element, 3)
			    list[0] = 1       // an int
			    list[1] = "Hello" // a string
			    list[2] = Person{"mike", 18}

			    for index, element := range list {
			        if value, ok := element.(int); ok {
			            fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
			        } else if value, ok := element.(string); ok {
			            fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
			        } else if value, ok := element.(Person); ok {
			            fmt.Printf("list[%d] is a Person and its value is [%s, %d]\n", index, value.name, value.age)
			        } else {
			            fmt.Printf("list[%d] is of a different type\n", index)
			        }
			    }

			    /*  打印结果：
			    list[0] is an int and its value is 1
			    list[1] is a string and its value is Hello
			    list[2] is a Person and its value is [mike, 18]
			    */
			}

====== switch测试 ======

		type Element interface{}

		type Person struct {
		    name string
		    age  int
		}

		func main() {
		    list := make([]Element, 3)
		    list[0] = 1       //an int
		    list[1] = "Hello" //a string
		    list[2] = Person{"mike", 18}

		    for index, element := range list {
		        switch value := element.(type) {
		        case int:
		            fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
		        case string:
		            fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
		        case Person:
		            fmt.Printf("list[%d] is a Person and its value is [%s, %d]\n", index, value.name, value.age)
		        default:
		            fmt.Println("list[%d] is of a different type", index)
		        }
		    }
		}

异常处理相关

Go语言引入了一个关于错误处理的标准模式，即error接口，它是Go语言内建的接口类型，该接口的定义如下：
		type error interface {
		    Error() string
		}

Go语言的标准库代码包errors为用户提供如下方法：
		package errors

		type errorString struct { 
		    text string 
		}

		func New(text string) error { 
		    return &errorString{text} 
		}

		func (e *errorString) Error() string { 
		    return e.text 
		}

====== panic ======

	在通常情况下，向程序使用方报告错误状态的方式可以是返回一个额外的error类型值。
	但是，当遇到不可恢复的错误状态的时候，如数组访问越界、空指针引用等，这些运行时错误会引起painc异常。这时，上述错误处理方式显然就不适合了。反过来讲，在一般情况下，我们不应通过调用panic函数来报告普通的错误，而应该只把它作为报告致命错误的一种方式。当某些不应该发生的场景发生时，我们就应该调用panic。

字符串相关方法

func Contains(s, substr string) bool
功能：字符串s中是否包含substr，返回bool值

func Join(a []string, sep string) string
功能：字符串链接，把slice a通过sep链接起来

func Index(s, sep string) int
功能：在字符串s中查找sep所在的位置，返回位置值，找不到返回-1

func Repeat(s string, count int) string
功能：重复s字符串count次，最后返回重复的字符串

func Replace(s, old, new string, n int) string
功能：在s字符串中，把old字符串替换为new字符串，n表示替换的次数，小于0表示全部替换

func Split(s, sep string) []string
功能：把s字符串按照sep分割，返回slice

func Trim(s string, cutset string) string
功能：在s字符串的头部和尾部去除cutset指定的字符串

func Fields(s string) []string
功能：去除s字符串的空格符，并且按照空格分割返回slice

Append 系列函数将整数等转换为字符串后，添加到现有的字节数组中。

Format 系列函数把其他类型的转换为字符串。

Parse 系列函数把字符串转换为其他类型。

正则表达式

		package main

		import (
		    "fmt"
		    "regexp"
		)

		func main() {
		    context1 := "3.14 123123 .68 haha 1.0 abc 6.66 123."

		    //MustCompile解析并返回一个正则表达式。如果成功返回，该Regexp就可用于匹配文本。
		    //解析失败时会产生panic
		    // \d 匹配数字[0-9]，d+ 重复>=1次匹配d，越多越好（优先重复匹配d）
		    exp1 := regexp.MustCompile(`\d+\.\d+`)

		    //返回保管正则表达式所有不重叠的匹配结果的[]string切片。如果没有匹配到，会返回nil。
		    //result1 := exp1.FindAllString(context1, -1) //[3.14 1.0 6.66]
		    result1 := exp1.FindAllStringSubmatch(context1, -1) //[[3.14] [1.0] [6.66]]

		    fmt.Printf("%v\n", result1)
		    fmt.Printf("\n------------------------------------\n\n")

		    context2 := `
		        <title>标题</title>
		        <div>你过来啊</div>
		        <div>hello mike</div>
		        <div>你大爷</div>
		        <body>呵呵</body>
		    `
		    //(.*?)被括起来的表达式作为分组
		    //匹配<div>xxx</div>模式的所有子串
		    exp2 := regexp.MustCompile(`<div>(.*?)</div>`)
		    result2 := exp2.FindAllStringSubmatch(context2, -1)

		    //[[<div>你过来啊</div> 你过来啊] [<div>hello mike</div> hello mike] [<div>你大爷</div> 你大爷]]
		    fmt.Printf("%v\n", result2)
		    fmt.Printf("\n------------------------------------\n\n")

		    context3 := `
		        <title>标题</title>
		        <div>你过来啊</div>
		        <div>hello 
		        mike
		        go</div>
		        <div>你大爷</div>
		        <body>呵呵</body>
		    `
		    exp3 := regexp.MustCompile(`<div>(.*?)</div>`)
		    result3 := exp3.FindAllStringSubmatch(context3, -1)

		    //[[<div>你过来啊</div> 你过来啊] [<div>你大爷</div> 你大爷]]
		    fmt.Printf("%v\n", result3)
		    fmt.Printf("\n------------------------------------\n\n")

		    context4 := `
		        <title>标题</title>
		        <div>你过来啊</div>
		        <div>hello 
		        mike
		        go</div>
		        <div>你大爷</div>
		        <body>呵呵</body>
		    `
		    exp4 := regexp.MustCompile(`<div>(?s:(.*?))</div>`)
		    result4 := exp4.FindAllStringSubmatch(context4, -1)

		    /*
		        [[<div>你过来啊</div> 你过来啊] [<div>hello
		            mike
		            go</div> hello
		            mike
		            go] [<div>你大爷</div> 你大爷]]
		    */
		    fmt.Printf("%v\n", result4)
		    fmt.Printf("\n------------------------------------\n\n")

		    for _, text := range result4 {
		        fmt.Println(text[0]) //带有div
		        fmt.Println(text[1]) //不带带有div
		        fmt.Println("================\n")
		    }
		}

json处理

使用json.Marshal()函数可以对一组数据进行JSON格式的编码。
使用json.Unmarshal()函数将JSON格式的文本解码为Go里面预期的数据结构。

文件操作

新建文件可以通过如下两个方法：
func Create(name string) (file *File, err Error)
根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666的文件，返回的文件对象是可读写的。

	func NewFile(fd uintptr, name string) *File
	根据文件描述符创建相应的文件，返回一个文件对象

通过如下两个方法来打开文件：
func Open(name string) (file *File, err Error)
该方法打开一个名称为name的文件，但是是只读方式，内部实现其实调用了OpenFile。

	func OpenFile(name string, flag int, perm uint32) (file *File, err Error)
	打开名称为name的文件，flag是打开的方式，只读、读写等，perm是权限

写文件：
func (file *File) Write(b []byte) (n int, err Error)
写入byte类型的信息到文件

	func (file *File) WriteAt(b []byte, off int64) (n int, err Error)
	在指定位置开始写入byte类型的信息

	func (file *File) WriteString(s string) (ret int, err Error)
	写入string信息到文件

读文件：
func (file *File) Read(b []byte) (n int, err Error)
读取数据到b中

	func (file *File) ReadAt(b []byte, off int64) (n int, err Error)
	从off开始读取数据到b中

删除文件
func Remove(name string) Error
调用该函数就可以删除文件名为name的文件