go理论知识记录(入门2)

go理论知识记录(入门2)

来源于刘丹冰老师的课程

type关键字

1. 定义类型别名

使用 type 关键字可以为现有类型定义别名。

语法：

type 新类型名 原类型

示例：

type myInt int

• myInt 是 int 类型的别名，但它是一个全新的类型，不能直接与 int 类型混用。

2. 使用自定义类型

定义别名后，可以像使用原类型一样使用新类型。

示例：

var a myInt = 10
fmt.Printf("%d\n", a) // 输出: 10

3. 定义结构体

结构体是一种复合数据类型，用于将多个字段组合在一起。

语法：

type 结构体名 struct {
    字段1 类型1
    字段2 类型2
    ...
}

示例：

type book struct {
    title string
    auth  string
}

4. 使用结构体

定义结构体后，可以创建结构体变量并访问其字段。

示例：

var book1 book
book1.title = "Golang"
book1.auth = "zhangsan"

fmt.Printf("%v\n", book1) // 输出: {Golang zhangsan}

5. 完整示例代码

以下是完整的示例代码：

package main

import "fmt"

// 给 int 类型起别名
type myInt int

// 声明一个结构体类型
type book struct {
    title string
    auth  string
}

func main() {
    // 使用自定义类型
    var a myInt = 10
    fmt.Printf("%d\n", a) // 输出: 10

    // 使用结构体
    var book1 book
    book1.title = "Golang"
    book1.auth = "zhangsan"

    fmt.Printf("%v\n", book1) // 输出: {Golang zhangsan}
}

6. 输出结果

运行上述代码后，输出如下：

10
{Golang zhangsan}

7. 注意事项

1. 类型别名与原始类型：

   • 类型别名是一个全新的类型，不能直接与原始类型混用。
   • 如果需要转换，必须显式进行类型转换。

   示例：

   var a myInt = 10
   var b int = int(a) // 显式类型转换
   

2. 结构体字段访问：

   • 结构体的字段通过 . 操作符访问。
   • 如果结构体字段未初始化，会使用其类型的零值。

3. 值接收者 vs 指针接收者：

   • 值接收者（func (this Hero)）会创建对象的副本，修改不会影响原始对象。
   • 指针接收者（func (this *Hero)）直接操作原始对象，修改会生效。

结构体的注意点

1. 公有与私有：

• Go 语言通过首字母大小写控制访问权限。
• 大写字母开头的字段或方法可以在包外访问。
• 小写字母开头的字段或方法只能在包内访问。

2. 指针接收者的使用：

• 如果需要在方法中修改结构体的字段，必须使用指针接收者。
• 否则，修改只会作用于方法的副本，不会影响原始对象。

3. 方法命名规范：

• 方法名应清晰表达其功能。
• 遵循 Go 语言的命名规范，使用驼峰式命名法。

好的！以下是关于 Go语言中的继承 的学习笔记片段，重点围绕你提供的代码，解释 Go 语言如何通过 结构体嵌入 实现类似继承的功能。

继承

Go 语言本身并没有继承，但通过 结构体嵌入 和 方法提升，可以实现类似继承的效果。

1. 结构体嵌入

在代码中，Hero 结构体嵌入了 Human 结构体：

type Hero struct {
    Human // 嵌入 Human 结构体
    level int
}

• 嵌入 意味着 Hero 结构体继承了 Human 的所有字段和方法。
• Hero 可以直接访问 Human 的字段和方法，就像访问自己的字段和方法一样。

2. 方法提升

嵌入的结构体的方法会被 自动提升 到外层结构体中。例如：

func (this *Human) Eat() {
    fmt.Println("human eat……")
}

• 由于 Human 被嵌入到 Hero 中，Hero 实例可以直接调用 Eat 方法：

h := Hero{Human{"lucifer", "male"}, 80}
h.Eat() // 输出：human eat……

3. 方法重写

Go 语言允许外层结构体 重写 嵌入结构体的方法。例如：

