一、Go基础知识17、接口详解

已于 2023-11-28 00:02:22 修改
阅读量882 收藏 21
点赞数 19
分类专栏： Go的小细节 文章标签： golang 开发语言 后端
于 2023-11-26 10:35:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49015143/article/details/134624172
版权

一、什么是鸭子类型

鸭子类型（Duck Typing）是动态类型语言中的一种风格，主张对象的适用性不是由它所属的类别或类型决定，而是由其实现的方法和属性决定。这个概念源自于“如果它像鸭子一样走路并且嘎嘎叫，那么它就是一只鸭子”。

在 Go 语言中，虽然没有像其他动态语言那样显式地支持鸭子类型，但其接口（interface）系统允许根据行为来确定类型的适用性。接口是一种抽象类型，由一组方法定义，而不是由具体的数据表示。如果一个对象实现了接口所定义的所有方法，那么它就被视为实现了该接口，即使它没有显式地声明它实现了该接口。

示例：

package main

import (
	"fmt"
)

// 定义一个接口
type Quacker interface {
	Quack() string
}

// 定义一个鸭子类型的结构体
type Duck struct{}

// Duck 结构体实现了 Quacker 接口的方法
func (d Duck) Quack() string {
	return "Quack! Quack!"
}

// 另一个结构体，同样实现了 Quacker 接口
type Person struct{}

// Person 结构体也实现了 Quacker 接口的方法
func (p Person) Quack() string {
	return "I'm quacking like a duck!"
}

func main() {
	// 使用 Duck 类型
	var duck Quacker
	duck = Duck{} // Duck 类型赋值给 Quacker 接口
	fmt.Println(duck.Quack()) // 输出：Quack! Quack!

	// 使用 Person 类型
	var person Quacker
	person = Person{} // Person 类型赋值给 Quacker 接口
	fmt.Println(person.Quack()) // 输出：I'm quacking like a duck!
}

解释：
在这个示例中，Duck 和 Person 结构体都实现了 Quacker 接口的 Quack() 方法。尽管它们是不同的结构体类型，但由于它们都实现了 Quacker 接口，可以将它们赋值给 Quacker 类型的变量，调用 Quack() 方法时都能正常工作。

这展示了在 Go 中，对象的类型不是通过它所属的结构体类型来决定的，而是通过其实现的接口方法来决定的，类似于鸭子类型的概念。

二、如何定义接口

在 Go 语言中，接口（Interface）是一种抽象类型，定义了一组方法的集合，但并不包含这些方法的实现细节。接口定义了对象应该具有的行为，而不关心对象是如何实现这些行为的。

1、定义接口

接口定义使用 type 关键字和 interface 关键字。

// 定义一个接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

解释：
这里定义了一个 Shape 接口，它包含了两个方法：Area() 和 Perimeter()。任何结构体只要实现了这两个方法，就被视为实现了 Shape 接口。

2、实现接口

要实现接口，结构体需要实现接口中定义的所有方法。

示例：

// 定义一个矩形结构体
type Rectangle struct {
    Width  float64
    Height float64
}

// Rectangle 结构体实现 Shape 接口的 Area 方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Rectangle 结构体实现 Shape 接口的 Perimeter 方法
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

解释：
Rectangle 结构体实现了 Shape 接口中定义的 Area() 和 Perimeter() 方法，因此它被视为实现了 Shape 接口。

3、使用接口

接口可以用作变量类型、函数参数或返回值类型。

示例：

func CalculateAreaAndPerimeter(s Shape) {
    area := s.Area()
    perimeter := s.Perimeter()
    fmt.Printf("Area: %f, Perimeter: %f\n", area, perimeter)
}

func main() {
    // 创建一个 Rectangle 结构体的实例
    rect := Rectangle{Width: 5, Height: 3}

    // 传递 Rectangle 结构体实例给函数 CalculateAreaAndPerimeter
    CalculateAreaAndPerimeter(rect)
}

