国产无码综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

<label id="vjnp1"><dfn id="vjnp1"><input id="vjnp1"></input></dfn></label>

<ruby id="vjnp1"></ruby>

go語言基本操作--四

2年前作者：小乞丐程序員分類：Toy博客閱讀(16)違法舉報

這篇具有很好參考價值的文章主要介紹了go語言基本操作--四。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

面向?qū)ο缶幊?/h3>
對于面向?qū)ο缶幊痰闹С謌o語言設(shè)計得非常簡潔而優(yōu)雅。因為，Go語言并沒有沿襲面向?qū)ο缶幊讨兄T多概念，比如繼承(不支持繼承，盡管匿名字段的內(nèi)存布局和行為類似繼承，但它并不是繼承)、虛函數(shù)、構(gòu)造函數(shù)和析構(gòu)函數(shù)、隱藏的this指針等.
盡管go語言中沒有封裝，繼承，多態(tài)這些概念，但同樣通過別的方式實現(xiàn)這些特性:
1:封裝:通過方法實現(xiàn)
2:繼承:通過匿名字段實現(xiàn)
3:多態(tài):通過接口實現(xiàn)

匿名字段作用—繼承

一般情況下，定義結(jié)構(gòu)體的時候是字段名與其類型一一對應，實際上go支持只提供類型，而不寫字段名的方式，也就是匿名字段，也稱為嵌入字段。
當匿名字段也是一個結(jié)構(gòu)體的時候，那么這個結(jié)構(gòu)體所擁有的全部字段都被隱式地引入了當前定義的這個結(jié)構(gòu)體。

//定義一個結(jié)構(gòu)體類型

type Person struct {
	name string //名字
	sex  byte   //性別
	age  int    //年齡
}

type Student struct {
	Person //只有類型 沒有名字，匿名字段,繼承了Person的成員
	id     int
	addr   string
}

匿名字段初始化

package main

import "fmt"

//定義一個結(jié)構(gòu)體類型

type Person struct {
	name string //名字
	sex  byte   //性別
	age  int    //年齡
}

type Student struct {
	Person //只有類型 沒有名字，匿名字段,繼承了Person的成員
	id     int
	addr   string
}

func main() {
	//順序初始化
	var s1 Student = Student{
		Person{"mike", 'm', 18},
		1,
		"bj",
	}
	fmt.Println("s1 = ", s1) //s1 =  {{mike 109 18} 1 bj}

	//自動推導類型
	s2 := Student{
		Person{"mike", 'm', 18},
		1,
		"bj",
	}
	fmt.Println("s2 = ", s2) //s2 =  {{mike 109 18} 1 bj}
	//%+v 顯示更詳細
	fmt.Printf("s2 = %+v\n", s2) //s2 = {Person:{name:mike sex:109 age:18} id:1 addr:bj}

	//指定成員初始化，沒有初始化的常用自動賦值為0
	s3 := Student{id: 1}
	fmt.Printf("s3 = %+v\n", s3) //s3 = {Person:{name: sex:0 age:0} id:1 addr:}

	s4 := Student{Person: Person{name: "mike"}, id: 1}
	fmt.Printf("s4 = %+v\n", s4) //s4 = {Person:{name:mike sex:0 age:0} id:1 addr:}
}

成員的操作

package main

import "fmt"

//定義一個結(jié)構(gòu)體類型

type Person struct {
	name string //名字
	sex  byte   //性別 字符類型
	age  int    //年齡
}

type Student struct {
	Person //只有類型 沒有名字，匿名字段,繼承了Person的成員
	id     int
	addr   string
}

func main() {
	//自動推導類型
	s1 := Student{Person{"mike", 'm', 18}, 1, "bj"}

	fmt.Println(s1.name, s1.sex, s1.id, s1.addr, s1.age) //mike 109 1 bj 18
	s1.name = "yoyo"                                     //等價于s1.Person.name = "mike"
	s1.sex = 'f'
	s1.age = 22
	s1.id = 666
	s1.addr = "wh"
	fmt.Println(s1.name, s1.sex, s1.id, s1.addr, s1.age) //yoyo 102 666 wh 22
	s1.Person = Person{"go", 'm', 23}
	fmt.Println(s1.name, s1.sex, s1.id, s1.addr, s1.age) //go 109 666 wh 23
}

