空接口

定義

空接口是特殊形式的接口類型，普通的接口都有方法，而空接口沒有定義任何方法口，也因此，我們可以說所有類型都至少實現(xiàn)了空接口。

type test interface {
}

每一個接口都包含兩個屬性，一個是值，一個是類型。

var i interface{}
fmt.Printf("類型：%T----值：%v\n", i, i) //類型：<nil>----值：<nil>

可見對于空接口來說，這兩者都是 nil

使用場景

第一，通常我們會直接使用 interface{} 作為類型聲明一個實例，而這個實例可以承載任意類型的值。

func main() {
	var i interface{}

	i = 100
	fmt.Println(i) //100

	i = "yif"
	fmt.Println(i) //yif

	i = 3.14
	fmt.Println(i) //3.14

	i = false
	fmt.Println(i) //false
}

第二，如果想讓你的函數(shù)可以接收任意類型的值 ，也可以使用空接口。如下代碼都正常打印：

func main() {
	i := 100
	s := "yif"
	f := 3.14

	test(i)
	test(s)
	test(f)
}

func test(i interface{}) {
	fmt.Println(i)
}

上面寫法有點麻煩，可以使用可變參數(shù)的函數(shù)。如下：

func main() {
	i := 100
	s := "yif"
	f := 3.14

	test(i, s, f)
}

func test(res ...interface{}) {
	fmt.Println(res) //res是切片
	for k, v := range res {
		fmt.Println(k, v)
	}
}

結(jié)果：

D:\workspace\go\src\test>go run main.go
[100 yif 3.14]
0 100
1 yif
2 3.14 

第三，你也定義一個可以接收任意類型的 array、slice、map、strcut，例如這邊定義一個切片

func main() {
	sli := make([]interface{}, 4)
	sli[0] = 100
	sli[1] = "yif"
	sli[2] = []int{1, 2, 3}
	sli[3] = [...]int{5, 6, 7}
	fmt.Println(sli)
	for k, v := range sli {
		fmt.Println(k, v)
	}
}

結(jié)果：

D:\workspace\go\src\test>go run main.go
[100 yif [1 2 3] [5 6 7]]
0 100
1 yif
2 [1 2 3]
3 [5 6 7] 

空接口幾個要注意的坑

**第一，**空接口可以承載任意值，但不代表任意類型就可以承接空接口類型的值

空接口類型可以保存任何值，也可以從空接口中取出原值。

但要是你把一個空接口類型的對象，再賦值給一個固定類型（比如 int, string等類型）的對象賦值，是會報錯的。

var i interface{} = 100
var t int = i // cannot use i (type interface {}) as type int in assignment: need type assertion

但是你使用短變量聲明，是可以的：

var i interface{} = 100
t := i
fmt.Println(t) //100

因為編譯器會根據(jù)等號右邊的值來推導(dǎo)變量的類型完成初始化。

**第二：**當(dāng)空接口承載數(shù)組和切片后，該對象無法再進(jìn)行切片

sli := []int{1, 2, 3, 4}
var i interface{}
i = sli
fmt.Println(i[1:2]) //cannot slice i (type interface {})

類型斷言

類型斷言（Type Assertion）是一個使用在接口值上的操作，用于檢查接口類型變量所持有的值是否實現(xiàn)了期望的接口或者具體的類型

類型斷言，僅能對靜態(tài)類型為空接口（interface{}）的對象進(jìn)行斷言，否則會拋出錯誤

Go語言中類型斷言的兩種語法

在Go語言中類型斷言的第一種語法格式如下：

t := i.(T)

這個表達(dá)式可以斷言一個接口對象（i）里不是 nil，并且接口對象（i）存儲的值的類型是 T，如果斷言成功，就會返回值給 t，如果斷言失敗，就會觸發(fā) panic。

func main() {
	var i interface{} = 100
	t := i.(int)
	fmt.Println(t) //100
	
	fmt.Println("------------------------------------")

	s := i.(string)
	fmt.Println(s)
}

結(jié)果【執(zhí)行第二次斷言的時候失敗了，并且觸發(fā)了 panic】：

D:\workspace\go\src\test>go run main.go
100
------------------------------------
panic: interface conversion: interface {} is int, not string

goroutine 1 [running]:
main.main()
        D:/workspace/go/src/test/main.go:32 +0x10e
exit status 2 

如果要斷言的接口值是 nil，那我們來看看也是不是也如預(yù)期一樣會觸發(fā)panic

var i interface{}
var _ = i.(interface{})

結(jié)果：

D:\workspace\go\src\test>go run main.go
panic: interface conversion: interface is nil, not interface {}

goroutine 1 [running]:
main.main()
        D:/workspace/go/src/test/main.go:27 +0x34
exit status 2 

在Go語言中類型斷言的另一種語法格式如下：

t, ok:= i.(T)

和上面一樣，這個表達(dá)式也是可以斷言一個接口對象（i）里不是 nil，并且接口對象（i）存儲的值的類型是 T，如果斷言成功，就會返回其類型給 t，并且此時 ok 的值 為 true，表示斷言成功。

如果接口值的類型，并不是我們所斷言的 T，就會斷言失敗，但和第一種表達(dá)式不同的事，這個不會觸發(fā) panic，而是將 ok 的值設(shè)為 false ，表示斷言失敗，此時t 為 T 的零值。

func main() {
    var i interface{} = 10
    t1, ok := i.(int)
    fmt.Printf("%d-%t\n", t1, ok)

    fmt.Println("=====分隔線1=====")

    t2, ok := i.(string)
    fmt.Printf("%s-%t\n", t2, ok)

    fmt.Println("=====分隔線2=====")

    var k interface{} // nil
    t3, ok := k.(interface{})
    fmt.Println(t3, "-", ok)

    fmt.Println("=====分隔線3=====")
    k = 10
    t4, ok := k.(interface{})
    fmt.Printf("%d-%t\n", t4, ok)

    t5, ok := k.(int)
    fmt.Printf("%d-%t\n", t5, ok)
}

結(jié)果【運行后輸出如下，可以發(fā)現(xiàn)在執(zhí)行第二次斷言的時候，雖然失敗了，但并沒有觸發(fā)了 panic】：

D:\workspace\go\src\test>go run main.go
10-true
=====分隔線1=====
-false
=====分隔線2=====
<nil> - false
=====分隔線3=====
10-true
10-true 

上面這段輸出，你要注意的是第二個斷言的輸出在-false 之前并不是有沒有輸出任何 t2 的值，而是由于斷言失敗，所以 t2 得到的是 string 的零值也是 "" ，它是零長度的，所以你看不到其輸出。

類型斷言配合 switch 使用

如果需要區(qū)分多種類型，可以使用 type switch 斷言。

func main() {
	test(100)
	test("yif")
	test(3.14)
	
	var i interface{} //nil
	test(i)
	
	test(nil)
}

func test(i interface{}) {
	switch r := i.(type) {
	case int:
		fmt.Println(r, "是int型")
	case string:
		fmt.Println(r, "是字符串")
	case nil:
		fmt.Println(r, "是nil")
	default:
		fmt.Println("沒有結(jié)果！")
	}
}

結(jié)果：

D:\workspace\go\src\test>go run main.go
100 是int型
yif 是字符串
沒有結(jié)果！
<nil> 是nil
<nil> 是nil

 到此這篇關(guān)于Golang空接口與類型斷言的實現(xiàn)的文章就介紹到這了,更多相關(guān)Golang空接口與類型斷言內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論