func (this *Hero) Eat() {
    fmt.Println("hero eat……")
}

• 当 Hero 重写了 Eat 方法后，调用 h.Eat() 时会优先调用 Hero 的 Eat 方法，而不是 Human 的 Eat 方法：

h.Eat() // 输出：hero eat……

4. 访问嵌入结构体的方法

即使外层结构体重写了方法，仍然可以通过 显式指定嵌入结构体 来调用原始方法。例如：

h.Human.Eat() // 输出：human eat……

5. 初始化嵌入结构体

在初始化时，可以直接为嵌入结构体赋值。例如：

h := Hero{Human{"lucifer", "male"}, 80}

• 这里为 Hero 的 Human 部分初始化了 name 和 sex 字段。

6. 代码示例分析

func main() {
    h := Hero{Human{"lucifer", "male"}, 80} // 初始化 Hero
    h.doi()  // 调用 Human 的 doi 方法
    h.Eat()  // 调用 Hero 重写的 Eat 方法
    h.Fly()  // 调用 Hero 重写的 Fly 方法
}

• h.doi()：调用的是 Human 的 doi 方法，因为 Hero 没有重写它。
• h.Eat() 和 h.Fly()：调用的是 Hero 重写后的方法。

注意点

• Go 语言通过 结构体嵌入 实现类似继承的功能。
• 嵌入结构体的字段和方法会被 自动提升 到外层结构体。
• 外层结构体可以 重写 嵌入结构体的方法，实现多态。
• 通过显式指定嵌入结构体，可以调用原始方法。

以下是关于 Go 语言多态 的学习笔记片段，基于你提供的代码，详细解释了多态的实现原理和代码分析。

Go 语言中的多态

多态是面向对象编程的重要特性之一，它允许 父类指针指向子类实例，并通过统一的接口调用不同子类的方法。Go 语言通过 接口 实现了多态。

1. 多态的实现条件

在你的代码中，多态的实现需要满足以下条件：

1. 定义接口：AnimalIF 接口定义了 Sleep、GetColor 和 GetType 方法。
2. 实现接口：Cat 和 Dog 结构体实现了 AnimalIF 接口的所有方法。
3. 父类指针指向子类实例：在 main 函数中，AnimalIF 类型的变量（父类指针）分别指向了 Cat 和 Dog 的实例。

2. 代码分析

定义接口

type AnimalIF interface {
    Sleep()
    GetColor() string // 获取动物颜色
    GetType() string  // 获取动物种类
}

• AnimalIF 接口定义了三个方法：Sleep、GetColor 和 GetType。
• 任何实现了这三个方法的类型都可以被认为是 AnimalIF 接口的实现。

实现接口

Cat 和 Dog 结构体分别实现了 AnimalIF 接口的所有方法。

Cat 结构体

type Cat struct {
    color string
}

func (this *Cat) Sleep() {
    fmt.Println("cat is sleeping")
}

func (this *Cat) GetColor() string {
    return this.color
}

func (this *Cat) GetType() string {
    return "Cat v1.0"
}

• Cat 实现了 Sleep、GetColor 和 GetType 方法。

Dog 结构体

type Dog struct {
    color string
}

func (this *Dog) Sleep() {
    fmt.Println("dog is sleeping")
}

func (this *Dog) GetColor() string {
    return this.color
}

func (this *Dog) GetType() string {
    return "Dog v1.0"
}

• Dog 也实现了 Sleep、GetColor 和 GetType 方法。

使用多态

在 main 函数中，通过 AnimalIF 接口类型的变量调用不同子类的方法：

func main() {
    var animal AnimalIF // 接口数据类型，父类的指针

    // 父指针指向 Cat 实例
    animal = &Cat{"green"}
    animal.Sleep() // 调用 Cat 的 Sleep 方法
    fmt.Println("Cat color:", animal.GetColor())
    fmt.Println("Cat type:", animal.GetType())

    // 父指针指向 Dog 实例
    animal = &Dog{"yellow"}
    animal.Sleep() // 调用 Dog 的 Sleep 方法
    fmt.Println("Dog color:", animal.GetColor())
    fmt.Println("Dog type:", animal.GetType())
}