同名字段

package main

import "fmt"

//定義一個結(jié)構(gòu)體類型

type Person struct {
	name string //名字
	sex  byte   //性別 字符類型
	age  int    //年齡
}

type Student struct {
	Person //只有類型 沒有名字，匿名字段,繼承了Person的成員
	id     int
	addr   string
	name   string //和Person同名了
}

func main() {
	//聲明(定義一個變量)
	var s Student
	//默認規(guī)則(就近原則),如果能在本作用域找到此成員，就操作此成員
	//如果沒有找到，找到繼承的字段
	s.name = "mike" //操作的是Student的name
	s.sex = 'm'
	s.age = 18
	s.addr = "bj"
	fmt.Printf("s = %+v\n", s) //s = {Person:{name: sex:109 age:18} id:0 addr:bj name:mike}

	//顯示調(diào)用
	s.Person.name = "yoyo"
	fmt.Printf("s = %+v\n", s) //s = {Person:{name:yoyo sex:109 age:18} id:0 addr:bj name:mike}
}

非結(jié)構(gòu)體匿名字段

package main

import "fmt"

//定義一個結(jié)構(gòu)體類型

type mystr string //自定義類型，給一個類型改名

type Person struct {
	name string //名字
	sex  byte   //性別 字符類型
	age  int    //年齡
}

type Student struct {
	Person //只有類型 沒有名字，匿名字段,繼承了Person的成員
	int    //基礎(chǔ)類型的匿名字段
	mystr  //基礎(chǔ)類型的匿名字段
}

func main() {
	s := Student{Person{"mike", 'm', 18}, 666, "hehehe"}
	fmt.Printf("s = %+v\n", s) //s = {Person:{name:mike sex:109 age:18} int:666 mystr:hehehe}

	fmt.Println(s.name, s.age, s.sex, s.int, s.mystr) //mike 18 109 666 hehehe
	fmt.Println(s.Person, s.int, s.mystr)             //{mike 109 18} 666 hehehe

	s.Person = Person{"go", 'm', 22}
	fmt.Println(s.Person, s.int, s.mystr)             //{go 109 22} 666 hehehe
	fmt.Println(s.name, s.age, s.sex, s.int, s.mystr) //go 22 109 666 hehehe
}

結(jié)構(gòu)體指針類型匿名字段

package main

import "fmt"

//定義一個結(jié)構(gòu)體類型

type mystr string //自定義類型，給一個類型改名

type Person struct {
	name string //名字
	sex  byte   //性別 字符類型
	age  int    //年齡
}

type Student struct {
	*Person //指針類型
	id      int
	addr    string
}

func main() {
	s1 := Student{&Person{"mike", 'm', 18}, 1, "wh"}
	fmt.Println("s1 = ", s1)                             //s1 =  {0xc00008e380 1 wh}
	fmt.Println(s1.name, s1.sex, s1.age, s1.id, s1.addr) //mike 109 18 1 wh

	//先定義變量
	var s2 Student
	s2.Person = new(Person) //分配空間
	s2.name = "yoyo"
	s2.sex = 'm'
	s2.age = 19
	s2.id = 2
	s2.addr = "wh"
	fmt.Println("s2 = ", s2)                             //s2 =  {0xc000054400 2 wh}
	fmt.Println(s2.name, s2.sex, s2.age, s2.id, s2.addr) //yoyo 109 19 2 wh
}

方法介紹—封裝

在面向?qū)ο缶幊讨?，一個對象其實也就是一個簡單的值或者一個變量，在這個對象中會包含一些函數(shù)，這種帶有接收者的函數(shù)，我們稱為方法。本質(zhì)上，一個方法則是一個和特殊關(guān)聯(lián)的函數(shù)。
一個面向?qū)ο蟮某绦驎梅椒▉肀磉_其屬性和對應的操作，這樣使用這個對象的用戶就不需要直接去操作對象，而是借助方法來做這種事情。
在Go語言中，可以任意自定義類型(包括內(nèi)置類型，但不包括指針類型)添加相應的方法。
方法總是綁定對象實例，并隱式將實例作為第一實參(receiver)，方法的語法如下:
func （receiver ReceiverType） funcName(parameters)(results)
1：參數(shù)receiver可任意命名.如方法中未曾使用，可以省略參數(shù).
2: 參數(shù)receiver類型可以是T或*T。基類型T不能是接口或者指針。
3：不支持重載方法，也就是說，不能定義名字相同但是不同參數(shù)的方法。

