Go

Go 基础

编码约定

包导入

import (
    // 导入内置包
    "fmt"
    "log"
    "net/http"
    "time"
    // 导入当前项目下的包
    "http/sessionManager"
    "http/sessionProvider"   
    //匿名导入
    _ "packageA"   //导入不使用
    //内嵌导入   
    .  "packageB"  //类似php的trait,内嵌一个包的方法到当前包中 
    //别名导入
    "crypto/rand"
    mrand "math/rand" // 将名称替换为mrand避免冲突  
)

空白标识符 _

_ 用于忽略某个变量或返回值，或者只是执行导入包的init()函数； Go 语言要求所有变量或导入的包都必须被使用，如果你不想使用，这时候就可以使用空白标识符 _ 来忽略。

init 函数

一个包中可以有个名为 init 的函数来负责包的初始化， 相当于构造方法construct，它没有返回值，init 函数会在 main 函数之前执行, 如果导入了其他包，则先执行其他包的init函数，注意：如果同一个包内的多个 init 顺序是不受保证的。

func init() {
    fmt.Println("execute before than main")
}

数据类型

值类型

bool、string、complex64、complex128、array
int, uint，int8、uint8(byte)、int16、uint16、int32(rune)、uint32、int64、uint64
float32、float64

引用类型

slice   
map
chan

自定义类型

使用 type 关键字，基于一个现有的类型创造新的类型称之为自定义类型 或者 类型定义。

type Fuck int64
type T struct
Type I interface

内置关键字和函数

关键字

    break        default      func         interface    select
    case         defer        go           map          struct
    chan         else         goto         package      switch
    const        fallthrough  if           range        type
    continue     for          import       return       var

函数

    append          用来追加元素到数组、slice中,返回修改后的数组、slice
    close           主要用来关闭channel
    delete          从map中删除key对应的value
    panic           停止常规的goroutine  （panic和recover：用来做错误处理）
    recover         允许程序定义goroutine的panic动作
    real            返回complex的实部   （complex、real imag：用于创建和操作复数）
    imag            返回complex的虚部
    make            用来分配内存，返回Type本身(只能应用于slice, map, channel)
    new             用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
    cap             capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
    copy            用于复制和连接slice，返回复制的数目
    len             获取长度，比如string、array、slice、map、channel ，返回长度
    print、println  底层打印函数，在部署环境中建议使用 fmt 包

变量

全局变量与局部变量

• 全局变量：在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。
• 局部变量：在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量

大多数变量的默认值是其类型的零值。nil 是 interface、function、pointer、map、slice 和 channel 类型变量的默认初始值。

变量申明

一、一行声明一个变量

var name sting  
var title sting = "Python编程时光"

二、多个变量一起声明

var (
    name string
    age int
    gender string
)

三、短变量申明(函数特有)

name := "Python编程时光"

四、声明和初始化多个变量

name, age := "wangbm", 28

常量申明

常量使用 const 关键字申明，注意：常量不能用 := 语法声明。

const (
    A = "A"
    B = 1
)
const C = true

iota是常量的计数器，从0开始，组中每定义1个常量自动递增1，每遇到一个const关键字,iota就会重置为0。

package main
import (
    "fmt"
)
func main() {
    const (
        A = "A"
        B
        C = iota
        D
    )
    const E = iota
    fmt.Println(A, B, C, D, E) // A A 2 3 0
}

数据类型转换

类型转换时一般需要显式的使用某个类型的表达式进行转换，例如表达式 T(v) 将值 v 转换为类型 T。

package main
import (
    "fmt"
    "reflect"
    "strconv"
)
func main() {
    //同类型转换，只能在两种相互兼容的类型之间
    f := 3.15
    int_f := int(f) //浮点变整形
    fmt.Println(int_f)
    bool := true
    fmt.Println(int(bool)) //报错,整型无法和bool类型兼容
    //int 和 string 转换
    num := 3
    str := strconv.Itoa(num)   // 字符串 3
    num, _ = strconv.Atoi(str) // int 3
    fmt.Println(reflect.TypeOf(str), str, num)
    //ascii 转换
    zs := 65
    asc := string(zs)
    fmt.Println(asc) // A
    //浮点型精度处理
    a := 1690                         // 表示1.69
    b := 1700                         // 表示1.70
    c := a * b                        // 结果应该是2873000表示 2.873
    fmt.Println(c)                    // 2873000
    fmt.Println(float64(c) / 1000000) // 2.873
}

不仅可以使用内置类型进行转换，我们自定义的类型也可以进行转换

