Go語言基礎之結構體

時間  2021-08-12
標籤 html python 面試 編程 json 數據結構 app 編程語言 ide 函數 欄目 HTML 简体版
原文   原文鏈接


目錄html

  • 1、類型別名和自定義類型
  • 2、自定義類型
  • 3、類型別名
  • 4、類型定義和類型別名的區別
  • 5、結構體
  • 6、結構體的定義
  • 7、結構體實例化
    • 7.1 基本實例化
    • 7.2 匿名結構體
    • 7.3 建立指針類型結構體
    • 7.4 取結構體的地址實例化
  • 8、結構體初始化
    • 8.1 使用鍵值對初始化
    • 8.2 使用值的列表初始化
  • 9、結構體內存佈局
  • 10、面試題
  • 11、構造函數
  • 12、方法和接收者
    • 12.1 指針類型的接收者
    • 12.2 值類型的接收者
    • 12.3 何時應該使用指針類型接收者
  • 十3、任意類型添加方法
  • 十4、結構體的匿名字段
  • 十5、嵌套結構體
    • 15.1 嵌套匿名結構體
    • 15.2 嵌套結構體的字段名衝突
  • 十6、結構體的「繼承」
  • 十7、結構體字段的可見性
  • 十8、結構體與JSON序列化
  • 十9、結構體標籤（Tag）
  • 二10、練習題


更新、更全的《Go從入門到放棄》的更新網站，更有python、go、人工智能教學等着你：https://www.cnblogs.com/nickchen121/p/11517502.htmlpython


Go語言中沒有「類」的概念，也不支持「類」的繼承等面向對象的概念。Go語言中經過結構體的內嵌再配合接口比面向對象具備更高的擴展性和靈活性。面試

1、類型別名和自定義類型2、自定義類型

在Go語言中有一些基本的數據類型，如string、整型、浮點型、布爾等數據類型， Go語言中可使用type關鍵字來定義自定義類型。編程

自定義類型是定義了一個全新的類型。咱們能夠基於內置的基本類型定義，也能夠經過struct定義。例如：json

//將MyInt定義爲int類型
type MyInt int

經過Type關鍵字的定義，MyInt就是一種新的類型，它具備int的特性。數據結構

3、類型別名

類型別名是Go1.9版本添加的新功能。app

類型別名規定：TypeAlias只是Type的別名，本質上TypeAlias與Type是同一個類型。就像一個孩子小時候有小名、乳名，上學後用學名，英語老師又會給他起英文名，但這些名字都指的是他本人。編程語言

type TypeAlias = Type

咱們以前見過的rune和byte就是類型別名，他們的定義以下：ide

type byte = uint8
type rune = int32
4、類型定義和類型別名的區別

類型別名與類型定義表面上看只有一個等號的差別，咱們經過下面的這段代碼來理解它們之間的區別。函數

//類型定義
type NewInt int

//類型別名
type MyInt = int

func main() {
	var a NewInt
	var b MyInt
	
	fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
	fmt.Printf("type of b:%T\n", b) //type of b:int
}

結果顯示a的類型是main.NewInt，表示main包下定義的NewInt類型。b的類型是int。MyInt類型只會在代碼中存在，編譯完成時並不會有MyInt類型。

5、結構體

Go語言中的基礎數據類型能夠表示一些事物的基本屬性，可是當咱們想表達一個事物的所有或部分屬性時，這時候再用單一的基本數據類型明顯就沒法知足需求了，Go語言提供了一種自定義數據類型，能夠封裝多個基本數據類型，這種數據類型叫結構體，英文名稱struct。 也就是咱們能夠經過struct來定義本身的類型了。

Go語言中經過struct來實現面向對象。

6、結構體的定義

使用type和struct關鍵字來定義結構體，具體代碼格式以下：

type 類型名 struct {
    字段名 字段類型
    字段名 字段類型
    …
}

其中：

  • 類型名：標識自定義結構體的名稱，在同一個包內不能重複。
  • 字段名：表示結構體字段名。結構體中的字段名必須惟一。
  • 字段類型：表示結構體字段的具體類型。

舉個例子，咱們定義一個Person（人）結構體，代碼以下：

type person struct {
	name string
	city string
	age  int8
}

一樣類型的字段也能夠寫在一行，

type person1 struct {
	name, city string
	age        int8
}

這樣咱們就擁有了一個person的自定義類型，它有name、city、age三個字段，分別表示姓名、城市和年齡。這樣咱們使用這個person結構體就可以很方便的在程序中表示和存儲人信息了。

語言內置的基礎數據類型是用來描述一個值的，而結構體是用來描述一組值的。好比一我的有名字、年齡和居住城市等，本質上是一種聚合型的數據類型