面向過程和面向?qū)ο蠛瘮?shù)區(qū)別

package main

import "fmt"

// 實現(xiàn)2數(shù)相加
// 面向過程
func Add01(a, b int) int {
	return a + b
}

// 面向?qū)ο?，方?給某個類型綁定一個函數(shù)
type long int //改名

// tmp叫接收者，接收者就是傳遞的一個參數(shù)
func (tmp long) Add02(other long) long {
	return tmp + other
}

func main() {

	result := Add01(1, 1)            //普通函數(shù)調(diào)用方式
	fmt.Println("result = ", result) //result = 2

	//定義一個變量
	var a long = 2

	//調(diào)用方法格式
	add1 := a.Add02(3)
	fmt.Println("result = ", add1) //result =  5

	//面向?qū)ο笾皇菗Q了一種表現(xiàn)形式
}

結(jié)構(gòu)體類型添加方法

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

//帶有接收者的函數(shù)叫方法

func (tmp Person) PrintInfo() {
	fmt.Println("tmp = ", tmp)
}

// 通過一個函數(shù)，給成員賦值
func (p *Person) SetInfo(name string, sex byte, age int) {
	p.name = name
	p.sex = sex
	p.age = age
}
func main() {
	//定義同時初始化
	p := Person{"mike", 'm', 18}
	p.PrintInfo() //tmp =  {mike 109 18}

	//定義一個結(jié)構(gòu)體變量
	var p2 Person

	(&p2).SetInfo("yoyo", 'm', 19)
	p2.PrintInfo() //tmp =  {yoyo 109 19}
}

type pointer *int
//pointer 為接收者類型，它本身不能是指針類型
func (tmp pointer) test(){} //error invalid receiver type pointer

//不支持重載，只要接收者類型不一樣，這個方法就算同名，也是不同方法，不會出現(xiàn)重復定義函數(shù)的錯誤

func (tmp Person) PrintInfo() {
	fmt.Println("tmp = ", tmp)
}

type char byte

func (tmp char) PrintInfo() {

}

值語義和引用語義

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

// 接收者為普通變量，非指針，值語義，一份拷貝
func (p Person) SetInfoValue(name string, sex byte, age int) {
	p.name = name
	p.sex = sex
	p.age = age
	fmt.Println("SetInfoValue p = ", p)      //SetInfoValue p =  {mike 109 19}
	fmt.Printf("SetInfoValue &p = %p\n", &p) //SetInfoValue &p = 0xc00008e3c0
}

// 接收者為指針變量，引用傳遞
func (p *Person) SetInfoPoubter(name string, sex byte, age int) {
	p.name = name
	p.sex = sex
	p.age = age
	fmt.Printf("SetInfoPoubter p = %p\n", &p) //SetInfoPoubter p = 0xc00008e380
	fmt.Println("SetInfoPoubter &p = ", *p)   //SetInfoPoubter &p =  {mike 109 19}
}
func main() {

	s1 := Person{"go", 'm', 18}

	fmt.Printf("&s1 = %p\n", &s1) //&s1 = 0xc00008e380
	//值語義
	s1.SetInfoValue("mike", 'm', 19)
	fmt.Println("s1 = ", s1) //s1 =  {go 109 18}

	//引用語義
	(&s1).SetInfoPoubter("mike", 'm', 19)
	fmt.Println("s1 = ", s1) //s1 =  {mike 109 19}
}

指針類型和普通類型的方法集

指針類型的方法集

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

// 接收者為普通變量，非指針，值語義，一份拷貝
func (p Person) SetInfoValue() {
	fmt.Println("SetInfoValue")
}

// 接收者為指針變量，引用傳遞
func (p *Person) SetInfoPoubter() {
	fmt.Println("SetInfoPoubter")
}
func main() {
	//假如，結(jié)構(gòu)體是一個指針變量，它能夠調(diào)用那些方法,這些方法就是一個集合，簡稱方法集
	p := &Person{"mike", 'm', 18}

	p.SetInfoPoubter()

	(*p).SetInfoPoubter() //把(*p)轉(zhuǎn)換成p調(diào)用，等價于上面

	//內(nèi)部做的轉(zhuǎn)換，先把指針p，轉(zhuǎn)成*p后再調(diào)用
	//(*p).SetInfoValue()
	p.SetInfoValue()
}

