Go基础学习

一、安装sublime与安装PackageControl

　　1、下载Sublime Text：http://www.sublimetext.com/3。选择windows64位下载安装。

　　2、安装过程中记得选择“Add to explorer context menu”，把它加入右键快捷菜单。其它以默认设置安装。

　　3、安装插件，插件网址：https://packagecontrol.io/，如果能打开就在线安装.
　　     安装 Package Control(在线安装)
　　    通过快捷键 ctrl+`` 或者菜单 View > Show Console 或者菜单 视图 > 显示/隐藏控制台 进入控制台，复制下面的代码到控制台运行

　　 4、但是这个网站无法安装packagecontrol因为打不开，所以打不开选择在这下载离线安装：https://github.com/HBLong/channel_v3_daily

           下载好后解压，将Package Control.sublime-package文件复制，打开菜单 - Preferences - Browser Package进入文件夹，当前文件地址是 Sublime Text 3\Packages，我们进入到Sublime Text 3\Installed       　　  Packages文件夹下，将复制的Package Control.sublime-package文件粘贴到目录下，重启Sublime Text3。打开菜单 - Preferences看到下面有package setting和package control就安装好了

二、sublime text3安装并解决Gosublime无法自动补全代码

　　安装Gosublime

　　　　打开Perferences–Browse Packages…，进入Gosublime，在命令行里输入：

　　　　git clone https://github.com/DisposaBoy/GoSublime.git    

　　自动补全解决方法
　　　　在windows和mac上使用sublime text3安装Gosublime插件后都无法自动补全代码，经过多日的研究找到如下解决方法。
　　　　打开Perferences–Browse Packages…，进入Gosublime：
　　　　1、在src目录下创建margo目录；
　　　　2、拷贝src/margo.sh/extension-example/extension-example.go文件到margo目录下；
　　　　3、拷贝margo文件夹（所有文件和目录）到src/margo.sh/vendor目录下；
　　　　4、重新打开sublime text3，稍等几分钟就可以自动补全代码了。

三、Go 语言环境安装

四、Go语言结构

//定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包
package main

//import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包
import (
    "fmt"
)

//func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）
func main() {
    fmt.Print("Hello,World!")
}

//go run test.go运行

五、数据类型

六、切片

var s = []int{2, 3, 4}

    //make是长度为3,5最大长度
    var numbers = make([]int, 3, 5)

    var number2 = []int{2, 3, 3, 4, 4, 3, 4}

    //s5的长度4，容量是7
    s5 := number2[:4]
    //s6的长度是4，容量也是4
    s6 := number2[3:]

    var countnum = len(number2)

    //append追加元素
    number2 = append(number2, 3, 3, 3)
    for i, num := range number2 {
    }

七、闭包

　　1、 闭包是匿名函数与匿名函数所引用环境的组合。匿名函数有动态创建的特性，该特性使得匿名函数不用通过参数传递的方式，就可以直接引用外部的变量。这就类似于常规函数直接使用全局变量一样，个人理解为：匿名函数和它引用的变量以及环境，类似常规函数引用全局变量处于一个包的环境。

package main

//import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包
import (
    "fmt"
)

// 闭包
// 闭包是匿名函数与匿名函数所引用环境的组合。匿名函数有动态创建的特性，该特性使得匿名函数不用通过参数传递的方式，就可以直接引用外部的变量。这就类似于常规函数直接使用全局变量一样，个人理解为：匿名函数和它引用的变量以及环境，类似常规函数引用全局变量处于一个包的环境。

//1、闭包作为函数返回值
func Increase() func() int {
    n := 0
    return func() int {
        fmt.Printf("%p\n", &n)
        n++
        return n
    }
}

func main() {
    //1、闭包
    n := 0
    f := func() int {
        //匿名函数引用外部的变量
        n += 1
        return n
    }
    fmt.Println(f()) // 别忘记括号，不加括号相当于地址
    fmt.Println(f())

    //2、闭包最为返回值
    //闭包被返回赋予一个同类型的变量时，同时赋值的是整个闭包的状态，
    //该状态会一直存在外部被赋值的变量in中，直到in被销毁，整个闭包也被销毁。
    in := Increase()
    fmt.Println(in()) //输出1
    fmt.Println(in()) //输出2
}