• animal = &Cat{"green"}：AnimalIF 类型的变量 animal 指向 Cat 实例。
• animal = &Dog{"yellow"}：AnimalIF 类型的变量 animal 指向 Dog 实例。
• 通过 animal.Sleep() 调用方法时，实际调用的是 Cat 或 Dog 的 Sleep 方法，具体取决于 animal 指向的实例。

3. 运行结果

运行代码后，输出如下：

cat is sleeping
Cat color: green
Cat type: Cat v1.0
dog is sleeping
Dog color: yellow
Dog type: Dog v1.0

注意点

• Go 语言通过 接口 实现多态。
• 多态的条件：
  1. 定义接口。
  2. 子类实现接口的所有方法。
  3. 父类指针指向子类实例。
• 多态提高了代码的复用性、扩展性和灵活性。

以下是关于 Go 语言中的 interface{} 的学习笔记片段，基于你提供的代码，详细解释了 interface{} 的使用方法和相关特性。

interface{}

interface{} 是 Go 语言中的 空接口，它可以存储任意类型的值。因为所有类型都至少实现了零个方法，所以所有类型都满足空接口。

1. 特点

• 万能数据类型：interface{} 可以存储任何类型的值，包括基本类型（如 int、string）和复杂类型（如结构体、切片、映射等）。
• 类型断言：通过 类型断言，可以从 interface{} 中提取具体的类型和值。

2. 代码分析

定义函数接受 interface{} 参数

func myFunc(arg interface{}) {
    fmt.Println("myFunc is called")
}

• myFunc 函数的参数类型是 interface{}，因此它可以接受任意类型的参数。

类型断言

在 myFunc 函数中，使用 类型断言 判断 arg 的具体类型：

value, ok := arg.(string)
if !ok {
    fmt.Println("arg is not string type")
} else {
    fmt.Println("arg is string type, value is", value)
}

• arg.(string)：尝试将 arg 断言为 string 类型。
• value：如果断言成功，value 是 arg 的具体值。
• ok：如果断言成功，ok 为 true；否则为 false。

调用 myFunc 函数

在 main 函数中，分别传入不同类型的参数：

func main() {
    book := Book{"golang"}

    myFunc(book)  // 传入结构体
    myFunc(100)   // 传入整数
    myFunc("200") // 传入字符串
}

• myFunc(book)：传入 Book 结构体实例。
• myFunc(100)：传入整数 100。
• myFunc("200")：传入字符串 "200"。

3. 运行结果

运行代码后，输出如下：

myFunc is called
arg is not string type
myFunc is called
arg is not string type
myFunc is called
arg is string type, value is 200

4. 类型断言的详细说明

类型断言的语法：

value, ok := arg.(Type)

• arg：interface{} 类型的变量。
• Type：目标类型（如 string、int 等）。
• value：如果断言成功，value 是 arg 的具体值；否则为 Type 的零值。
• ok：如果断言成功，ok 为 true；否则为 false。

5. 使用 switch 进行类型判断

除了 if-else，还可以使用 switch 语句对 interface{} 进行类型判断：

func myFunc(arg interface{}) {
    fmt.Println("myFunc is called")

    switch v := arg.(type) {
    case string:
        fmt.Println("arg is string, value is", v)
    case int:
        fmt.Println("arg is int, value is", v)
    case Book:
        fmt.Println("arg is Book, auth is", v.auth)
    default:
        fmt.Println("arg is unknown type")
    }
}

• arg.(type)：只能在 switch 语句中使用，用于判断 arg 的具体类型。
• v：arg 的具体值。

5. 注意点

• interface{} 是 Go 语言中的万能数据类型，可以存储任意类型的值。
• 通过 类型断言 或 switch 类型判断，可以从 interface{} 中提取具体的类型和值。
• 空接口在需要处理多种数据类型的场景中非常有用，例如 JSON 解析、泛型编程等。