普通類型的方法集

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

// 接收者為普通變量，非指針，值語義，一份拷貝
func (p Person) SetInfoValue() {
	fmt.Println("SetInfoValue")
}

// 接收者為指針變量，引用傳遞
func (p *Person) SetInfoPoubter() {
	fmt.Println("SetInfoPoubter")
}
func main() {

	p := Person{"mike", 'm', 18}

	p.SetInfoPoubter() //內(nèi)部會先把p轉(zhuǎn)化為&p再調(diào)用(&p).SetInfoPoubter()

	p.SetInfoValue()
}

方法的繼承

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

// Person類型，實現(xiàn)一個方法
func (tmp *Person) PrintInfo() {
	//PrintInfo: name = mike,sex = m, age = 18
	fmt.Printf("PrintInfo: name = %s,sex = %c, age = %d\n", tmp.name, tmp.sex, tmp.age)
}

// 有一個學生，繼承Person字段，成員和方法都繼承了
type Student struct {
	Person //匿名字段
	id     int
	addr   string
}

func main() {
	s := Student{Person{"mike", 'm', 18}, 666, "bj"}
	s.PrintInfo()
}

方法的重寫

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

// PrintInfo Person類型，實現(xiàn)一個方法
func (tmp *Person) PrintInfo() {
	//PrintInfo: name = mike,sex = m, age = 18
	fmt.Printf("PrintInfo: name = %s,sex = %c, age = %d\n", tmp.name, tmp.sex, tmp.age)
}

// PrintInfo Student也實現(xiàn)了一個方法，這個方法和Person方法重名，這個方法叫重寫
func (tmp *Student) PrintInfo() {
	//PrintInfo: name = mike,sex = m, age = 18
	fmt.Println("Student: tmp = ", tmp)   //Student: tmp =  &{{mike 109 18} 666 bj}
	fmt.Println("Student: *tmp = ", *tmp) //Student: *tmp =  {{mike 109 18} 666 bj}
}

// Student 有一個學生，繼承Person字段，成員和方法都繼承了
type Student struct {
	Person //匿名字段
	id     int
	addr   string
}

func main() {
	s := Student{Person{"mike", 'm', 18}, 666, "bj"}
	//就近原則:先找本作用域的方法，找不到再用繼承的方法
	s.PrintInfo() //這樣會調(diào)用Student的

	//顯示調(diào)用繼承的方法
	s.Person.PrintInfo() //PrintInfo: name = mike,sex = m, age = 18
}

方法值

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

func (p Person) SetInfoValue() {
	fmt.Printf("SetInfoValue: %p,%v\n", &p, p)
}

func (p *Person) SetInfoPointer() {
	fmt.Printf("SetInfoPointer %p, %v\n", p, *p) //SetInfoPointer 0xc00008e380, {mike 109 18}
}

func main() {

	p := Person{"mike", 'm', 18}
	fmt.Printf("main: %p,%v\n", &p, p) //main: 0xc00008e380,{mike 109 18}

	p.SetInfoPointer() //傳統(tǒng)調(diào)用方式

	//保存方式入口地址
	pFunc := p.SetInfoPointer //這個就是方法值，調(diào)用函數(shù)時，無需再傳遞接收者，隱藏了接收者
	pFunc()                   //等價于p.SetInfoPointer() SetInfoPointer 0xc00008e380, {mike 109 18}

	vFunc := p.SetInfoValue
	vFunc() //等價于p.SetInfoValue() SetInfoValue: 0xc000054440,{mike 109 18} 值傳遞
}

方法表達式

package main

import "fmt"

type Person struct {
	name string
	sex  byte
	age  int
}

func (p Person) SetInfoValue() {
	fmt.Printf("SetInfoValue: %p,%v\n", &p, p)
}

func (p *Person) SetInfoPointer() {
	fmt.Printf("SetInfoPointer %p, %v\n", p, *p) //SetInfoPointer 0xc00008e380, {mike 109 18}
}

