Golang接口用法回顾与实践分享：https://play.golang.org/p/RKezV69HjPe

Golang接口用法回顾与实践分享：https://play.golang.org/p/RKezV69HjPe https://play.golang.org/p/RKezV69HjPe

switch h.(type)

在复习这段关于接口的教学代码时，我还需要重新学习switch语句。
以下代码被作为"对值进行switch判断"的示例：

https://play.golang.org/p/KllsXGiuWTv
在这段代码中，n是值吗？

switch h.(type)

那么这里的h就是值吗？

这个"."符号有什么重要意义？
(type)是参数吗？
它指的是什么？

回到 https://play.golang.org/p/RKezV69HjPe

以下所有代码：

func main() {
	sa1 := secretAgent{
		person: person{
			"James",
			"Bond",
		},
		ltk: true,
	}

	sa2 := secretAgent{
		person: person{
			"Miss",
			"Moneypenny",
		},
		ltk: true,
	}

	p1 := person{
		first: "Dr.",
		last:  "Yes",
	}

	fmt.Println(sa1)
	sa1.speak()
	sa2.speak()

	fmt.Println(p1)

	bar(sa1)
	bar(sa2)
	bar(p1)

	// conversion
	var x hotdog = 42
	fmt.Println(x)
	fmt.Printf("%T\n", x)
	var y int
	y = int(x)
	fmt.Println(y)
	fmt.Printf("%T\n", y)

}

是在定义func main()吗？


更多关于Golang接口用法回顾与实践分享：https://play.golang.org/p/RKezV69HjPe的实战教程也可以访问 https://www.itying.com/category-94-b0.html

5 回复

谢谢

更多关于Golang接口用法回顾与实践分享：https://play.golang.org/p/RKezV69HjPe的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


cherilexvold1974:

以下所有代码：

func main() {
	sa1 := secretAgent{
		person: person{
			"James",
			"Bond",
		},
		ltk: true,
	}

	sa2 := secretAgent{
		person: person{
			"Miss",
			"Moneypenny",
		},
		ltk: true,
	}

	p1 := person{
		first: "Dr.",
		last:  "Yes",
	}

	fmt.Println(sa1)
	sa1.speak()
	sa2.speak()

	fmt.Println(p1)

	bar(sa1)
	bar(sa2)
	bar(p1)

	// conversion
	var x hotdog = 42
	fmt.Println(x)
	fmt.Printf("%T\n", x)
	var y int
	y = int(x)
	fmt.Println(y)
	fmt.Printf("%T\n", y)

}

定义了 func main() 吗？

是的。

Switch 是一个简单的 switch 语句，而另一个问题中的 . 是类型断言。

规则1：h 必须是接口类型，因为类型断言需要接口。当你调用 h.(type) 时，你试图获取接口值的底层具体类型。

假设你从函数获取一个接口值： h:=getBirthDay() 你想知道这个函数返回的是字符串格式的生日还是时间格式的生日。

switch bd.(type) {
case time.Time:
	birthDay = bd.(time.Time)
case string:
	t, _ := time.Parse(timeLayout, bd.(string))
	birthDay = t
default:
	fmt.Printf("unexpected time: %T\n", bd)
}

h.(type) 是一个特殊情况，只能在 switch 语句中使用。 编译器不允许你这样写： t := h.(type) on a line without switch

该语法的另一个用途是具体类型检查或类型断言：

var timeLayout = "2006-01-02"
	h := getBirthDay()
	var birthDay time.Time
	if v, ok := h.(time.Time); ok {
		fmt.Println("it is Time. let''s set birthDay")
		birthDay = v
	} else if v, ok := h.(string); ok {
		fmt.Println("it is string let's parse it")
		birthDay, _ = time.Parse(timeLayout, v)
	} else {
		fmt.Println("upps something is wrong")
		return
	}
	fmt.Println(birthDay.Format(timeLayout))

cherilexvold1974:

switch h.(type)

这是用于根据变量数据类型进行分支判断的语法。变量是 h，而 .(type) 是一个获取 h 数据类型的指令。因此：

	switch h.(type) {
	case person:
		fmt.Println("I was passed into barrrrrr", h.(person).first)
	case secretAgent:
		fmt.Println("I was passed into barrrrrr", h.(secretAgent).first)
	}

这段代码允许你在变量 h 持有 person 数据类型或 secretAgent 数据类型时进行分支处理。这两者都是结构体类型。

cherilexvold1974:

Is (type) a parameter?

type 表示数据类型，例如 int、int8、int16、int32、string、byte、[]byte 等。

hollowaykeanho:

Does all the following:

func main() {

sa1 := secretAgent{
	person: person{
		"James",
		"Bond",
	},
	ltk: true,
}

sa2 := secretAgent{
	person: person{
		"Miss",
		"Moneypenny",
	},
	ltk: true,
}

p1 := person{
	first: "Dr.",
	last:  "Yes",
}

fmt.Println(sa1)
sa1.speak()
sa2.speak()

fmt.Println(p1)

bar(sa1)
bar(sa2)
bar(p1)

// conversion
var x hotdog = 42
fmt.Println(x)
fmt.Printf("%T\n", x)
var y int
y = int(x)
fmt.Println(y)
fmt.Printf("%T\n", y)

}

define func main() ?

Yes.

在Go语言中，switch h.(type) 是类型断言的语法，用于在运行时检查接口变量 h 的动态类型。下面详细解释你的问题：

  1. h 是值吗？

    • 是的，h 是一个接口类型的变量，它持有具体的值和类型信息。在类型断言中，h 是被检查的接口值。

  2. . 符号的意义：

    • . 是Go语言中的点操作符，在这里用于类型断言语法。它分隔接口变量和 type 关键字。

  3. (type) 是参数吗？它指什么？

    • (type) 不是参数，而是类型断言语法中的固定关键字，专门用于 switch 语句中检查接口的动态类型。它告诉编译器我们要对接口变量的实际类型进行分支判断。

  4. 关于 func main()：

    • 是的，你提供的代码是在定义 main 函数，它是Go程序的入口点。

示例代码演示类型断言的用法：

package main

import "fmt"

type Speaker interface {
    Speak()
}

type Person struct {
    Name string
}

func (p Person) Speak() {
    fmt.Println("Hello, I'm", p.Name)
}

type Animal struct {
    Sound string
}

func (a Animal) Speak() {
    fmt.Println("Animal sound:", a.Sound)
}

func checkType(s Speaker) {
    switch v := s.(type) {
    case Person:
        fmt.Printf("It's a Person: %s\n", v.Name)
    case Animal:
        fmt.Printf("It's an Animal: %s\n", v.Sound)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    p := Person{Name: "Alice"}
    a := Animal{Sound: "Woof"}
    
    checkType(p)  // 输出: It's a Person: Alice
    checkType(a)  // 输出: It's an Animal: Woof
}

在你的原始代码中，bar 函数很可能使用了类似的类型断言来检查传入接口参数的实际类型。类型断言允许你在运行时基于接口变量的实际类型执行不同的逻辑。

回到顶部