解释：
在 main 函数中，我们创建了一个 Rectangle 结构体的实例，并将其传递给 CalculateAreaAndPerimeter 函数。因为 Rectangle 结构体实现了 Shape 接口的所有方法，所以它可以作为 Shape 类型的参数传递给函数。

4、完整示例

package main

import (
    "fmt"
)

// 定义一个接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

// 定义一个矩形结构体
type Rectangle struct {
    Width  float64
    Height float64
}

// Rectangle 结构体实现 Shape 接口的 Area 方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Rectangle 结构体实现 Shape 接口的 Perimeter 方法
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// 计算图形的面积和周长
func CalculateAreaAndPerimeter(s Shape) {
    area := s.Area()
    perimeter := s.Perimeter()
    fmt.Printf("Area: %f, Perimeter: %f\n", area, perimeter)
}

func main() {
    // 创建一个 Rectangle 结构体的实例
    rect := Rectangle{Width: 5, Height: 3}

    // 传递 Rectangle 结构体实例给函数 CalculateAreaAndPerimeter
    CalculateAreaAndPerimeter(rect)
}

解释：
以上示例演示了如何定义接口、实现接口方法，并使用接口作为函数参数。Rectangle 结构体实现了 Shape 接口，因此可以通过 Shape 接口来调用对应的方法。

三、多接口的实现

在 Go 语言中，一个类型可以实现多个接口，这被称为多接口实现。一个类型只要实现了某个接口规定的所有方法，就被认为实现了该接口，无论它是否同时实现了其他接口。

1、定义多个接口

示例：

// 定义 Shape 接口
type Shape interface {
    Area() float64
}

// 定义 Renderer 接口
type Renderer interface {
    Render() string
}

解释：
在这里，我们定义了两个接口：Shape 和 Renderer。Shape 接口规定了一个方法 Area()，而 Renderer 接口规定了一个方法 Render()。

2、实现多个接口

示例：

// 定义矩形结构体
type Rectangle struct {
    Width  float64
    Height float64
}

// Rectangle 结构体实现 Shape 接口的 Area 方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Rectangle 结构体实现 Renderer 接口的 Render 方法
func (r Rectangle) Render() string {
    return fmt.Sprintf("Rendering a rectangle with width %f and height %f", r.Width, r.Height)
}

解释：
在这里，Rectangle 结构体同时实现了 Shape 接口的 Area() 方法和 Renderer 接口的 Render() 方法。这展示了一个类型可以同时满足多个接口的要求。

3、使用多接口

示例：

// 函数接受一个实现了 Shape 接口和 Renderer 接口的类型
func DisplayInformation(s Shape, r Renderer) {
    area := s.Area()
    rendering := r.Render()

    fmt.Printf("Area: %f\n", area)
    fmt.Println(rendering)
}

解释：
这个函数 DisplayInformation 接受两个参数，分别是实现了 Shape 接口和 Renderer 接口的类型。这样的设计允许我们在函数中操作这两个接口的方法。

4、使用示例

func main() {
    // 创建一个 Rectangle 结构体的实例
    rect := Rectangle{Width: 5, Height: 3}

    // 调用 DisplayInformation 函数，传递 Rectangle 结构体实例
    DisplayInformation(rect, rect)
}

解释：
在 main 函数中，我们创建了一个 Rectangle 结构体的实例，并将其作为参数传递给 DisplayInformation 函数。由于 Rectangle 结构体实现了 Shape 和 Renderer 接口，因此它可以作为这两个接口的实例进行传递。

5、完整示例

package main

import (
    "fmt"
)

// 定义 Shape 接口
type Shape interface {
    Area() float64
}

// 定义 Renderer 接口
type Renderer interface {
    Render() string
}

// 定义矩形结构体
type Rectangle struct {
    Width  float64
    Height float64
}

// Rectangle 结构体实现 Shape 接口的 Area 方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Rectangle 结构体实现 Renderer 接口的 Render 方法
func (r Rectangle) Render() string {
    return fmt.Sprintf("Rendering a rectangle with width %f and height %f", r.Width, r.Height)
}