好的！以下是关于 Go 语言中的 pair 概念 的学习笔记片段，基于你提供的代码，详细解释了 pair 的作用和实现原理。

pair

在 Go 语言中，pair 是一个常见的概念，用于描述变量或接口的内部结构。具体来说，pair 由两部分组成：

1. 类型信息（Type）：表示变量的静态类型。
2. 值信息（Value）：表示变量的实际值。

这种 pair 的概念在 Go 语言的接口实现中尤为重要，因为接口变量实际上存储了一个 pair，其中包含 动态类型 和 动态值。

1. 普通变量的 pair

对于普通变量，pair 的结构是固定的：

• 类型信息：变量的静态类型。
• 值信息：变量的实际值。

示例代码

var a string
a = "abcde" // pair<static type: string, value: "abcde">

• 变量 a 的 pair 是 <string, "abcde">。

2. 接口变量的 pair

对于接口变量，pair 的结构是动态的：

• 类型信息：接口的动态类型（即实际存储的值的类型）。
• 值信息：接口的动态值（即实际存储的值）。

示例代码

var allType interface{}
allType = a // pair<dynamic type: string, value: "abcde">

• 变量 allType 的 pair 是 <string, "abcde">。
• 通过类型断言，可以从接口中提取出具体的类型和值：

  str, _ := allType.(string)
  fmt.Println(str) // 输出：abcde
  

3. 接口的类型断言

类型断言用于从接口中提取具体的类型和值。它的语法是：

value, ok := interfaceVar.(Type)

• interfaceVar：接口变量。
• Type：目标类型。
• value：如果断言成功，value 是接口的动态值。
• ok：如果断言成功，ok 为 true；否则为 false。

示例代码

str, ok := allType.(string)
if ok {
    fmt.Println("动态类型是 string，值是", str)
} else {
    fmt.Println("动态类型不是 string")
}

4. 接口的 pair 在类型转换中的应用

在 Go 语言中，接口的 pair 可以用于实现类型转换。例如，将 io.Reader 接口转换为 io.Writer 接口。

示例代码

tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
    fmt.Println("open file error", err)
    return
}

var r io.Reader
r = tty // pair<dynamic type: *os.File, value: "/dev/tty">

var w io.Writer
w = r.(io.Writer) // pair<dynamic type: *os.File, value: "/dev/tty">

w.Write([]byte("hello test!\n"))

• r 的 pair 是 <*os.File, "/dev/tty">。
• 通过类型断言，将 r 转换为 io.Writer 接口，w 的 pair 仍然是 <*os.File, "/dev/tty">。
• 调用 w.Write 方法时，实际调用的是 *os.File 的 Write 方法。

5. 注意点

• pair 是 Go 语言中描述变量或接口内部结构的概念，包含类型信息和值信息。
• 对于普通变量，pair 是静态的；对于接口变量，pair 是动态的。
• 通过 类型断言，可以从接口中提取具体的类型和值。
• 接口的 pair 在类型转换和方法调用中起着关键作用。

完整代码示例

以下是结合 pair 概念的完整代码示例：

示例 1：普通变量和接口的 pair

package main

import "fmt"

func main() {
    var a string
    a = "abcde" // pair<static type: string, value: "abcde">

    var allType interface{}
    allType = a // pair<dynamic type: string, value: "abcde">

    str, _ := allType.(string)
    fmt.Println(str) // 输出：abcde
}

示例 2：接口的类型转换

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
    if err != nil {
        fmt.Println("open file error", err)
        return
    }

    var r io.Reader
    r = tty // pair<dynamic type: *os.File, value: "/dev/tty">

    var w io.Writer
    w = r.(io.Writer) // pair<dynamic type: *os.File, value: "/dev/tty">

    w.Write([]byte("hello test!\n"))
}