　　2、闭包的应用

package main

import (
    "fmt"
)

//隔离数据
// 函数计数器
func counter(f func()) func() int {
    n := 0
    return func() int {
        f()
        n += 1
        return n
    }
}

// 测试的调用函数
func foo() {
    fmt.Println("call foo")
}

func main() {
    cnt := counter(foo)
    cnt()
    cnt()
    cnt()
    fmt.Println(cnt())
}

　　3、装饰函数和创建中间件

func wrapping(f func() string) {
    fmt.Println("do my work...")
    fmt.Println("wrapping function: ", f())
    fmt.Println("my work finished !")
}

func sayHello() string {
    return "Hello !"
}

func sayByeBye() string {
    return "Bye Bye ！"
}

func main() {
    wrapping(sayHello)
    wrapping(sayByeBye)
}

 　　4、将不匹配参数的函数的函数进行应用

package main

//import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包
import (
    "fmt"
)

func f1(f func()) {
    fmt.Println("This f1")
    f()
}

func f2(x, y int) {
    fmt.Println("this f2 ")
    fmt.Println(x + y)
}

//f3对f2进行包装,返回一个不带参数的函数
func f3(a func(x, y int), x, y int) func() {
    tmp := func() {
        a(x, y)
    }
    return tmp
}

func main() {
    //将f2传入到f1
    //将类型不匹配的函数应用到函数参数中
    var tmpf3 = f3(f2, 3, 4)
    f1(tmpf3)
}

 　　5、延迟调用

func main() {
    x, y := 1,2

    defer func(a int){
        fmt.Println("defer x, y = ", a, y) //y为闭包引用
    }(x) //x值拷贝 调用时传入参数

    x += 100
    y += 200

    fmt.Println(x, y)
}

七、defer语句

　　1、defer有延迟调用的特性，处理资源清理、文件关闭、解锁及记录时间等

　　2、defer执行时间，在go语言函数中，return语句不是原子操作，它分为给返回值赋值和RET指令两步，而defer语句执行的时机就在返回值赋值操作后

　　

package main

import (
    "fmt"
)

func f1() int {
    x := 5
    defer func() {
        x++
    }()
    return x //1、返回值进行赋值  2执行defer  3真正的ret指令
}

func f2() (x int) {
    defer func() {
        x++
    }()
    return 5 //1/5返回给了x，2执行了defer里面x++进行运算
}

func f3() (y int) {
    x := 5
    defer func() {
        x++
    }()
    return x //x=5 赋值给ret给了y 而defer该了x的值
}

func f4() (x int) {
    defer func() {
        x++ //改变了x是参数，跟return返回的x无关
    }(x)
    return 5 //
}

func f5() (x int) {
    defer func() {
        x++      //改变了x是参数，跟return返回的x无关
        return x //defer中return值跟f5return值无关
    }(x)
    return 5 //
}

func f6() (x *int) {
    defer func() {
        (*x)++ //defter是指针，是指向x数据的地址
    }(&x)
    return 5 //
}

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

func main() {
    fmt.Print(f1())
    fmt.Print(f2())
    fmt.Print(f3()) //5
    fmt.Print(f4()) //5

    //最后执行defer，calc会先将参数进行计算出来
    defer calc("1", a, calc("10", a, b))
}

八、内置函数

　　1、new 用来分配内存，主要用于分配值类型，int/string, 返回时指针类型

　　2、make用来分配内存，主要分配引用类型，比如chan/map/slice

　　3、panic/recover  在go1.12是没有异常处理机制的，但是使用panic/revocer模式来处理错误。panic任何地方引发，但recover只有在defer调用中有效

package main

import (
    "fmt"
)

func func1() {
    defer func() {
        //获取错误，recover进行修复
        err := recover()
        fmt.Println("释放数据库连接")
    }()
    panic("出现错误")
    fmt.Println("b")
}

func main() {
    func1()
}

 　　4、recover必须搭配在refer使用，defer一定要在可能引发panic的语句之前定义