func main() {

	p := Person{"mike", 'm', 18}
	fmt.Printf("main: %p,%v\n", &p, p) //main: 0xc00008e380,{mike 109 18}

	p.SetInfoPointer() //傳統(tǒng)調(diào)用方式

	//方法值，f := p.SetInfoPointer//隱藏了接收者

	//方法表達式
	f := (*Person).SetInfoPointer
	fmt.Println("=========")
	f(&p) //顯示把接收者傳遞過去 ---->p.SetInfoPointer() SetInfoPointer 0xc0000543a0, {mike 109 18}

	f2 := (Person).SetInfoValue
	f2(p) //SetInfoValue: 0xc000054440,{mike 109 18}
}

接口類型介紹

在go語言，接口是一個自定義類型，接口類型具體描述了一系列方法的集合。
接口類型時一種抽象的類型，它不會暴露出它所代表的對象的內(nèi)部值的結(jié)構(gòu)和這個對象支持的基礎(chǔ)操作的集合，它們只會展示出它們自己的方法。因此接口類型不能將其實例化。
接口定義:
1:接口命令習慣以er結(jié)尾
2:接口只有方法聲明，沒有實現(xiàn)，沒有數(shù)據(jù)字段
3:接口可以匿名嵌入其他接口，或嵌入到結(jié)構(gòu)中

接口的定義和實現(xiàn)

package main

import "fmt"

// Humaner 定義接口類型
type Humaner interface {
	//方法，只有聲明，沒有實現(xiàn),由別的類型(自定義類型)實現(xiàn)
	sayhi()
}

type Student struct {
	name string
	id   int
}

// Student實現(xiàn)了此方法
func (tmp *Student) sayhi() {
	fmt.Printf("Student[%s, %d] sayhi\n", tmp.name, tmp.id)

}

type Teacher struct {
	addr  string
	group string
}

// Teacher實現(xiàn)了此方法
func (tmp *Teacher) sayhi() {
	fmt.Printf("Teacher[%s, %s] sayhi\n", tmp.addr, tmp.group)

}

type MyStr string

// MyStr實現(xiàn)了此方法
func (tmp *MyStr) sayhi() {
	fmt.Printf("MyStr[%s] sayhi\n", *tmp)
}

type MyStr1 string

func (tmp MyStr1) sayhi() {
	fmt.Printf("MyStr1[%s] sayhi\n", tmp)
}

func main() {
	//定義接口類型的變量
	var i Humaner

	//只要實現(xiàn)了此接口方法的類型,那么這個類型的變量(接收者類型)就可以給i賦值
	s := &Student{"mike", 666}
	i = s
	i.sayhi() //Student[mike, 666] sayhi

	t := &Teacher{"wh", "go"}
	i = t
	i.sayhi() //Teacher[wh, go] sayhi

	var str MyStr = "hello cheng"
	i = &str
	i.sayhi() //MyStr[hello cheng] sayhi

	var str1 MyStr1 = "hello"
	i = str1
	i.sayhi() //MyStr1[hello] sayhi
}

多態(tài)的表現(xiàn)

package main

import "fmt"

// Humaner 定義接口類型
type Humaner interface {
	//方法，只有聲明，沒有實現(xiàn),由別的類型(自定義類型)實現(xiàn)
	sayhi()
}

type Student struct {
	name string
	id   int
}

// Student實現(xiàn)了此方法
func (tmp *Student) sayhi() {
	fmt.Printf("Student[%s, %d] sayhi\n", tmp.name, tmp.id)

}

type Teacher struct {
	addr  string
	group string
}

// Teacher實現(xiàn)了此方法
func (tmp *Teacher) sayhi() {
	fmt.Printf("Teacher[%s, %s] sayhi\n", tmp.addr, tmp.group)

}

type MyStr string

// MyStr實現(xiàn)了此方法
func (tmp *MyStr) sayhi() {
	fmt.Printf("MyStr[%s] sayhi\n", *tmp)
}

type MyStr1 string

func (tmp MyStr1) sayhi() {
	fmt.Printf("MyStr1[%s] sayhi\n", tmp)
}

// 定義一個普通函數(shù)，函數(shù)的參數(shù)為接口類型
// 只有一個函數(shù)，可以有不同表現(xiàn)，多態(tài)
func WhoSayHi(i Humaner) {
	i.sayhi()
}