// 函数接受一个实现了 Shape 接口和 Renderer 接口的类型
func DisplayInformation(s Shape, r Renderer) {
    area := s.Area()
    rendering := r.Render()

    fmt.Printf("Area: %f\n", area)
    fmt.Println(rendering)
}

func main() {
    // 创建一个 Rectangle 结构体的实例
    rect := Rectangle{Width: 5, Height: 3}

    // 调用 DisplayInformation 函数，传递 Rectangle 结构体实例
    DisplayInformation(rect, rect)
}

解释：
这个示例演示了如何定义多个接口，一个类型同时实现多个接口，并在函数中使用多接口的实例。Rectangle 结构体实现了 Shape 和 Renderer 接口，可以在函数中同时使用这两个接口。

四、通过interface解决动态类型传参

在 Go 语言中，通过接口（interface）可以实现动态类型传参的机制。使用接口可以将具体类型的实现细节隐藏起来，使得函数能够接受不同类型的参数，只要它们实现了相同的接口。下面我将详细讲解如何通过接口解决动态类型传参，并提供一个示例来说明。

1、定义接口

首先，定义一个接口，该接口包含希望被传递对象必须实现的方法。

// 定义一个接口
type Printer interface {
    Print() string
}

这里我们定义了一个 Printer 接口，它规定了一个名为 Print() 的方法。

2、实现接口

创建不同类型的结构体，并让它们实现接口定义的方法。

// 实现接口的结构体1
type Dog struct {
    Name string
}

// Dog 结构体实现 Printer 接口的 Print 方法
func (d Dog) Print() string {
    return "Dog: " + d.Name
}

// 实现接口的结构体2
type Cat struct {
    Name string
}

// Cat 结构体实现 Printer 接口的 Print 方法
func (c Cat) Print() string {
    return "Cat: " + c.Name
}

在这里，Dog 和 Cat 结构体都实现了 Printer 接口的 Print() 方法。

3、使用接口作为参数

示例中该函数接受实现了接口的对象作为参数。

示例：

// 函数接受实现了 Printer 接口的对象作为参数
func PrintInformation(p Printer) {
    fmt.Println(p.Print())
}

解释：
这个函数 PrintInformation 接受实现了 Printer 接口的对象，并调用其 Print() 方法打印信息。

4、使用示例

func main() {
    // 创建 Dog 和 Cat 的实例
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}

    // 调用函数，传递不同类型的参数
    PrintInformation(dog) // 输出：Dog: Buddy
    PrintInformation(cat) // 输出：Cat: Whiskers
}

解释：
在 main 函数中，我们创建了 Dog 和 Cat 结构体的实例，并将它们作为参数传递给 PrintInformation 函数。由于它们都实现了 Printer 接口，所以可以作为参数传递给接受 Printer 接口的函数。

5、完整示例

package main

import (
    "fmt"
)

// 定义一个接口
type Printer interface {
    Print() string
}

// 实现接口的结构体1
type Dog struct {
    Name string
}

// Dog 结构体实现 Printer 接口的 Print 方法
func (d Dog) Print() string {
    return "Dog: " + d.Name
}

// 实现接口的结构体2
type Cat struct {
    Name string
}

// Cat 结构体实现 Printer 接口的 Print 方法
func (c Cat) Print() string {
    return "Cat: " + c.Name
}

// 函数接受实现了 Printer 接口的对象作为参数
func PrintInformation(p Printer) {
    fmt.Println(p.Print())
}

func main() {
    // 创建 Dog 和 Cat 的实例
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}

    // 调用函数，传递不同类型的参数
    PrintInformation(dog) // 输出：Dog: Buddy
    PrintInformation(cat) // 输出：Cat: Whiskers
}

解释：
这个示例演示了如何通过接口实现动态类型传参。函数 PrintInformation 可以接受实现了 Printer 接口的不同类型的对象，从而实现了动态类型传参的效果。

五、通过switch语句进行类型判断

