Golang Go语言中菜鸟请教 interface 的使用

发布于 1周前 作者 nodeper 来自 Go语言

有 2 个 struct A B,分别有自己的 New 方法 NewA()，NewB()，并且已经实现了 interface C ｛ Scan （）｝ 想通过命令行传参，在 main 方法使用的时候选择实例化 A or B 并且执行 scan()

run.go A

目前的写法是用 switch 判断，感觉不太对头，有优雅的写法吗？

switch svc {
case "A":
  a := NewA()
  go func(c C) {
    c.Scan()
  }(a)
case "B":
  b := NewB()
  go func(c C) {
    c.Scan()
  }(b)
}

Golang Go语言中菜鸟请教 interface 的使用

更多关于Golang Go语言中菜鸟请教 interface 的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html

Harmonyos Next教程
5 回复

package main

import (
“fmt”
)

type C interface {
Scan()
}

type A struct{}

func NewA() *A {
return &A{}
}

func (a *A) Scan() {
fmt.Println(“A Scan”)
}

type B struct{}

func NewB() *B {
return &B{}
}

func (b *B) Scan() {
fmt.Println(“B Scan”)
}

// 工厂函数，返回不同的类型
func NewInstance(svc string) (C, error) {
switch svc {
case “A”:
return NewA(), nil
case “B”:
return NewB(), nil
default:
return nil, fmt.Errorf(“invalid service: %s”, svc)
}
}

func main() {
svc := “A” // 可以通过命令行参数获取 svc

// 通过工厂函数选择实例化对象
c, err := NewInstance(svc)
if err != nil {
fmt.Println(“Error:”, err)
return
}

// 启动并执行 Scan()
go func(c C) {
c.Scan()
}©

// 阻塞，避免主程序提前退出
select {}
}

说明：
NewInstance(svc string)：通过传入的 svc 字符串来决定实例化 A 或 B ，返回 C 类型接口。
在 main 函数中，通过 NewInstance 获取具体的实例并执行 Scan() 方法。
使用 go 协程来异步执行 Scan() 方法。
通过 select{} 保证主程序不会提前退出。
这样做的好处：

通过工厂模式将实例化逻辑集中管理，避免了 switch 语句的重复使用。
如果以后需要添加更多的服务，只需在 NewInstance 函数中增加对应的 case ，而不需要修改 main 函数的核心逻辑，增加了可扩展性。
这种写法比直接使用 switch 更加优雅、清晰，并且具有更好的可扩展性。

更多关于Golang Go语言中菜鸟请教 interface 的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


虽然是 gpt 的，也感谢你
我发现根本错的地方是我的 New 方法返回了 A ，所以 main 里面实例化的 a,b 类型错了
应该返回 C 才对
func NewA() C

手动撸了个,你也可以改为 struct 方式

go<br>type CmdFunc func(args)<br>const cmds = map[string]CmdFunc{<br>"A":A,<br>"B":B,<br>}<br>func A(args){<br><br>}<br>func B(args){<br><br>}<br>func main(){<br> if(len(os.args)&lt;=2){<br> //err exit<br> }<br> cmd:=os.args(1)<br> fun,ok:=cmds[cmd]<br> if ok {<br> fun(os.args)<br> }<br>}<br>

也可以写一个容器，注册不同的类型，例如 A,B 。
传参就到容器中获取。
本质是一个 map 存取。

在Go语言中，interface 是一个非常强大且灵活的特性，它定义了一组方法签名，而不包含具体的实现。这对于编写泛型代码和进行依赖注入非常有用。作为初学者，理解interface的使用可以从以下几个方面入手：

  1. 定义interface： 使用type关键字定义一个interface，并在其中声明一系列方法。例如：

    type Animal interface {
    Speak() string
}

  2. 实现interface： 任何类型只要实现了interface中声明的所有方法，就隐式地实现了该interface。无需显式声明。

    type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

  3. 使用interface： 可以将实现了某个interface的类型赋值给该interface类型的变量。

    func main() {
    var a Animal
    a = Dog{}
    fmt.Println(a.Speak()) // 输出: Woof!
}

  4. 多态性： interface使得函数可以接受不同类型的参数，只要这些类型实现了相应的interface。这大大增强了代码的灵活性和可扩展性。

  5. 空interface： interface{}是一个空interface，它表示任意类型。这在处理未知类型的数据时非常有用。

希望这些解释能帮助你更好地理解Go语言中的interface。如果有更具体的问题或代码示例需要分析，请随时提问！

回到顶部