以下是关于 Go 语言中的 reflect 包 的学习笔记片段，基于你提供的代码，详细解释了反射的使用方法和相关特性。

反射（reflect 包）

反射是 Go 语言中一种强大的机制，允许程序在运行时动态地获取变量的类型信息和值信息，并对其进行操作。reflect 包提供了实现反射的核心功能。

1. 反射的基本概念

• 类型信息（Type）：表示变量的静态类型。
• 值信息（Value）：表示变量的实际值。
• 反射的核心函数：
  • reflect.TypeOf(arg)：获取 arg 的类型信息。
  • reflect.ValueOf(arg)：获取 arg 的值信息。

2. 反射的基本用法

示例代码

func reflectNum(arg interface{}) {
    fmt.Println("type:", reflect.TypeOf(arg))
    fmt.Println("value:", reflect.ValueOf(arg))
}

• reflect.TypeOf(arg)：返回 arg 的类型信息。
• reflect.ValueOf(arg)：返回 arg 的值信息。

3. 反射操作结构体

定义结构体

type User struct {
    Id   int
    Name string
    Age  int
}

func (this *User) Call() {
    fmt.Println(this.Name)
}

• User 结构体包含三个字段：Id、Name 和 Age。
• Call 方法是指针接收者方法。

反射获取结构体字段和方法

func DoFiledAndMethod(input interface{}) {
    // 获取 type
    InputType := reflect.TypeOf(input)
    fmt.Println("InputType is : ", InputType)

    // 获取 value
    InputValue := reflect.ValueOf(input)
    fmt.Println("InputValue is : ", InputValue)

    // 如果 input 是指针类型，获取其指向的实际类型
    if InputType.Kind() == reflect.Ptr {
        InputType = InputType.Elem() // 获取指针指向的实际类型
        InputValue = InputValue.Elem() // 获取指针指向的实际值
    }

    // 通过 type 获取里面的字段
    for i := 0; i < InputType.NumField(); i++ {
        field := InputType.Field(i)
        value := InputValue.Field(i).Interface()
        fmt.Printf("%s: %v = %v\n", field.Name, field.Type, value)
    }

    fmt.Println("=======================")

    // 通过 type 获取里面的方法
    for i := 0; i < InputType.NumMethod(); i++ {
        m := InputType.Method(i)
        fmt.Printf("%s: %v\n", m.Name, m.Type)
    }
}

• InputType.Elem()：获取指针指向的实际类型。
• InputValue.Elem()：获取指针指向的实际值。
• InputType.NumField()：获取结构体的字段数量。
• InputType.Field(i)：获取第 i 个字段的信息。
• InputValue.Field(i).Interface()：获取第 i 个字段的值。
• InputType.NumMethod()：获取结构体的方法数量。
• InputType.Method(i)：获取第 i 个方法的信息。

4. 反射的注意事项

1. 指针类型的处理：

   • 如果 input 是指针类型，需要使用 InputType.Elem() 获取指针指向的实际类型。
   • 否则，NumField 和 Field 方法会报错。

2. 方法获取的限制：

   • 如果方法是指针接收者（例如 func (this *User) Call()），则必须传递指针给 reflect 包才能获取到方法。
   • 如果方法是值接收者（例如 func (this User) Call()），则可以传递值或指针。

3. 性能开销：

   • 反射操作比直接操作变量更慢，因此在性能敏感的场景中应谨慎使用。

结构体标签与 JSON 转换

在 Go 语言中，结构体标签是一种元数据，用于为结构体字段附加额外的信息。最常见的用途是 控制 JSON 编码和解码的行为。

1. 结构体标签的基本语法