在 Go 语言中，可以使用 switch 语句进行类型判断。switch 语句可以根据表达式的值或类型进行分支选择。

1、switch 语句进行类型判断

使用 switch 语句时，可以在 case 分支中使用 type 关键字来进行类型判断。

示例：

func getType(x interface{}) string {
    switch x := x.(type) {
    case int:
        return "Integer"
    case float64:
        return "Float"
    case string:
        return "String"
    default:
        return fmt.Sprintf("Unknown type %T", x)
    }
}

解释：
在这个例子中，函数 getType 接受一个空接口 interface{} 类型的参数 x，并使用 switch 语句根据其实际类型进行判断。

2、使用示例

func main() {
    // 测试不同类型的参数
    fmt.Println(getType(42))          // 输出：Integer
    fmt.Println(getType(3.14))        // 输出：Float
    fmt.Println(getType("Hello"))     // 输出：String
    fmt.Println(getType([]int{1, 2})) // 输出：Unknown type []int
}

解释：
在 main 函数中，我们调用了 getType 函数，并传递了不同类型的参数。根据传递的参数类型，switch 语句会匹配相应的 case 分支。

3、完整示例

package main

import (
    "fmt"
)

func getType(x interface{}) string {
    switch x := x.(type) {
    case int:
        return "Integer"
    case float64:
        return "Float"
    case string:
        return "String"
    default:
        return fmt.Sprintf("Unknown type %T", x)
    }
}

func main() {
    // 测试不同类型的参数
    fmt.Println(getType(42))          // 输出：Integer
    fmt.Println(getType(3.14))        // 输出：Float
    fmt.Println(getType("Hello"))     // 输出：String
    fmt.Println(getType([]int{1, 2})) // 输出：Unknown type []int
}

解释：
这个示例演示了如何使用 switch 语句进行类型判断。通过在 case 分支中使用 type 关键字，我们可以根据不同的类型执行相应的逻辑。在 main 函数中，通过调用 getType 函数测试了不同类型的参数。

六、接口嵌套

在 Go 语言中，接口嵌套是一种将一个接口嵌套到另一个接口的方式，通过这种方式，一个接口可以包含另一个接口的所有方法。接口嵌套可以帮助我们构建更复杂的接口，并且在实现这些接口时，只需要实现最底层的接口，即可满足所有嵌套的接口的要求。下面我将详细讲解接口嵌套，并提供一个示例来说明。

1、定义基础接口

首先，定义两个基础接口，分别为 Reader 和 Writer。

示例：

// 定义 Reader 接口
type Reader interface {
    Read() string
}

// 定义 Writer 接口
type Writer interface {
    Write(data string) bool
}

2、接口嵌套

现在，我们创建一个新的接口 ReadWriter，通过接口嵌套将 Reader 和 Writer 这两个接口包含在内。

示例：

// 定义 ReadWriter 接口，通过接口嵌套包含 Reader 和 Writer 接口
type ReadWriter interface {
    Reader
    Writer
}

这样，ReadWriter 接口就包含了 Reader 和 Writer 接口的所有方法。

3、结构体实现接口

接下来，我们创建一个结构体 MyFile 并实现 ReadWriter 接口的方法。

示例：

// 定义 MyFile 结构体
type MyFile struct {
    Content string
}

// MyFile 结构体实现 Read 方法
func (f MyFile) Read() string {
    return f.Content
}

// MyFile 结构体实现 Write 方法
func (f *MyFile) Write(data string) bool {
    f.Content = data
    return true
}

解释：
在这里，MyFile 结构体实现了 Read 方法和 Write 方法，分别满足了 Reader 和 Writer 接口的要求。

4、使用示例

func main() {
    // 创建 MyFile 结构体实例
    file := MyFile{Content: "Hello, Go!"}

    // 使用 ReadWriter 接口的方法
    result := file.Read()
    fmt.Println("Read:", result) // 输出：Read: Hello, Go!

    success := file.Write("New content")
    fmt.Println("Write success:", success) // 输出：Write success: true

    // 验证新内容是否写入成功
    result = file.Read()
    fmt.Println("Read after Write:", result) // 输出：Read after Write: New content
}