func main() {

	s := &Student{"mike", 666}
	t := &Teacher{"wh", "go"}
	var str MyStr = "hello cheng"
	var str1 MyStr1 = "hello"
	//調(diào)用同一函數(shù)，不同表現(xiàn)，多態(tài)，多種形態(tài)
	WhoSayHi(s)
	WhoSayHi(t)
	WhoSayHi(&str)
	WhoSayHi(str1)

	//創(chuàng)建一個切片
	x := make([]Humaner, 4)
	x[0] = s
	x[1] = t
	x[2] = &str
	x[3] = str1

	//第一個返回下標，第二個返回鞋標所對應的值
	for _, data := range x {
		fmt.Println("===========")
		WhoSayHi(data)
	}
}

接口繼承—(接口嵌入)

如果一個interface1作為interface2的一個嵌入字段，那么interface2隱式地包含了interface1里面的方法。

package main

import "fmt"

// Humaner 定義接口類型
type Humaner interface { //子集
	//方法，只有聲明，沒有實現(xiàn),由別的類型(自定義類型)實現(xiàn)
	sayhi()
}

type Personer interface { //超集
	Humaner //匿名字段，繼承了sayhi()

	sing(lrc string)
}

type Student struct {
	name string
	id   int
}

// Student實現(xiàn)了此方法
func (tmp *Student) sayhi() {
	fmt.Printf("Student[%s, %d] sayhi\n", tmp.name, tmp.id)

}

func (tmp *Student) sing(lrc string) {
	fmt.Println("Student在唱著:", lrc)
}

func main() {

	//定義一個接口類型的變量
	var i Personer
	s := &Student{"mike", 666}
	i = s
	i.sayhi()    //繼承過來的方法 //Student[mike, 666] sayhi
	i.sing("三月") //Student在唱著: 三月
}

接口轉(zhuǎn)換

package main

import "fmt"

// Humaner 定義接口類型
type Humaner interface { //子集
	//方法，只有聲明，沒有實現(xiàn),由別的類型(自定義類型)實現(xiàn)
	sayhi()
}

type Personer interface { //超集
	Humaner //匿名字段，繼承了sayhi()

	sing(lrc string)
}

type Student struct {
	name string
	id   int
}

// Student實現(xiàn)了此方法
func (tmp *Student) sayhi() {
	fmt.Printf("Student[%s, %d] sayhi\n", tmp.name, tmp.id)

}

func (tmp *Student) sing(lrc string) {
	fmt.Println("Student在唱著:", lrc)
}

func main() {

	//超集可以轉(zhuǎn)換為子集，反過來不可以
	var iPro Personer //超集

	iPro = &Student{"mike", 666}
	var i Humaner //子集
	//cannot use i (variable of type Humaner) as Personer value in assignment:
	//Humaner does not implement Personer (missing method sing)
	//iPro = i //error

	i = iPro //OK 超集可以轉(zhuǎn)換為子集
	i.sayhi()
}

空接口

空接口不包含任何的方法，正因為如此，所有的類型都實現(xiàn)了空接口，因此空接口可以存儲任意類型，它有點類似于C語言的void*類型。
go語言基本操作--四,golang,開發(fā)語言,后端

package main

import "fmt"

func xxx(args ...interface{}) {
	
}

func main() {
	//空接口萬能類型，保存任意類型的值

	var i interface{} = 1
	fmt.Println("i = ", i)

	i = "abc"
	fmt.Println("i = ", i)
}

通過if實現(xiàn)類型斷言

go語言基本操作--四,golang,開發(fā)語言,后端文章來源地址http://www.zghlxwxcb.cn/news/detail-696055.html

package main

import "fmt"

type Student struct {
	name string
	id   int
}