7、結構體實例化

只有當結構體實例化時，纔會真正地分配內存。也就是必須實例化後才能使用結構體的字段。

結構體自己也是一種類型，咱們能夠像聲明內置類型同樣使用var關鍵字聲明結構體類型。

var 結構體實例 結構體類型

7.1 基本實例化

舉個例子：

type person struct {
	name string
	city string
	age  int8
}

func main() {
	var p1 person
	p1.name = "沙河娜扎"
	p1.city = "北京"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)  //p1={沙河娜扎 北京 18}
	fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"沙河娜扎", city:"北京", age:18}
}

咱們經過.來訪問結構體的字段（成員變量）,例如p1.name和p1.age等。

7.2 匿名結構體

在定義一些臨時數據結構等場景下還可使用匿名結構體。

package main
     
import (
    "fmt"
)
     
func main() {
    var user struct{Name string; Age int}
    user.Name = "小王子"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

7.3 建立指針類型結構體

咱們還能夠經過使用new關鍵字對結構體進行實例化，獲得的是結構體的地址。 格式以下：

var p2 = new(person)
fmt.Printf("%T\n", p2)     //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

從打印的結果中咱們能夠看出p2是一個結構體指針。

須要注意的是在Go語言中支持對結構體指針直接使用.來訪問結構體的成員。

var p2 = new(person)
p2.name = "小王子"
p2.age = 28
p2.city = "上海"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王子", city:"上海", age:28}

7.4 取結構體的地址實例化

使用&對結構體進行取地址操做至關於對該結構體類型進行了一次new實例化操做。

p3 := &person{}
fmt.Printf("%T\n", p3)     //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "七米"
p3.age = 30
p3.city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"七米", city:"成都", age:30}

p3.name = "七米"其實在底層是(*p3).name = "七米"，這是Go語言幫咱們實現的語法糖。

8、結構體初始化

沒有初始化的結構體，其成員變量都是對應其類型的零值。

type person struct {
	name string
	city string
	age  int8
}

func main() {
	var p4 person
	fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}
}

8.1 使用鍵值對初始化

使用鍵值對對結構體進行初始化時，鍵對應結構體的字段，值對應該字段的初始值。

p5 := person{
	name: "小王子",
	city: "北京",
	age:  18,
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"小王子", city:"北京", age:18}

也能夠對結構體指針進行鍵值對初始化，例如：

p6 := &person{
	name: "小王子",
	city: "北京",
	age:  18,
}
fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"小王子", city:"北京", age:18}

當某些字段沒有初始值的時候，該字段能夠不寫。此時，沒有指定初始值的字段的值就是該字段類型的零值。

p7 := &person{
	city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}

8.2 使用值的列表初始化

初始化結構體的時候能夠簡寫，也就是初始化的時候不寫鍵，直接寫值：

p8 := &person{
	"沙河娜扎",
	"北京",
	28,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"沙河娜扎", city:"北京", age:28}

使用這種格式初始化時，須要注意：

  1. 必須初始化結構體的全部字段。
  2. 初始值的填充順序必須與字段在結構體中的聲明順序一致。
  3. 該方式不能和鍵值初始化方式混用。
9、結構體內存佈局

結構體佔用一塊連續的內存。

type test struct {
	a int8
	b int8
	c int8
	d int8
}
n := test{
	1, 2, 3, 4,
}
fmt.Printf("n.a %p\n", &n.a)
fmt.Printf("n.b %p\n", &n.b)
fmt.Printf("n.c %p\n", &n.c)
fmt.Printf("n.d %p\n", &n.d)

輸出：

n.a 0xc0000a0060
n.b 0xc0000a0061
n.c 0xc0000a0062
n.d 0xc0000a0063

【進階知識點】關於Go語言中的內存對齊推薦閱讀:在 Go 中恰到好處的內存對齊

10、面試題

請問下面代碼的執行結果是什麼？

type student struct {
	name string
	age  int
}

func main() {
	m := make(map[string]*student)
	stus := []student{
		{name: "小王子", age: 18},
		{name: "娜扎", age: 23},
		{name: "大王八", age: 9000},
	}

	for _, stu := range stus {
		m[stu.name] = &stu
	}
	for k, v := range m {
		fmt.Println(k, "=>", v.name)
	}
}
11、構造函數

Go語言的結構體沒有構造函數，咱們能夠本身實現。 例如，下方的代碼就實現了一個person的構造函數。 由於struct是值類型，若是結構體比較複雜的話，值拷貝性能開銷會比較大，因此該構造函數返回的是結構體指針類型。

func newPerson(name, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}

調用構造函數