package main
import (
    "fmt"
)
type tcl int
func main() {
    num := 456
    p := (*tcl)(&num)
    val, isTcl := interface{}(p).(*tcl)
    fmt.Println(*val, isTcl)  // 456, true
}

byte 和 string 转换

• byte： 占用1个节字，就 8 个比特位（2^8 = 256，因此 byte 的表示范围 0~255），所以它和 uint8 类型本质上没有区别，它表示的是 ACSII 表中的一个字符, 可以将byte理解为单个字符的类型。
• rune：占用4个字节，共32位比特位，所以它和 uint32 本质上也没有区别。它表示的是一个 Unicode字符（Unicode是一个可以表示世界范围内的绝大部分字符的编码规范）。

import "fmt"
func main() {
    // 单个字符的类型可以申明为 byte
    var a byte = 'A'
    var b uint8 = 'B'
    fmt.Printf("a 的值: %c \nb 的值: %c", a, b)
}

由于单个 byte 代表一个ACSII字符，那多个 byte 放在一起就组成了字符串，也就是 string 类型(一堆byte组成了字符串，即 byte[])；使用 byte[]来进行默认字符串处理 ，性能和扩展性都有照顾。

func main() {
    // string 转 byte数组
    byteAB := []byte("AB")   // [97 98]
    // byte数组 转 string
    stringAB := string(byteAB) // AB
    fmt.Println(byteAB, stringAB)
}

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。因为一个 UTF8 编码的字符可能会占多个字节，因此更推荐使用 []rune 来处理字符。

s1 := "hello"
//转换为字节数组
byteS1 := []byte(s1)
byteS1[0] = 'H'
fmt.Println(string(byteS1))
s2 := "博客"
//转换为字节数组
runeS2 := []rune(s2)
runeS2[0] = '狗'
fmt.Println(string(runeS2))

函数

函数申明

go 函数可以接受多个参数，并且在函数名之后可以指出返回的类型。

package main
import "fmt"
func add(x int, y int) int {
    return x + y
}
func main() {
    fmt.Println(add(42, 13))
}

可变参数

如果参数数量不确定，可以通过 ...type 来定义不定参数函数。

... type 只能是位于函数参数最后，如果你希望函数的参数传任意类型，可以指定类型为 interface{}。

package main
import "fmt"
func myFunc(args ...int) {
    // 使用for循环获取每个输入的参数
    for _, arg := range args {
        fmt.Println(arg)
    }
    //在内部转发参数
    myFunc2(args ...)
}
func myFunc2(args ...int){
    fmt.Println(args)
}
func main() {
    myFunc(2, 3, 4) 
}

隐式返回

如果函数体中的变量名和返回值的变量名一样，你无需显式的 return 这个变量。

func (manager *Manager) SessionStart() (session Session) {
   ...
   //生成 session
   session, _ = manager.provider.SessionInit(sid)
   ...
   return
}

多返回值

函数还可以有多个返回值。

package main
import "fmt"
func swap(x, y string) (string, string) {
    return y, x
}
func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}

返回nil

nil 是任意类型的0值，当一个函数你没有要求可返回的类型，那么你就返回 nil。

func (provider MemoryDriver) SessionRead(sid string) (sessionManager.Session, error) {
   ...
   return nil, nil
}

回调函数

函数可以用作另一函数的参数，也就是所谓的回调函数。

package main
import (
    "fmt"
    "math"
)
func compute(x,y float64,fn func(float64, float64) float64) float64 {
    return fn(x, y)
}
func main() {
    hypot := func(x, y float64) float64 {
        return math.Sqrt(x*x + y*y)
    }
    fmt.Println(compute(3, 4, hypot))
}

闭包

函数的返回值类型如果是函数，这时候就形成了闭包。

package main
import (
    "fmt"
)
//将 【func(int) int】 看作一个整体，意为 a() 函数的返回值类型为函数
func a() (func(n int) int) {
    // 这里的func 没有函数名，我们称之为匿名函数
    return func(n int) int {
        return n+1
    }
}
func main() {
    b := a()
    fmt.Println(b(5))   // 6
}

错误处理

对于大多数函数，如果要返回错误，将 error 作为多个返回值中的最后一个。

func ListPosts(...) ([]Post, error) {
    conn, err := gorm.Open(...)
    if err != nil {
        return []Post{}, err
    }
    var posts []Post
    if err := conn.Find(&posts).Error; err != nil {
        return []Post{}, err
    }
    return posts, nil
}

当然，我们还可以生成自定义 error 信息。