解释：
在 main 函数中，我们创建了一个 MyFile 结构体的实例，并通过 ReadWriter 接口的方法进行读取和写入操作。这样，我们可以看到通过接口嵌套，一个结构体可以同时实现多个相关接口的方法。

5、完整示例

package main

import (
    "fmt"
)

// 定义 Reader 接口
type Reader interface {
    Read() string
}

// 定义 Writer 接口
type Writer interface {
    Write(data string) bool
}

// 定义 ReadWriter 接口，通过接口嵌套包含 Reader 和 Writer 接口
type ReadWriter interface {
    Reader
    Writer
}

// 定义 MyFile 结构体
type MyFile struct {
    Content string
}

// MyFile 结构体实现 Read 方法
func (f MyFile) Read() string {
    return f.Content
}

// MyFile 结构体实现 Write 方法
func (f *MyFile) Write(data string) bool {
    f.Content = data
    return true
}

func main() {
    // 创建 MyFile 结构体实例
    file := MyFile{Content: "Hello, Go!"}

    // 使用 ReadWriter 接口的方法
    result := file.Read()
    fmt.Println("Read:", result) // 输出：Read: Hello, Go!

    success := file.Write("New content")
    fmt.Println("Write success:", success) // 输出：Write success: true

    // 验证新内容是否写入成功
    result = file.Read()
    fmt.Println("Read after Write:", result) // 输出：Read after Write: New content
}

解释：
这个示例演示了如何使用接口嵌套，通过一个结构体实现嵌套的接口的所有方法。通过这种方式，可以构建出更灵活且具有层次结构的接口体系。

七、接口遇到slice的常见错误

在 Go 语言中，使用接口和切片（slice）时可能会遇到一些常见的问题，尤其是在使用切片作为接口参数或在切片中存储实现了接口的对象时。

1、切片存储实现了接口的对象

示例：

type Printer interface {
    Print() string
}

type Dog struct {
    Name string
}

func (d Dog) Print() string {
    return "Dog: " + d.Name
}

func main() {
    dogs := []Printer{Dog{Name: "Buddy"}, Dog{Name: "Max"}}

    for _, dog := range dogs {
        fmt.Println(dog.Print())
    }
}

解释：
这段代码看起来似乎没有错误，但是它可能不会按预期工作。在 Go 中，切片中存储的是元素的拷贝，而不是元素的引用。因此，当将实现了接口的结构体放入切片时，存储的是接口类型的副本而不是实际的对象。

2、解决方法 - 使用指针

要解决上述问题，可以使用指针来存储实现了接口的对象。这样可以确保切片中存储的是对象的引用而不是副本。

示例：

type Printer interface {
    Print() string
}

type Dog struct {
    Name string
}

func (d Dog) Print() string {
    return "Dog: " + d.Name
}

func main() {
    dogs := []Printer{&Dog{Name: "Buddy"}, &Dog{Name: "Max"}}

    for _, dog := range dogs {
        fmt.Println(dog.Print())
    }
}

解释：
在这个例子中，dogs 切片存储了 Dog 结构体的指针，确保了在迭代时使用的是实际的对象而不是副本。

3、切片类型与接口

另一个常见的问题是，尝试将一个切片转换为实现了某个接口的类型。例如：

示例：

type Printer interface {
    Print() string
}

type Dog struct {
    Name string
}

func (d Dog) Print() string {
    return "Dog: " + d.Name
}

func main() {
    var dogs []Dog = []Dog{{Name: "Buddy"}, {Name: "Max"}}

    var printer Printer = dogs // 这行代码会报错
}

解释：
这样的代码会导致编译错误，因为无法将 []Dog 类型的切片直接赋值给 Printer 接口类型。

4、解决方法 - 逐个转换

要将切片转换为实现了接口的类型，需要逐个进行转换。

示例：

type Printer interface {
    Print() string
}