p9 := newPerson("張三", "沙河", 90)
fmt.Printf("%#v\n", p9) //&main.person{name:"張三", city:"沙河", age:90}
12、方法和接收者

Go語言中的方法（Method）是一種做用於特定類型變量的函數。這種特定類型變量叫作接收者（Receiver）。接收者的概念就相似於其餘語言中的this或者 self。

方法的定義格式以下：

func (接收者變量 接收者類型) 方法名(參數列表) (返回參數) {
    函數體
}

其中，

  • 接收者變量：接收者中的參數變量名在命名時，官方建議使用接收者類型名的第一個小寫字母，而不是self、this之類的命名。例如，Person類型的接收者變量應該命名爲 p，Connector類型的接收者變量應該命名爲c等。
  • 接收者類型：接收者類型和參數相似，能夠是指針類型和非指針類型。
  • 方法名、參數列表、返回參數：具體格式與函數定義相同。

舉個例子：

//Person 結構體
type Person struct {
	name string
	age  int8
}

//NewPerson 構造函數
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

//Dream Person作夢的方法
func (p Person) Dream() {
	fmt.Printf("%s的夢想是學好Go語言！\n", p.name)
}

func main() {
	p1 := NewPerson("小王子", 25)
	p1.Dream()
}

方法與函數的區別是，函數不屬於任何類型，方法屬於特定的類型。

12.1 指針類型的接收者

指針類型的接收者由一個結構體的指針組成，因爲指針的特性，調用方法時修改接收者指針的任意成員變量，在方法結束後，修改都是有效的。這種方式就十分接近於其餘語言中面向對象中的this或者self。 例如咱們爲Person添加一個SetAge方法，來修改實例變量的年齡。

// SetAge 設置p的年齡
// 使用指針接收者
func (p *Person) SetAge(newAge int8) {
	p.age = newAge
}

調用該方法：

func main() {
	p1 := NewPerson("小王子", 25)
	fmt.Println(p1.age) // 25
	p1.SetAge(30)
	fmt.Println(p1.age) // 30
}

12.2 值類型的接收者

當方法做用於值類型接收者時，Go語言會在代碼運行時將接收者的值複製一份。在值類型接收者的方法中能夠獲取接收者的成員值，但修改操做只是針對副本，沒法修改接收者變量自己。

// SetAge2 設置p的年齡
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
	p.age = newAge
}

func main() {
	p1 := NewPerson("小王子", 25)
	p1.Dream()
	fmt.Println(p1.age) // 25
	p1.SetAge2(30) // (*p1).SetAge2(30)
	fmt.Println(p1.age) // 25
}

12.3 何時應該使用指針類型接收者

  1. 須要修改接收者中的值
  2. 接收者是拷貝代價比較大的大對象
  3. 保證一致性，若是有某個方法使用了指針接收者，那麼其餘的方法也應該使用指針接收者。
十3、任意類型添加方法

在Go語言中，接收者的類型能夠是任何類型，不只僅是結構體，任何類型均可以擁有方法。 舉個例子，咱們基於內置的int類型使用type關鍵字能夠定義新的自定義類型，而後爲咱們的自定義類型添加方法。

//MyInt 將int定義爲自定義MyInt類型
type MyInt int

