go--指針、結構體和接口
指針
指針地址和指針類型
每一個變量在運行時都擁有一個地址，這個地址表明變量在內存中的位置。Go語言中使用&字符放在變量前面對變量進行「取地址」操做。 Go語言中的值類型（int、float、bool、string、array、struct）都有對應的指針類型，如：*int、*int64、*string等。取變量指針的語法以下：php
a := &變量
// 舉例
a := 1
b := &a
fmt.Printf("a:%d ptr:%p\n", a, &a); // a:1 ptr:0xc000098000
fmt.Println(b) // 0xc000098000
fmt.Printf("%T\n", b) // *int
指針取值
在對普通變量使用&操做符取地址後會得到這個變量的指針，而後能夠對指針使用*操做，也就是指針取值，代碼以下。json
func main() {
a := 1
b := &a
fmt.Printf("type of b:%T\n", b) // type of b:*int
c := *b
fmt.Printf("type of c:%T\n", c) // type of c:int
fmt.Printf("value of c:%v\n", c) // value of c:1
}
指針操做，能夠實現相似於php中&符傳引用的功能：數據結構
func modify1(x int) {
x = 100
}
func modify2(x *int) {
*x = 100
}
func main() {
a := 10
modify1(a)
fmt.Println(a) // 10
modify2(a)
fmt.Println(a) // 100
}
new()函數建立指針
Go語言還提供了另一種方法來建立指針變量，格式以下：app
new (類型)
// 舉例
func main () {
a := new(int)
fmt.Println(a) // 0xc00001a078
fmt.Printf("type of a:%T\n", a) // type of a:*int
*a = 100
fmt.Println(a) //0xc00001a078
fmt.Println(*a) //100
}
結構體
定義
Go語言中沒有「類」的概念，也不支持「類」的繼承等面向對象的概念。Go語言中經過結構體的內嵌再配合接口比面向對象具備更高的擴展性和靈活性。函數
類型別名和自定義類型
自定義類型
在Go語言中有一些基本的數據類型，如string、整型、浮點型、布爾等數據類型， Go語言中可使用type關鍵字來定義自定義類型。佈局
自定義類型是定義了一個全新的類型。咱們能夠基於內置的基本類型定義，也能夠經過struct定義。例如：性能
type MyInt int
類型別名
類型別名規定：TypeAlias只是Type的別名，本質上TypeAlias與Type是同一個類型。學習
type TypeAlias = Type
咱們以前見過的rune和byte就是類型別名，他們的定義以下：ui
type byte = uint8 type rune = int32
類型定義和類型別名的區別
類型別名與類型定義表面上看只有一個等號的差別，咱們經過下面的這段代碼來理解它們之間的區別。this
// 類型定義
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
}
結構體
Go語言中的基礎數據類型能夠表示一些事物的基本屬性，可是當咱們想表達一個事物的所有或部分屬性時，這時候再用單一的基本數據類型明顯就沒法知足需求了，Go語言提供了一種自定義數據類型，能夠封裝多個基本數據類型，這種數據類型叫結構體，英文名稱struct。 也就是咱們能夠經過struct來定義本身的類型了。
Go語言中經過struct來實現面向對象。
結構體的定義
使用type和struct關鍵字來定義結構體，具體代碼格式以下：
type 類型名 struct {
字段名 字段類型
字段名 字段類型
}
其中：
- 類型名：標識自定義結構體的名稱，在同一個包內不能重複。
- 字段名：表示結構體字段名。結構體中的字段名必須惟一。
- 字段類型：表示結構體字段的具體類型。
例如：
type student struct {
name string
city string
age int8
}
// 相同類型的字段也能夠寫在一行
type student struct {
name, city string
age int8
}
結構體實例化
只有當結構體實例化時，纔會真正的分配內存。也就是必須實例化後才能使用結構體的字段。
基本實例化
type student struct {
name string
city string
age int8
}
func main() {
var tom student
tom.name = "tom"
tom.city = "北京"
tom.age = 100
fmt.Printf("p1=%v\n", p1) //p1={tom 北京 100}
fmt.Printf("p1=%#v\n", p1) //p1=main.student{name:"tom", city:"北京", age:100}
}
匿名結構體
在定義一些臨時數據結構等場景下還可使用匿名結構體。
func main() {
var user struct{Name string; Age int}
user.Name = "小王子"
user.Age = 18
fmt.Printf("%#v\n", user)
}
建立指針類型結構體
咱們還能夠經過使用new關鍵字對結構體進行實例化，獲得的是結構體的地址。 格式以下：
var lee = new (student)
fmt.Printf("%T\n", p2) //*main.student
fmt.Printf("p2=%#v\n", p2) //p2=&main.student{name:"", city:"", age:0}
注意：Go語言中一樣支持對結構體指針直接使用.來訪問結構體的成員。
取結構體的地址實例化
使用&對結構體進行取地址操做至關於對該結構體進行了一次new實例化操做。
tom := &student{}
fmt.Printf("%T\n", p3) //*main.student
fmt.Printf("p3=%#v\n", p3) //p3=&main.student{name:"", city:"", age:0}
tom.name = "tom"
tom.age = 100
tom.city = "北京"
tom.name = "tom"其實在底層是(*tom).name = "tom"，這是Go語言幫咱們實現的語法糖。
結構體初始化
沒有初始化的結構體，其成員變量都是對應其類型的零值。
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}
}
使用鍵值對初始化
使用鍵值對對結構體進行初始化時，鍵對應結構體的字段，值對應該字段的初始值。
p := person{
name: "小王子",
city: "北京",
age: 18,
}
fmt.Printf("p=%#v\n", p) //p=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}
初始化結構體的時候能夠簡寫，也就是初始化的時候不寫鍵，直接寫值：
p8 := &person{
"張三",
"北京",
28,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"張三", city:"北京", age:28}
使用這種格式初始化時，須要注意：
- 必須初始化結構體的全部字段。
- 初始值的填充順序必須與字段在結構體中的聲明順序一致。
- 該方式不能和鍵值初始化方式混用。
結構體內存佈局
結構體佔用一塊連續的內存。
構造函數
Go語言的結構體沒有構造函數，咱們能夠本身實現。 例如，下方的代碼就實現了一個person的構造函數。 由於struct是值類型，若是結構體比較複雜的話，值拷貝性能開銷會比較大，因此該構造函數返回的是結構體指針類型。
func newPerson (name, city string, age int8) *person {
return &{
name: name,
city: city,
age: age,
}
}
方法和接收者
Go語言中的方法（Method）是一種做用於特定類型變量的函數。這種特定類型變量叫作接收者（Receiver）。接收者的概念就相似於其餘語言中的this或者self。
方法的定義格式以下：
func (接收者變量 接收者類型) 方法名(參數列表) (返回參數) {
函數體
}
其中：
- 接收者變量：接收者中的參數變量名在命名時，官方建議使用接收者類型名的第一個小寫字母，而不是
self、this之類的命名。例如，Person類型的接收者變量應該命名爲p，Connector類型的接收者變量應該命名爲c等。 - 接收者類型：接收者類型和參數相似，能夠是指針類型和非指針類型。
- 方法名、參數列表、返回參數：具體格式與函數定義相同。
// 結構體
type Person struct {
name string
age int8
}
// 構造函數
func NewPerson(name string, age int8) *Person {
return &Person{
name: name,
age: age,
}
}
// study方法
func (p Person) Study() {
fmt.Printf("%s要好好學習\n", p.name)
}
func main() {
p1 = NewPerson("張三", 18)
p1.Study()
}
指針類型的接收者
指針類型的接收者由一個結構體的指針組成，因爲指針的特性，調用方法時修改接收者指針的任意成員變量，在方法結束後，修改都是有效的。這種方式就十分接近於其餘語言中面向對象中的this或者self。 例如咱們爲Person添加一個SetAge方法，來修改實例變量的年齡。
func (p *Person) SetAge(newAge int8) {
p.age = newAge
}
func main() {
p1 := NewPerson("張三", 25)
fmt.Println(p1.age) //25
p1.SetAge(30) //等價於(&p1).SetAge(30)
fmt.Println(p1.age) //30
}
值類型的接收者
當方法做用於值類型接收者時，Go語言會在代碼運行時將接收者的值複製一份。在值類型接收者的方法中能夠獲取接收者的成員值，但修改操做只是針對副本，沒法修改接收者變量自己。
func (p Person) setAge2(newAge int8) {
p.age = newAge
}
func main () {
p1 := NewPerson("張三", 30)
p1.Study()
fmt.Println(p1.age) //30
p1.SetAge2(33)
fmt.Println(p1.age) //30
}
注意：在如下狀況推薦使用指針類型接收者
- 須要修改接收者中的值
- 接收者是拷貝代價比較大的大對象
- 保證一致性，若是有某個方法使用了指針接收者，那麼其餘的方法也應該使用指針接收者。
任意類型添加方法
在Go語言中，接收者的類型能夠是任何類型，不只僅是結構體，任何類型均可以擁有方法。 舉個例子，咱們基於內置的int類型使用type關鍵字能夠定義新的自定義類型，而後爲咱們的自定義類型添加方法。
type Myint int
func (m Myint) SayHello() {
fmt.Println("Hello")
}
func main () {
var m1 Myint
m1.SayHello()
m1 = 100
fmt.Printf("%#v %T\n"k, m1, m1) // 100 main.Myint
}
注意事項：非本地類型不能定義方法，也就是說咱們不能給別的包的類型定義方法。
結構體的匿名字段
結構體容許其成員字段在聲明時沒有字段名而只有類型，這種沒有名字的字段就稱爲匿名字段。
type Person struct {
string
int
}
func main () {
p1 := Person{
"張三",
18
}
fmt.Printf("%#v\n", p1) // main.Person{string:"張三", int:18}
}
嵌套結構體
一個結構體中能夠嵌套包含另外一個結構體或結構體指針。
type Address struct {
Province string
City string
}
type User struct {
Name string
Gender string
Address Address
}
func main () {
user1 := User{
Name: "張三",
Gender: "男",
Address: Address{
Province: "山西",
City: "太原",
},
}
}
嵌套匿名結構體
// 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:"威海"}}
}
注意：當訪問結構體成員時會先在結構體中查找該字段，找不到再去匿名結構體中查找。
嵌套結構體的字段名衝突
嵌套結構體內部可能存在相同的字段名。這個時候爲了不歧義須要指定具體的內嵌結構體的字段。
//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
}
結構體的「繼承」
Go語言中使用結構體也能夠實現其餘變成語言中面向對象的繼承。
type Animal struct {
name string
}
func (a *Animal) move() {
fmt.Printf("%s會動！\n", a.name)
}
type Dog struct {
Feet int8
*Animal // 經過嵌套匿名結構體實現繼承
}
func (d *Dog) bark() {
fmt.Printf("%s會汪汪汪\n", d.name)
}
func main () {
d1 := &Dog{
Feet: 4,
Animal: &Animal{
name: "仉仉",
},
}
d1.bark() // 仉仉會汪汪汪
d1.move() // 仉仉會動！
}
結構體字段的可見性
結構體中字段大寫開頭表示可公開訪問，小寫表示私有（僅在定義當前結構體的包中可訪問）。
結構體於Json序列化
可使用json.Marshal()將結構體序列化爲json字符串
//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)
}
結構體tag
tag是結構體的元信息，能夠在運行的時候經過反射的機制讀取出來。 例如定義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":"男"}
}
- 1. Go 指針和接口
- 2. 4.Go-結構體、結構體指針和方法
- 3. golang積累-接口指針與結構體指針
- 4. Go筆記-結構體和接口
- 5. go結構，結構嵌套，接口，指針的測試和結論
- 6. Golang結構體和指針
- 7. 指針和結構體
- 8. 結構體指針
- 9. 指針結構體
- 10. 結構體指針變量含義，結構體指針函數
- 更多相關文章...
- • Rust 結構體 - RUST 教程
- • Swift 結構體 - Swift 教程
- • 算法總結-雙指針
- • 算法總結-滑動窗口
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Go 指針和接口
- 2. 4.Go-結構體、結構體指針和方法
- 3. golang積累-接口指針與結構體指針
- 4. Go筆記-結構體和接口
- 5. go結構，結構嵌套，接口，指針的測試和結論
- 6. Golang結構體和指針
- 7. 指針和結構體
- 8. 結構體指針
- 9. 指針結構體
- 10. 結構體指針變量含義，結構體指針函數