结构体标签是写在结构体字段后面的字符串，用反引号（`）包裹。标签的格式通常是 key:"value"，多个键值对之间用空格分隔。

示例

type Movie struct {
    Title  string   `json:"title"`
    Year   int      `json:"year"`
    Price  int      `json:"rmb"`
    Actors []string `json:"actors"`
}

• json:"title"：表示在 JSON 编码和解码时，Title 字段对应的 JSON 键名为 "title"。
• json:"year"：表示在 JSON 编码和解码时，Year 字段对应的 JSON 键名为 "year"。
• json:"rmb"：表示在 JSON 编码和解码时，Price 字段对应的 JSON 键名为 "rmb"。
• json:"actors"：表示在 JSON 编码和解码时，Actors 字段对应的 JSON 键名为 "actors"。

2. JSON 编码（结构体 → JSON）

使用 encoding/json 包中的 json.Marshal 函数，可以将结构体编码为 JSON 字符串。

示例代码

movie := Movie{"喜剧之王", 2000, 10, []string{"xingye", "lucifer"}}
jsonStr, err := json.Marshal(movie)
if err != nil {
    fmt.Println("json marshal error", err)
    return
}
fmt.Printf("jsonStr = %s\n", jsonStr)

输出结果

jsonStr = {"title":"喜剧之王","year":2000,"rmb":10,"actors":["xingye","lucifer"]}

关键点

• json.Marshal 会根据结构体标签将字段名映射为 JSON 键名。
• 如果字段没有标签，默认使用字段名作为 JSON 键名。

3. JSON 解码（JSON → 结构体）

使用 encoding/json 包中的 json.Unmarshal 函数，可以将 JSON 字符串解码为结构体。

示例代码

myMovie := Movie{}
err = json.Unmarshal(jsonStr, &myMovie)
if err != nil {
    fmt.Println("json unmarshal error", err)
}
fmt.Printf("%v\n", myMovie)

输出结果

{喜剧之王 2000 10 [xingye lucifer]}

关键点

• json.Unmarshal 会根据结构体标签将 JSON 键名映射为结构体字段名。
• 如果 JSON 键名与结构体标签不匹配，该字段会被忽略。

4. 结构体标签的高级用法

忽略字段

如果希望某个字段在 JSON 编码时被忽略，可以使用 json:"-" 标签。

示例

type Movie struct {
    Title  string   `json:"title"`
    Year   int      `json:"year"`
    Price  int      `json:"-"`
    Actors []string `json:"actors"`
}

• Price 字段在 JSON 编码时会被忽略。

输出结果

jsonStr = {"title":"喜剧之王","year":2000,"actors":["xingye","lucifer"]}

空值处理

如果希望某个字段在 JSON 编码时忽略空值，可以使用 omitempty 选项。

示例

type Movie struct {
    Title  string   `json:"title"`
    Year   int      `json:"year,omitempty"`
    Price  int      `json:"rmb,omitempty"`
    Actors []string `json:"actors,omitempty"`
}

• 如果 Year、Price 或 Actors 字段为零值（如 0、nil），则在 JSON 编码时会被忽略。

输出结果

jsonStr = {"title":"喜剧之王"}

5. 完整代码示例

以下是结合结构体标签和 JSON 转换的完整代码：

package main

import (
    "encoding/json"
    "fmt"
)

// 结构体标签
type Movie struct {
    Title  string   `json:"title"`
    Year   int      `json:"year"`
    Price  int      `json:"rmb"`
    Actors []string `json:"actors"`
}

func main() {
    movie := Movie{"喜剧之王", 2000, 10, []string{"xingye", "lucifer"}}

    // 编码：结构体 ==> JSON
    jsonStr, err := json.Marshal(movie)
    if err != nil {
        fmt.Println("json marshal error", err)
        return
    }
    fmt.Printf("jsonStr = %s\n", jsonStr)

    // 解码：JSON ==> 结构体
    myMovie := Movie{}
    err = json.Unmarshal(jsonStr, &myMovie)
    if err != nil {
        fmt.Println("json unmarshal error", err)
    }
    fmt.Printf("%v\n", myMovie)
}

6. 运行结果

运行代码后，输出如下：

jsonStr = {"title":"喜剧之王","year":2000,"rmb":10,"actors":["xingye","lucifer"]}
{喜剧之王 2000 10 [xingye lucifer]}