//SayHello 爲MyInt添加一個SayHello的方法
func (m MyInt) SayHello() {
	fmt.Println("Hello, 我是一個int。")
}
func main() {
	var m1 MyInt
	m1.SayHello() //Hello, 我是一個int。
	m1 = 100
	fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

注意事項：非本地類型不能定義方法，也就是說咱們不能給別的包的類型定義方法。

十4、結構體的匿名字段

結構體容許其成員字段在聲明時沒有字段名而只有類型，這種沒有名字的字段就稱爲匿名字段。

//Person 結構體Person類型
type Person struct {
	string
	int
}

func main() {
	p1 := Person{
		"小王子",
		18,
	}
	fmt.Printf("%#v\n", p1)        //main.Person{string:"北京", int:18}
	fmt.Println(p1.string, p1.int) //北京 18
}

匿名字段默認採用類型名做爲字段名，結構體要求字段名稱必須惟一，所以一個結構體中同種類型的匿名字段只能有一個。

十5、嵌套結構體

一個結構體中能夠嵌套包含另外一個結構體或結構體指針。

//Address 地址結構體
type Address struct {
	Province string
	City     string
}

//User 用戶結構體
type User struct {
	Name    string
	Gender  string
	Address Address
}

func main() {
	user1 := User{
		Name:   "小王子",
		Gender: "男",
		Address: Address{
			Province: "山東",
			City:     "威海",
		},
	}
	fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

15.1 嵌套匿名結構體

//Address 地址結構體
type Address struct {
	Province string
	City     string
}

//User 用戶結構體
type User struct {
	Name    string
	Gender  string
	Address //匿名結構體
}

func main() {
	var user2 User
	user2.Name = "小王子"
	user2.Gender = "男"
	user2.Address.Province = "山東"    //經過匿名結構體.字段名訪問
	user2.City = "威海"                //直接訪問匿名結構體的字段名
	fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

當訪問結構體成員時會先在結構體中查找該字段，找不到再去匿名結構體中查找。

15.2 嵌套結構體的字段名衝突

嵌套結構體內部可能存在相同的字段名。這個時候爲了不歧義須要指定具體的內嵌結構體的字段。

//Address 地址結構體
type Address struct {
	Province   string
	City       string
	CreateTime string
}

//Email 郵箱結構體
type Email struct {
	Account    string
	CreateTime string
}

//User 用戶結構體
type User struct {
	Name   string
	Gender string
	Address
	Email
}

func main() {
	var user3 User
	user3.Name = "沙河娜扎"
	user3.Gender = "男"
	// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
	user3.Address.CreateTime = "2000" //指定Address結構體中的CreateTime
	user3.Email.CreateTime = "2000"   //指定Email結構體中的CreateTime
}
十6、結構體的「繼承」

Go語言中使用結構體也能夠實現其餘編程語言中面向對象的繼承。

//Animal 動物
type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Printf("%s會動！\n", a.name)
}

//Dog 狗
type Dog struct {
	Feet    int8
	*Animal //經過嵌套匿名結構體實現繼承
}

func (d *Dog) wang() {
	fmt.Printf("%s會汪汪汪~\n", d.name)
}

func main() {
	d1 := &Dog{
		Feet: 4,
		Animal: &Animal{ //注意嵌套的是結構體指針
			name: "樂樂",
		},
	}
	d1.wang() //樂樂會汪汪汪~
	d1.move() //樂樂會動！
}
十7、結構體字段的可見性

結構體中字段大寫開頭表示可公開訪問，小寫表示私有（僅在定義當前結構體的包中可訪問）。

十8、結構體與JSON序列化

JSON(JavaScript Object Notation) 是一種輕量級的數據交換格式。易於人閱讀和編寫。同時也易於機器解析和生成。JSON鍵值對是用來保存JS對象的一種方式，鍵/值對組合中的鍵名寫在前面並用雙引號""包裹，使用冒號:分隔，而後緊接着值；多個鍵值之間使用英文,分隔。

//Student 學生
type Student struct {
	ID     int
	Gender string
	Name   string
}

//Class 班級
type Class struct {
	Title    string
	Students []*Student
}

func main() {
	c := &Class{
		Title:    "101",
		Students: make([]*Student, 0, 200),
	}
	for i := 0; i < 10; i++ {
		stu := &Student{
			Name:   fmt.Sprintf("stu%02d", i),
			Gender: "男",
			ID:     i,
		}
		c.Students = append(c.Students, stu)
	}
	//JSON序列化：結構體-->JSON格式的字符串
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed")
		return
	}
	fmt.Printf("json:%s\n", data)
	//JSON反序列化：JSON格式的字符串-->結構體
	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}
十9、結構體標籤（Tag）

Tag是結構體的元信息，能夠在運行的時候經過反射的機制讀取出來。Tag在結構體字段的後方定義，由一對反引號包裹起來，具體的格式以下：

`key1:"value1" key2:"value2"`

結構體標籤由一個或多個鍵值對組成。鍵與值使用冒號分隔，值用雙引號括起來。鍵值對之間使用一個空格分隔。注意事項：爲結構體編寫Tag時，必須嚴格遵照鍵值對的規則。結構體標籤的解析代碼的容錯能力不好，一旦格式寫錯，編譯和運行時都不會提示任何錯誤，經過反射也沒法正確取值。例如不要在key和value之間添加空格。

例如咱們爲Student結構體的每一個字段定義json序列化時使用的Tag：

//Student 學生
type Student struct {
	ID     int    `json:"id"` //經過指定tag實現json序列化該字段時的key
	Gender string //json序列化是默認使用字段名做爲key
	name   string //私有不能被json包訪問
}

func main() {
	s1 := Student{
		ID:     1,
		Gender: "男",
		name:   "沙河娜扎",
	}
	data, err := json.Marshal(s1)
	if err != nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}
二10、練習題
  1. 使用「面向對象」的思惟方式編寫一個學生信息管理系統。
    1. 學生有id、姓名、年齡、分數等信息
    2. 程序提供展現學生列表、添加學生、編輯學生信息、刪除學生等功能
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程