九、fmt库介绍

　　fmt.printf("%d %f %p指针")

　　fmt.sprintf()

十、自定义类型与别名

　　1、type myInt int ,自定义类型，给类型加入方法

package main

import (
    "fmt"
)

type myInt int

func main() {
    var n myInt
    n = 100

    u := 100

    //int32的类型
    var c rune
    c = '中'
}

十一、结构体

package main

import (
    "fmt"
)

type myInt int

type Person struct {
    name string
    age  int32
}

//传递结构体指针
func f(x *Person) {
    (*x).age = 1
}

func main() {
    // var n myInt
    // n = 100
    // u := 100
    // //int32的类型
    // var c rune
    // c = '中'

    //返回一个指针，指向了结构体
    var p2 = new(Person)
    fmt.Printf("值==%x", p2)
    fmt.Printf("值==%x", &(*p2))
    fmt.Printf("type==%T", p2)

    //声明变量并且初始化
    var p3 = Person{
        name: "lxw",
        age:  1,
    }

    //定义临时的变量
    var s struct {
        x string
        y int
    }
}

 十二、接口

　　

package main

import (
    "fmt"
)

//定义接口
type speaker interface{
    speak()
}

type cat struct{
    name string
    feet int8
}

//实现接口speaker方法
// func (c cat) speak() {
    
// }

func (c *cat) speak() {
    
}

func da(x speaker) {
    x.speak()
}

func main() {
    var c1 = new(cat)
    c2 := cat{"tom", 4}
}

　

　　多个类型实现接口
　　同一个结构体实现多个接口

　　接口还可以嵌套接口

package main

import (
    "fmt"
)

//多个类型实现接口
//同一个结构体实现多个接口

//接口还可以嵌套接口
type animal interface{
    mover
    eater
}

//空接口, 可以接受任何类型，所有的类型都实现了空接口
//...表示接受多个任何类型
func print_me(a ...interface{}) {
    fmt.Printf("type %T", a)
}


//mover接口
type mover interface{
    move()
}

//eater接口
type eater interface{
    eat(string)
}

type cat struct {
    name string
    age int8
}

func (c *cat) move() {
    fmt.Println("xxxxxxxxxxx")
}

func (c *cat) eat(food string) {
    fmt.Println("xxxxxxxxx")
}

func main() {
    var m1 map[string]interface{}
    m1 = make(map[string]interface{}, 16)
    m1["name"] = "linxiannwei"
    m1["age"] = 9000
    m1["hobby"] = [...]string{"唱", "跳"}
}

　　2、判断空接口 x.(T)  x表示类型interface{}变量，T表示断言x可能的类型

　　　　t := a.(type)获取接口动态的类型

　　

package main

import (
    "fmt"
)

//判断空接口的类型 x.(T)  x表示类型interface{}变量，T表示断言x可能的类型
func assign(a interface{}) {
    str, ok := a.(string)
    if !ok {
        //ok表示string类型
    }else{

    }

    t := a.(type)

    switch t {
    case string:
        fmt.Println("是的字符串")
    case int:
    case bool:
        
    }

}

func main() {
    
}

 十三、package使用

　　在文件夹code.number.cal有calc.go

package calc

//包中的标识符（变量名、函数名、结构体、接口等）如果首字母小写的，表示私有（只能当前这个包使用）
//首字母大写的标识符
func Add(x,y int) int{
    return x + y
}

package main

import (
    "fmt"
    "code.number.calc"
)

func main() {
    ret := calc.Add(1,2)
    fmt.Println(ret)
}

　　包的导入，import "包的路径"

　　 1、import导入语句通常放在文件开头包声明语句的下面

　　 2、包名从$GOPATH/scr后开始计算，使用/进行分割

　　3、Go中禁止循环导入包

　　4、自定义包名

　　　　import 别名 "包路径"

十四、init()初始化函数

　　在go语言程序中执行导入包语句自动触发包内部init()函数调用，init()函数没有参数也没有返回值

　　1、包中init函数的执行时机全局变量==》init（）函数==》main函数