var ErrTimeOut   = errors.New("执行者执行超时")
var ErrInterrupt = errors.New("执行者被中断")
var fmtError     = fmt.Errorf("借助fmt生成error信息")
//函数调用判断是否为error
...
err := r.run()
if(err != nil){
    // 出错了
    return fmtError
}

defer

defer 会在当前函数返回前执行传入的函数，它会经常被用于关闭文件描述符、关闭数据库连接以及解锁资源

defer 函数会按照后进先出的顺序调用(最早定义的最后执行)。

package main
import "fmt"
func main() {
    fmt.Println("counting") // 立即输出
    // 最先输出的是9,符合最早定义,最后执行的特点
    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }
    fmt.Println("done") // 立即输出
}

外层函数中的 return 语句会等到 defer 函数执行完毕后才会返回。

package main
import "fmt"
func main() {
    fmt.Println(testDefer())  // 2
}
func testDefer() (n int){
    i := 1
    // 这里通过匿名的自执行函数来求值
    defer func(i int) {
        n = i + 1
    }(i)
    return n
}

在 panic 抛出异常之前，会先处理完当前协程上已经defer 的任务，执行完成后再抛出。

func main() {
    defer func() {
        fmt.Println("defer func")
    }()
    arr := []int{1, 2, 3}
    fmt.Println(arr[4])
}

异常处理 panic 和 recover

这两个函数是go的异常处理函数，panic() 相当于抛出异常，recover() 相当于捕获异常。

• panic : 用来抛出错误，该函数接收任意类型的数据，比如整型，字符串，对象等，panic 退出前会执行 defer 指定的内容。
• recover : 用来捕获由 panic 函数抛出的错误，recover 函数应放置于函数体的最前面，并且只有在 defer 调用的函数中有效。

package main
import (
    "errors"
    "fmt"
)
func main() {
    err := doSomeThing()
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("success")
    }
}
func doSomeThing() (err error) {
    defer func() {
        if r := recover(); r != nil {
            //通过类型断言,将捕获的错误值转换为 string 类型,并最终将捕获的错误转换成 error类型返回给调用者
            str , ok := r.(string)
            if ok {
                err = errors.New(str)
            } else {
                panic("new error")
            }
        }
    }()
    panic("some error")
    return err
}

流程控制语句

for

go 只有 for 这一种循环结构，for 是 Go 中的 "while"。需要注意 for,if,switch 都具有块级作用域,即在语句外部无法在语句中定义的变量。

package main
import "fmt"
func main() {
    // for循环
    sum := 0
    for i := 0; i < 10; i++ {
        sum += i
    }
    fmt.Println(sum)
    fmt.Println(i) //报错 undefined: i
    // while 循环
    sum := 1
    for sum < 1000 {
        sum += sum
    }
    fmt.Println(sum)
}

可以使用 for range 对数组,切片,map,通道等迭代。

package main
import (
    "fmt"
)
func main() {
    slice := []int{1, 2, 3, 4, 5}
    // 普通遍历
    for i, v := range slice {
        fmt.Println(i , v)
    }
    // 如果不想要索引，可以使用_来忽略它
    for _, v := range slice {
        fmt.Println(v)
    }
    // 如果你用一个变量来接收的话，接收到的是索引
    for i := range slice {
        fmt.Println(i)
    }
    //range也可以用在map的键值对上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range还可以用来枚举字符串。
    for i2, c := range "go" {
        fmt.Println(i2, string(c)) //得出的c是ASCII值
    }
}

if

if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。

func main() {
    a := 10
    if a := 1; a > 0 {
        a++
        fmt.Println(a) // 2
    } else if a < 0 {
        a--
        fmt.Println(a) 
    }
    fmt.Println(a) // 10，说明if的a只是在局部有用
}

switch

不同于其他语言中的switch语句，go 中一旦条件符合则会自动终止，不需要 break，而如果你希望继续执行下一个case，需使用 fallthrough 语句。
G另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

package main
import (
    "fmt"
    "runtime"
    "time"
)
func main() {
    fmt.Print("Go runs on ")
    os := runtime.GOOS
    switch os {
    case "darwin":
        fmt.Println("OS X.")
    case "linux":
        fmt.Println("Linux.")
    default:
        fmt.Printf("%s.\n", os)
    }
    // fallthrough 语句
    switch a := 200; {
    case a == 100:
        fmt.Println("a=100")
    case a == 200:
        fmt.Println("a=200")
        fallthrough // 不退出，进入下个case语句
    default:
        fmt.Println("a=" + strconv.Itoa(a+a))
    }
    // 没有没有条件的 switch 能将一长串 if-then-else 写得更加清晰
    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.")
    }
}