type Dog struct {
    Name string
}

func (d Dog) Print() string {
    return "Dog: " + d.Name
}

func main() {
    var dogs []Dog = []Dog{{Name: "Buddy"}, {Name: "Max"}}

    var printers []Printer
    for _, dog := range dogs {
        printers = append(printers, dog)
    }
}

解释：
这里，我们逐个遍历 dogs 切片，将每个元素转换为实现了 Printer 接口的类型，并将它们存储在 printers 切片中。

5、完整示例

package main

import (
    "fmt"
)

type Printer interface {
    Print() string
}

type Dog struct {
    Name string
}

func (d Dog) Print() string {
    return "Dog: " + d.Name
}

func main() {
    dogs := []*Dog{&Dog{Name: "Buddy"}, &Dog{Name: "Max"}}

    for _, dog := range dogs {
        fmt.Println(dog.Print())
    }

    var dogs2 []Dog = []Dog{{Name: "Buddy"}, {Name: "Max"}}

    var printers []Printer
    for _, dog := range dogs2 {
        printers = append(printers, dog)
    }
}

解释：
这个示例展示了两个问题和解决方法：切片存储实现了接口的对象时使用指针，并且切片类型与接口之间的转换时需要逐个进行转换。通过这些示例，你可以更好地理解在 Go 语言中使用切片和接口时可能遇到的常见问题。