func main() {

	i := make([]interface{}, 3)

	i[0] = 1                    //int
	i[1] = "hello go"           //string
	i[2] = Student{"mike", 666} //Student

	//類型查詢，類型斷言
	//第一個返回下標，第二個返回下標對應的值，data是i[0],i[1],i[2]
	for index, data := range i {
		//第一個返回值，接口變量本身，第二個返回判斷結(jié)果的真假
		if value, ok := data.(int); ok == true {
			fmt.Printf("x[%d] 類型為int，內(nèi)容為%d\n", index, value) //x[0] 類型為int，內(nèi)容為1
			fmt.Println("int data = ", data)                 //int data =  1
			fmt.Println("------------------")
		} else if value, ok := data.(string); ok == true {
			fmt.Printf("x[%d] 類型為string, 內(nèi)容為%s\n", index, value) //x[1] 類型為string, 內(nèi)容為hello go
			fmt.Println("string data = ", data)                  //string data =  hello go
			fmt.Println("------------------")
		} else if value, ok := data.(Student); ok == true {
			fmt.Printf("x[%d] 類型為Student, 內(nèi)容為name = %s, id = %d\n", index, value.name, value.id) //x[2] 類型為Student, 內(nèi)容為name = mike, id = 666
			fmt.Println("Student data = ", data)                                                 //Student data =  {mike 666}
			fmt.Println("------------------")
		}
	}
}

通過switch實現(xiàn)類型斷言

package main

import "fmt"

type Student struct {
	name string
	id   int
}

func main() {

	i := make([]interface{}, 3)

	i[0] = 1                    //int
	i[1] = "hello go"           //string
	i[2] = Student{"mike", 666} //Student

	//類型查詢，類型斷言
	//第一個返回下標，第二個返回下標對應的值，data是i[0],i[1],i[2]
	for index, data := range i {
		switch value := data.(type) { //type參數(shù)類型
		case int:
			fmt.Printf("x[%d] 類型為int，內(nèi)容為%d\n", index, value) //x[0] 類型為int，內(nèi)容為1
			fmt.Println("int data = ", data)                 //int data =  1
			fmt.Println("------------------")
		case string:
			fmt.Printf("x[%d] 類型為string, 內(nèi)容為%s\n", index, value) //x[1] 類型為string, 內(nèi)容為hello go
			fmt.Println("string data = ", data)                  //string data =  hello go
			fmt.Println("------------------")
		case Student:
			fmt.Printf("x[%d] 類型為Student, 內(nèi)容為name = %s, id = %d\n", index, value.name, value.id) //x[2] 類型為Student, 內(nèi)容為name = mike, id = 666
			fmt.Println("Student data = ", data)                                                 //Student data =  {mike 666}
			fmt.Println("------------------")
		}
	}
}

到了這里，關(guān)于go語言基本操作--四的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！

本文來自互聯(lián)網(wǎng)用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務(wù)，不擁有所有權(quán)，不承擔相關(guān)法律責任。如若轉(zhuǎn)載，請注明出處：如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經(jīng)查實，立即刪除！

分享到：

領(lǐng)支付寶紅包贊助服務(wù)器費用