空语句块

Go中支持空block{}，这个大括号有自己的作用域，里面的代码只执行一次，退出大括号就退出作用域。

func main() {
    {
        v := 1
        {
            v := 2
            fmt.Println(v)   // 输出2
        }
        fmt.Println(v)   // 输出1
    }
}

复合数据类型

指针

Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址） 和 *（根据地址取值），取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。

• 对变量进行取地址（&）操作，可以获得这个变量的指针变量，指针变量的值是指针地址。
• 对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值。

package main
import (
    "fmt"
)
func main() {
   //================= 指向变量的指针 =====================
    var num = 3
    var p *int = &num  // 指针类型的变量,值必须是用 & 标识的内存地址
    var np *int = 3    // 报错， cannot use 3 (type int) as type *int in assignment
    fmt.Println(&num) //0xc0420080c8
    fmt.Println(p);   //0xc0420080c8，p和num指向了同一个内存地址
    fmt.Println(*p)   //3
    //=============== 指向指针的指针 ======================
    var pp **int
    pp = &p
    fmt.Println(pp);   //0xc042004028，获取指针 p 的内存地址，而指针 p 的值存的是它指向的内存地址
    fmt.Println(*pp);   //0xc0420080c8，获取指针p 指向的内存地址
    fmt.Println(**pp)   //3 ，** 获取指针p 指向的内存地址的值
}

数组

类型 [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)
}

Slice

切片是对数组一个连续片段的引用，没有设置元素个数的数组我们称之为切片， []T 表示一个元素类型为 T 的切片，切片用作函数参数是引用传递，切片比数组更常用，Go 中的大部分数组编程都是通过切片来完成的。

切片的零值是 nil，nil 切片的长度和容量为 0 且没有底层数组

package main
import "fmt"
func main() {
    var s []int
    fmt.Println(s, len(s), cap(s))
    if s == nil {
        fmt.Println("nil!")
    }
}

冒号分隔后的切片或数组，包括第一个元素，但排除最后一个元素。

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

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

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

相关函数

• len() : 获取切片的元素个数。
• cap() : 获取切片的容量。
• make([]T, len, cap) : 创建切片,len 是数组的元素个数,cap 是数组的容量，如果cap 省略，则其值和 len 相同。
• copy(dest, from) :复制切片，会在底层创建一个匿名的数组，这样就切断了与原切片间的引用关系，实现的效果是会覆盖相同索引处的元素，如果没有对应的索引，dest不变。
• append() : 向数组/切片追加元素。

切片截取

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)
}

使用 append 追加元素

package main
import (
    "fmt"
)
func main() {
    s  := []int {}
    s2 := []int {1,2,3}
    s = append(s, 4,5,6) // 添加元素到切片
    s2= append(s2, s...) // 通过...操作符合并切片
    fmt.Println(s, s2)   // [4 5 6] [1 2 3 4 5 6]
}

使用 copy 复制切片

package main
import (
    "fmt"
)
func main() {
    s := []int{1}
    arr := []int{4, 5, 6, 7, 8, 9}
    copy(arr, s)
    fmt.Println(arr, s) //[1 5 6 7 8 9] [1]，arr和s有相同的索引(index=0)，所以index=0处的4被覆盖成了1
    s[0] = 0
    fmt.Println(arr, s) //[1 5 6 7 8 9] [0], 切断了引用关系，即使修改了源切片也不会影响copy生成的切片
    //复制整个切片
    arr2 := []int{1, 2, 3, 4, 5}
    arr3 := make([]int, len(arr2))
    copy(arr3, arr2)
    arr3[0] = 0
    fmt.Println(arr2, arr3) // [1 2 3 4 5] [0 2 3 4 5]
}

字符串的底层就是一个 byte 的数组，因此，也可以进行切片操作

package main
import (
    "fmt"
    "strings"
)
func main() {
    host := "www.baidu.com"
    pdIndex := strings.LastIndex(host, ".")
    fmt.Println(host[pdIndex:]) //.com
    s := []byte(host)
    s[0] = 'W'
    fmt.Println(string(s)) //Www.baidu.com
}

Map

map 其实就是key-value形式的数据结构，在别的语言也叫hash表，字典或关联数组。

申明但未初始化的 Map 零值是 nil，既没有键，也不能添加键。

package main
import (
    "fmt"
)
func main(){
    var m1    map[string]string           
    fmt.Println(m1, m1 == nil)   // map[] true
}