风不归Alkaid
关注
专栏目录
Go语言基础语法与进阶技术详解
09-14
内容概要：本文档详细介绍了 Go 语言的基本语法与数据类型，涵盖了变量声明、条件判断、函数定义（包括多返回值）、包管理、类型转换等方面的知识点，并逐步深入至结构体、切片、映射表、接口、并发机制等进阶主题，...
图文详解go语言反射实现原理
12-20
在Go语言中，反射(reflection)是一个强大的工具，允许程序在运行时检查并操作其自身的结构和数据。本文将深入探讨Go语言反射的实现原理，尤其是与`interface`和`unsafe.Pointer`的关系。 首先，我们需要了解`...
Golang基础知识入门详解
qq_43842093的博客
10-23 1629
Go语言入门 Go语言入门教程 很多人将 Go 语言 称为 21 世纪的 C 语言，因为 Go 不仅拥有 C 语言的简洁和性能，而且还很好的提供了 21 世纪互联网环境下服务端开发的各种实用特性，让开发者在语言级别就可以方便的得到自己想要的东西。 在 Go 语言的版本迭代过程中，语言特性基本上没有太大的变化，基本上维持在 Go1.1 的基准上，并且官方承诺，新版本对老版本下开发的代码完全兼容。事实上，Go 开发团队在新增语言特性上显得非常谨慎，而在稳定性、编译速度、执行效率以及 GC 性能等方面进行了持续不
一、Go基础知识16、指针详解
风不归的乐园
11-26 854
GO：指针：定义与使用、初始化、swap交换值、nil的细节
一、Go基础知识14、函数详解以及错误处理详解
风不归的乐园
11-24 808
GO语言：函数：定义、可变参数、一等公民特性、闭包特性、defer、error详解、recover和panic详解
Go语言超全详解（入门级）
热门推荐
weixin_50941083的博客
07-14 14万+
Go语言是谷歌2009年发布的第二款开源编程语言（系统开发语言)，它是基于编译、垃圾收集和并发的编程语言。 Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美 C / C++代码的速度，而且更加安全、支持并行进程......
Golang中context包基础知识详解
路多辛的所思所想
05-02 645
前三种方法的相同点都是基于parent Context生成一个新的Context并返回一个CancelFunc方法，CancelFunc调用后，当前Context和基于新Context的子Context都会被取消。其他的Context都需要基于构造好的Context衍生出来，一个Context可以衍生多个子Context。WithValue方法可以生成一个绑定指定的键值对数据的Context，可以通过context.Value(Key) 获取指定key的值。
一、Go基础知识29、反射编程详解
风不归的乐园
11-30 1006
GO：反射编程：概述，reflect包简述、类型、函数，使用
Go基础学习05-切片基础知识详解
最新发布
FLJS_T的博客
09-25 587
本文系转载是对数组的一个连续片段的引用，所以切片是一个引用类型（因此更类似于 C/C++ 中的数组类型，或者 Python 中的 list 类型），这个片段可以是整个数组，也可以是由起始和终止索引标识的一些项的子集，需要注意的是，终止索引标识的项不包括在切片内。Go语言中切片的内部结构包含地址、大小和容量，切片一般用于快速地操作一块数据集合，如果将数据集合比作切糕的话，切片就是你要的“那一块”，切的过程包含从哪里开始（切片的起始位置）及切多大（切片的大小），容量可以理解为装切片的口袋大小，如下图所示。
一、Go基础知识23、面向对象编程详解
风不归的乐园
11-28 802
GO：面向对象编程，行为的定义与实现，相关接口，扩展与复用，不同接口类型的相同多态
Golang基础知识点整理
Mr_XiMu的博客
08-08 3963
Golang基础知识点整理
golang实战使用gin+xorm搭建go语言web框架详解.pdf
09-19
Gin是一个Web框架，是Go语言编写的，主要用于开发API服务，而Xorm是一个ORM库，用于简化数据库操作。我们将深入了解如何将Gin与Xorm结合起来，构建一个高效率的Web应用。 首先，我们需要了解Golang在面对一些开发...
详解Go 语言中的比较操作符
09-20
本文将围绕Go语言中的比较操作符进行详解，涵盖的六个操作符为：等于（==）、不等于（!=）、小于（<）、小于等于（）、大于（>）以及大于等于（>=）。 首先，Go语言的比较操作符支持多种数据类型，包括数值型、布尔...
go语言Map详解
gopher9511的博客
09-20 942
Go语言中提供的映射关系容器为map，其内部使用散列表（hash）实现map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。它提供了高效的查找、插入和删除操作，非常适合用于构建关联数组或字典。
golang cmd.exec 执行命令后报错 No such file or directory
weixin_42094764的博客
09-24 275
如果在你确定这个目录或者文件一定存在的情况下。这个问题有可能是因为exec执行的命令是管道操作或者重定向输出到文件导致的。
[译] Go语言的源起，发展和未来
techdashen的博客
09-20 1587
本篇内容是根据2019年9月份Creating the Go programming language音频录制内容的整理与翻译, 两位主持人与Go 的创始人 Rob Pike 和 Robert Griesemer谈论了 Go 的起源、发展、影响和未来。这是一个史诗般的剧集，深入探讨了 Go 的历史和详细信息，以及他们在创建这种出色的编程语言的过程中所做的选择。 访谈中有不少可能不为人知的小八卦: 例如new和make的初衷,Rsc其实是个"工程师二代"等. 一向金句频出的Rob Pike,还谈了对P
go解决引入私有包报错“Repository owner does not exist“的两种方式
qq_42750608的博客
09-23 469
go解决引入私有包报错"Repository owner does not exist"的两种方式
Fyne ( go跨平台GUI )中文文档- 数据绑定 (六)
bugtraq的博客
09-22 854
数据绑定是版本v2.0.0中引入的Fyne工具包的一个强大的新增功能。通过使用数据绑定，我们可以避免手动管理许多标准对象，如LabelButton和List。绑定支持许多原始类型（如IntString等Float）、列表（如StringListBoolList）以及Map和Struct绑定。这些类型中的每一种都可以使用简单的构造函数来创建。例如，要创建一个具有零值的新字符串绑定，您可以使用. 您可以使用Get和Set方法获取或设置数据绑定的值。
Go语言基础知识：关键字与编程规则详解
Go语言，也称为Golang，是由Google开发的一种静态类型、编译型、并发型且具有垃圾回收功能的编程语言。本资料详细阐述了Go语言的基础语法和核心概念，适合初学者入门及进阶学习。 首先，Go语言有25个关键字，包括`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

风不归Alkaid

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值