R語言——基本操作（一）
目錄一、基本操作二、R包的安裝及使用三、獲取幫助四、內(nèi)置數(shù)據(jù)集五、數(shù)據(jù)結(jié)構(gòu) 六、向量索引七、向量運算參考 Rstudio?控制臺常用快捷鍵 Ctrl + ↑ ：查看所有歷史記錄，比直接使用 ↑ 查找更方便 Esc：中斷操作，可中斷未完成的操作（未完成回車后是 + ），也可以
2024年04月15日
瀏覽(14)
鏈表的基本操作（c語言）
目錄鏈式存儲結(jié)構(gòu) 代碼實現(xiàn) 鏈表初始化頭插法(前插法)創(chuàng)建含k個結(jié)點的單鏈表尾插法(后插法)創(chuàng)建含k個結(jié)點的單鏈表取第i個節(jié)點的數(shù)據(jù)域尋找數(shù)據(jù)域等于e的結(jié)點返回該結(jié)點序號在第i個結(jié)點插入數(shù)據(jù)域為e的結(jié)點刪除第i個結(jié)點遍歷鏈表求鏈表結(jié)點個數(shù)(鏈表長度）銷毀
2024年02月08日
瀏覽(18)
【Golang】認識Go語言中基本的數(shù)據(jù)類型
目錄整形基本整型? 特殊整型浮點型布爾型字符型字符串轉(zhuǎn)義符? 多行字符串字符串的常用操作復數(shù) 我們不論在學習什么語言中，我們都要去認識一下這個語言中的數(shù)據(jù)類型，當然學習Go也不例外，我們也要去認識一下其相關(guān)的數(shù)據(jù)類型，當然這些數(shù)據(jù)類型基本上是大
2023年04月08日
瀏覽(24)
C語言實現(xiàn)鏈表基本操作
目錄一、什么是鏈表二、為什么要使用鏈表三、鏈表相關(guān)知識四、鏈表實現(xiàn) 1.定義結(jié)構(gòu)體 2.創(chuàng)建鏈表 3.遍歷鏈表 4.判斷鏈表是否為空 5.計算鏈表長度 6.插入一個數(shù)據(jù) 7.刪除數(shù)據(jù) 8.全部代碼如果把數(shù)據(jù)比喻成珠子，指針就是線，鏈表通過指針這條線就是把數(shù)據(jù)這些珠子串起
2024年02月06日
瀏覽(21)
順序表基本操作算法——基礎(chǔ)代碼（C語言）
?創(chuàng)建一個順序表（數(shù)據(jù)元素個數(shù)為5），輸出順序表中的所有數(shù)據(jù)元素查找第3個位置上的元素查找元素15是否在順序表中，如果在，請輸出該元素在順序表中的位置在順序表中的第1個位置插入數(shù)據(jù)0 刪除剛剛插入的元素輸出順序表中的所有數(shù)據(jù)元素運行結(jié)果如下 ?
2024年02月06日
瀏覽(17)
C語言第十一課--------操作符的使用與分類-------基本操作
? ? ? ? ?作者介紹： ? ? ? ? ? 作者id ：老秦包你會，簡單介紹： ? ? ? ? ? ? ?喜歡學習C語言和python等編程語言，是一位愛分享的博主，有興趣的小可愛可以來互討 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 個人主頁::小小頁面 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? gitee頁面
2024年02月14日
瀏覽(24)
【數(shù)據(jù)結(jié)構(gòu)】鏈棧的基本操作（C語言）
零零總總搜索了一些關(guān)于鏈棧的資料，了解了鏈棧的基本操作，一直覺得別人寫的代碼或多或少存在一些問題，所以打算自己寫一篇關(guān)于鏈棧的文章，也算是對所學知識的梳理和鞏固了。首先說明本文使用C語言進行鏈棧的基本操作，鏈棧是無頭結(jié)點的。這里補充說明一下，
2024年02月05日
瀏覽(26)
【數(shù)據(jù)結(jié)構(gòu)】隊列基本操作的實現(xiàn)（C語言）
?? 作者簡介：一名在后端領(lǐng)域?qū)W習，并渴望能夠?qū)W有所成的追夢人。 ?? 個人主頁：蝸牛牛啊 ?? 系列專欄：??數(shù)據(jù)結(jié)構(gòu)、??C++ ?? 學習格言：博觀而約取，厚積而薄發(fā) ?? 歡迎進來的小伙伴，如果小伙伴們在學習的過程中，發(fā)現(xiàn)有需要糾正的地方，煩請指正，希望能夠與
2024年02月16日
瀏覽(22)
【數(shù)據(jù)結(jié)構(gòu)】順序表基本操作的實現(xiàn)（C語言）
?? 作者簡介：一名在后端領(lǐng)域?qū)W習，并渴望能夠?qū)W有所成的追夢人。 ?? 個人主頁：蝸牛牛啊 ?? 系列專欄：??數(shù)據(jù)結(jié)構(gòu)、??C++ ?? 學習格言：博觀而約取，厚積而薄發(fā) ?? 歡迎進來的小伙伴，如果小伙伴們在學習的過程中，發(fā)現(xiàn)有需要糾正的地方，煩請指正，希望能夠與
2024年02月16日
瀏覽(25)
單鏈表的基本操作代碼實現(xiàn)(C語言版)
目錄前言：單鏈表的基本操作準備工作（頭文件、各種宏定義以及結(jié)構(gòu)體定義）一.較簡單操作 1.單鏈表的初始化 2.判斷單鏈表是否為空表 3.單鏈表的銷毀 4.單鏈表的清空 5.求單鏈表的表長二.較重要操作 1.單鏈表的取值 2.單鏈表元素的查找 3.單鏈表的結(jié)點插入 4.單鏈表的結(jié)
2024年04月11日
瀏覽(21)