可以在申明时给 Map 赋值或者通过 make 函数来初始化 Map，当然可以用任意类型初始化 Map，例如 struct。

package main
import (
    "fmt"
)
type User struct {
    Name string
    Age int
}
func main(){
    m2      := map[string]string{"a":"a"}
    m3      := make(map[string]string)
    // 结构体作为 value
    m4      := map[string]User{
        "zhangsan": { "张三", 18},
        "lisi": {"李四", 19},
    }
    fmt.Println(m2, m3) // map[a:a]  map[]
    fmt.Println(m4)     // map[lisi:{李四 19} zhangsan:{张三 18}]
}

对 Map 进行增删查改。

package main
import "fmt"
func main() {
    m := make(map[string]int)
    // 插入元素
    m["Answer"] = 42
    fmt.Println("The value:", m["Answer"])
    // 修改元素
    m["Answer"] = 48
    fmt.Println("The value:", m["Answer"])
    // 元素数量
    fmt.Println("The count:", len(m))
    // 删除元素
    delete(m, "Answer")
    fmt.Println("The value:", m["Answer"])
    // 判断某个key是否存在
    // 若 key 在 m 中,isset 为 true,否则 isset 为 false。
    // 若 key 不在映射中,那么 v 是该映射元素类型的零值。
    v, isset := m["Answer"]
    if(isset) {
        fmt.Println("v value is", v)
    }else{
        fmt.Println("v not found ", v)
    }
}

对 Map 进行迭代时，它是随机输出元素的，如果你想顺序迭代，可以先对Map中的键排序，然后遍历排好序的键，把对应的值取出来。

package main
import (
    "fmt"
    "sort"
)
func main() {
    m := map[string]string{"a": "A", "b": "B", "c": "C", "d": "D"}
    //===================随机取值=================
    for k, v := range m {
        fmt.Println(k, "=", v) // C D A b
    }
    //================= 顺序取值 ==================
    var keys []string
    for k := range m {
        keys = append(keys, k)
    }
    //对key进行排序
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Println(k, "=", m[k]) // A b C D
    }
}

new 和 make 的区别

• new()： new 返回一个指向类型的指针，并且指针对应的值为该类型的零值，使用时就不必进一步初始化了，new 函数不太常用。
• make()：make 只适用于映射、切片和通道的初始化，返回的还是这三个引用类型本身而非指针，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。

new

import "fmt"
type Student struct {
   name string
   age int
}
func main() {
    // new 一个内建类型
    var a *int
    a = new(int)
    *a = 10
    fmt.Println(*a)  //10
    // new 一个自定义类型
    s := new(Student)
    s.name = "bob"
}

make

package main
import "fmt"
func main() {
    var b = make(map[string]string)
    b["name"] = "bob"
    fmt.Println(b)
}

面向对象

go 没有面向对象的概念，面向对象中我们使用 class 关键字来申明一个类，而在 go 中我们可以通过 type 关键词来申明一个类型。可以将类型看作是面向对象中的对象(相当于申明了一个类)。

自定义类型与类型别名

• 自定义类型：自定义类型是基于内置的基本类型，使用 type 关键字定义的一种全新类型，和原类型是不同的两个类型。
• 类型别名：类型别名和原类型完全一样，只不过是另一种叫法而已。

package main
type D = int   // 类型别名,有等号
type I int     // 自定义类型,无等号
func main() {
    v := 100
    var d D = v    // 不报错
    var i I = v    // 报错
    var K I = I(v) // 转换成 I 类型后就不报错了
}

１．自定义类型
有这么一个闭包函数，参数类型和返回值类型都是函数，对于这样的代码其实是不好读的。

func getValue(func(n int) int) func(n int) int {
    return func(n int) int {
        return c(n) + 1
    }
}

我们可以借助自定义类型重构如下，这样一来这个函数就比较可读了。

type IntCompute func(n int) int
func getValue(c IntCompute) IntCompute {
    return func(n int) int {
        return c(n) + 1
    }
}

２．类型别名

类型别名还可以为其它包中的类型定义别名，只要这个类型在其它包中是导出的：

package main
import (
    "fmt"
    "time"
)
type MyTime = time.Time
func main() {
    var t MyTime = time.Now()
    fmt.Println(t)
}

如果类型别名导出是的，那么别的包中就可以使用，它和原始类型是否是导出没关系：

type t1 struct {
    S string
}
type T2 = t1

在switch中，你不能将原类型和类型别名作为两个分支，因为这是重复的case:

package main
import "fmt"
type D = int
func main() {
    var v interface{}
    var d D = 100
    v = d
    switch i := v.(type) {
    case int:
        fmt.Println("it is an int:", i)
    //报错： duplicate case int in type switch
    case D:
        fmt.Println("it is D type:", i)
    }
}

既然类型别名和原始类型是相同的，那么它们的方法集也是相同的：

package main
type T1 struct{}
type T3 = T1
func (t1 T1) say() {}
func (t3 *T3) greeting() {}
func main() {
    var t1 T1
    var t3 T3
    t1.say()
    t1.greeting()
    t3.say()
    t3.greeting()
}

类型别名建立的类型只能为本地类型添加方法，不能为内置类型添加方法：

package main
import (
    "fmt"
    "time"
)
type NTime = time.Time
// 报错 ：cannot define new methods on non-local type time.Time
func (t NTime) Dida() {
    fmt.Println("嘀嗒嘀嗒嘀嗒嘀嗒搜索")
}
func main() {
    t := time.Now()
    t.Dida()
}

对象定义三要素

• 对象申明，即用 type 关键字定义的类型，可以是 int，struct 等任意类型。
• 构造函数，即结构体实例化，推荐返回对象为指针类型。
• 方法接收者，即定义对象函数，推荐接收者为指针类型。

package main
import "fmt"
//对象定义
type person struct {
    name string
    city string
    age  int8
}
//构造函数
func newPerson(name, city string, age int8) *person {
    return &person{
        name: name,
        city: city,
        age:  age,
    }
}
//接收者
func (p *person) SetAge(newAge int8) {
    p.age = newAge
}
func main() {
    p := newPerson("bob", "beijing", 20)
    p.SetAge(18)
    fmt.Println(p.name, (*p).age)
}

Struct

Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了，Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体(struct)，通过 struct 可以实现面向对象。

结构体定义与实例化

package main
import (
    "fmt"
)
func main() {
    //============================结构体定义=========================
    type T_simple struct {
        id    int
        name  string
        phone string
        age   int
    }
    //基本的实例化
    var t T_simple
    t.id         = 10
    t.name       = "tcl"
    fmt.Println(t) //{10 tcl  0}
    //new 函数实例化
    new_simple = new(T_simple)  //类似其他语言　new 对象一样
    t.id         = 10
    t.name       = "tcl"
    fmt.Println(t) //{10 tcl  0}
    //键值对方式实例化
    t_simple := T_simple{ id:11, name:"tcl"}
    fmt.Println(t_simple)  // {11 tcl  0}
    //定义并初始化
    t_default := struct {
        Name string
        Age  int
    }{
        "tcl", 28,
    }
    fmt.Println(t_default)  // tcl 28
}

结构体中字段大写开头表示可公开访问，小写表示私有(仅在定义当前结构体的包中可访问)，结构体成员使用 . 访问。

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

指向结构体的指针 p，可以通过 (*p).X 来访问其字段 X，也可以通过 p.X 访问。p.X 的底层其实就是 (*p).X，这是go为了方便结构体使用帮我们实现的语法糖。

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

方法

方法只是个带接收者参数的函数，接收者位于 func 关键字和方法名之间，接收者只能是通过 type 关键词申明的类型。接收者的类型定义和方法声明必须在同一包内。

package main
import (
    "fmt"
)
type Rect struct {
    width float64
    height float64
}
// Area 方法拥有一个名为 r,类型为 Rect 的接收者
func (r *Rect) Area() float64 {
    return r.width * r.height
}
//在Go语言中没有构造函数的概念,通常以 NewXXX 命名的函数来表示【构造函数】
func NewRect(width, height float64) *Rect {
    return &Rect{width, height}
}
func main() {
    r := NewRect(3,4)
    fmt.Println(r.Area())  // 12
}

如果结构体比较复杂的话，值拷贝性能开销会比较大，因此构造函数推荐返回结构体的指针类型。

方法调用时没有严格要求接收者的类型，即方法的接收者为指针类型的话，也可以通过值类型来调用该方法，反之也是这样。

一般来说指针接收者比值接收者更常用：

• 方法经常需要修改它的接收者指向的值。
• 可以避免在每次调用方法时复制该值，若值的类型为大型结构体时，这样做会更加高效。

package main
import (
    "fmt"
)
type person struct {
    name string
}
// 接收者为值
func (p person) Call(){
    fmt.Println("value call")
}
// 接收者为指针
func (p *person) Call2(){
    fmt.Println("point call")
}
func main() {
    p := person{}
    p.Call()      // value call
    (&p).Call()   // value call
    p.Call2()     // point call
    (&p).Call2()  // point call
}

结构体嵌套

• 一个结构体中可以嵌套包含另一个结构体或结构体指针，我们称为结构体嵌套，这样就能将一个有简单行为的对象组合成有复杂行为的对像。

• 结构体还以可以包含一个或多个匿名结构体，即结构体没有字段名只有类型。匿名结构体其实仍然拥有自己的字段名，只是字段名就是其类型本身而己。

结构体嵌套

package main
import "fmt"
//Address 地址结构体
type Address struct {
    Province string
    City     string
}
//User 用户结构体
type User struct {
    Name    string
    Gender  string
    Address Address
}
func main() {
    user := User{
        Name:   "bob",
        Gender: "man",
        Address: Address{
            Province: "广东",
            City:     "深圳",
        },
    }
    fmt.Printf("user=%#v\n", user)
}

匿名结构体嵌套

嵌套多个匿名机结构体时，要求字段名称必须唯一，如果有同名字段会有冲突，如果结构体内部有同名字段，就不要使用匿名结构体嵌套了。

package main
import "fmt"
//Address 地址结构体
type Address struct {
    Province string
    City     string
}
//User 用户结构体
type User struct {
    Name    string
    Gender  string
            Address   //这里的
}
func main() {
    user := User{
        Name:   "bob",
        Gender: "man",
        Address: Address{
            Province: "广东",
            City:     "深圳",
        },
    }
    // 通过匿名结构体.字段名访问
    fmt.Println(user.Address.City)
    // 直接访问匿名结构体的字段名
    fmt.Println(user.Province)
}

结构体标签

结构体标签是它是一个附属于字段的字符串，存储了字段的元数据(如字段映射，数据校验，对象关系映射等等)。

最常用的一个场景就是 json 的编解码，标签名会以结构体字段别名的方式出现在 json 中：

package main
import (
    "encoding/json"
    "fmt"
)
// 在编解码时 "omitempty" 会忽略 false,0,空指针,空接口,空数组,空切片,空映射,空字符。
// "-" 会完全跳过该字段。
// 小写的字段也会被忽略。
type User struct{
    Name    string `json:"name"`
    Age     int `json:"age"`
    Phone   string `json:"phone,omitempty"`
    Id      int `json:"-"`
}
func main() {
    h := User{
        Name : "tcl",
        Age  : 27,
        Phone: "",
        Id   : 100,
    }
    jsonData, err := json.Marshal(h)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(string(jsonData))  //{"name":"tcl","age":27}
}

字段的标签可以有多个键值对，多个键值对使用空格分开：

type User struct{
    Name    string `json:"name"`
    Age     int `json:"age"`
    Phone   string `json:"phone,omitempty"`
    Id      int `json:"-"`
    Area    string `province:"广东" city:"shenzhen"`
}

通过反射可以获取字段的标签信息：

package main
import (
    "fmt"
    "reflect"
)
type User struct{
    Name    string `json:"name"`
    Age     int `json:"age"`
    Phone   string `json:"phone,omitempty"`
    Id      int `json:"-"`
    Area    string `province:"广东" city:"shenzhen"`
}
func main() {
    var u User
    t:=reflect.TypeOf(u)
    // 遍历字段
    for i:=0;i<t.NumField();i++{
        field:=t.Field(i)
        fmt.Println(field.Tag)
    }
    //获取特定字段的标签信息
    area, _ := t.FieldByName("Area")
    fmt.Println(area.Tag.Get("province"))  //获取键值对中的某个 key
    fmt.Println(area.Tag.Lookup("city"))   //查找标签中某个 key 是否存在
}

Json 编解码

encoding/json 包中的 Marshal() 和 Unmarshal() 方法可以用来对json数据进行编解码， struct、slice、array、map都可以转换成json。

`Marshal()`：Go数据对象 -> json数据
`UnMarshal()`：Json数据 -> Go数据对象

• struct、slice、array、map 都可以转换成 json
• struct 转换成json的时候，只有字段首字母大写的字段才会被转换
• map 转换的时候，key必须为string
• 封装的时候，如果是指针，会追踪指针指向的对象进行封装

首字母小写的字段是不会被编码输出的(未导出)，但如果你就想编码后的字段名是小写的，那么这时候结构体标签(json:tag)就能帮你实现这种效果。

package main
import (
    "encoding/json"
    "fmt"
    "time"
)
/*
ref 是 Id 字段编解码时的别名
private 字段不会被编码,因为它是小写(未导出的)
*/
type FruitBasket struct {
    Name    string
    Fruit   []string
    Id      int64  `json:"ref"`
    private string
    Created time.Time
}
func main() {
    basket := FruitBasket{
        Name:    "Standard",
        Fruit:   []string{"Apple", "Banana", "Orange"},
        Id:      999,
        private: "Second-rate",
        Created: time.Now(),
    }
    jsonData, err := json.Marshal(basket)
    if err != nil {
        fmt.Println(err)
    }
    // json.Marshal 生成数据类型是字节数组([]byte)，因此我们需要string()将其转换成字符串
    fmt.Println(string(jsonData))
    // "Name":"Standard","Fruit":["Apple","Banana","Orange"],"ref":999,"Created":"2019-07-27T15:13:5"}
}

解码时，如果你明确知道待解码字符串的类型，你可以为 json 字符串指定一个解析模板，让其解析为特定的某个对象。

package main
import (
    "encoding/json"
    "fmt"
    "time"
)
type FruitBasket struct {
    Name    string
    Fruit   []string
    Id      int64  `json:"ref"`
    private string
    Created time.Time
}
func main() {
    // json.Unmarshal 需要参数类型为字节数组, 需要把字符串转为 []byte 类型
    jsonStr := []byte(`
    {
        "Name": "Standard",
        "Fruit": [
            "Apple",
            "Banana",
            "Orange"
        ],
        "ref": 999
    }
    `)
    // 让 jsonStr 解析为对象 basketStruct 
    var basketStruct FruitBasket
    err := json.Unmarshal(jsonStr, &basketStruct)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(basketStruct)
}

JSON解析的时候只会解析能找得到的字段，找不到的字段会被忽略，这样的一个好处是：当你接收到一个很大的JSON数据结构而你却只想获取其中的部分数据的时候，你只需将你想要的数据对应的字段名大写，即可轻松解决这个问题。

如果你不知道待解码字符串有哪些字段，可以定义一个 interface{} 类型，interface{} 在 go 表示任意类型，然后利用类型断言特性var.(T)，把解码结果转换为 map[string]interface{} 类型来进行后续操作。

package main
import (
    "encoding/json"
    "fmt"
    "time"
)
type FruitBasket struct {
    Name    string
    Fruit   []string
    Id      int64  `json:"ref"`
    private string
    Created time.Time
}
func main() {
    jsonStr := []byte(`
    {
        "Name": "Standard",
        "Fruit": [
            "Apple",
            "Banana",
            "Orange"
        ],
        "ref": 999
    }
    `)
    // 申明一个任意类型的对象
    var any interface{}
    var basketStruct FruitBasket
    err := json.Unmarshal(jsonStr, &basketStruct)
    err2 := json.Unmarshal(jsonStr, &any)
    if err != nil || err2 != nil {
        fmt.Println(err)
    }
    // interface{}()是类型转换的语法,因为类型断言要求变量类型必须接口类型,这里将 basketStruct 转换为接口类型
    value1, isBasketStruct := interface{}(basketStruct).(FruitBasket)
    fmt.Println(value1, isBasketStruct)
    // {Standard [Apple Banana Orange] 999  0001-01-01 00:00:00 +0000 UTC} true
    // 使用类型断言特性将结果转换为 map[string]interface{}
    value2, isMap := any.(map[string]interface{})
    fmt.Println(value2, isMap)
    //map[Fruit:[Apple Banana Orange] Name:Standard ref:999] true
}

接口

接口 是由一组方法签名定义的集合，和传统面向对象语言中的接口一样，go 接口中的定义方法 只能是没有方法名的抽象方法，而通过接口中嵌入其它接口，就能实现传统面向对象中的接口继承。

接口类型的变量

接口也是一种类型，如果一个变量的类型是接口，我们就称该变量为接口型变量，可以用接口型变量保存任何实现了接口方法的对象。

package main
import (
    "fmt"
)
//=============== 接口申明 ============================
type Abser interface {
    Abs() float64
}
//==============MyFloat 实现了接口 Abser==============
type MyFloat float64
func (f MyFloat) Abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}
//==============Vertex 实现了接口 Abser ===================
type Vertex struct {
    X, Y float64
}
func (v *Vertex) Abs() float64 {
    return v.X*v.X + v.Y*v.Y
}
func main() {
    //申明接口型变量
    var a Abser
    var b Abser
    // 接口类型的变量可以保存实现该接口的类型
    a = &Vertex{3, 4}
    b = MyFloat(-0.1)
    // 尽管方法名一样,但这两者的方法体行为完全不一样,这就是多态
    fmt.Println(a.Abs())
    fmt.Println(b.Abs())
}