Bagaimana untuk menggunakan struktur bersarang dalam Go?

Dalam bahasa Go, struktur bersarang ialah teknik yang sangat biasa. Dengan membenamkan satu struktur dalam yang lain, kami boleh memecahkan model data yang kompleks kepada bahagian yang lebih kecil, menjadikannya lebih mudah untuk difahami dan diselenggara. Artikel ini akan memperkenalkan cara menggunakan struktur bersarang dalam Go dan beberapa amalan terbaik.

1. Tentukan struktur bersarang

Pertama, kita perlu mentakrifkan struktur yang mengandungi struktur bersarang. Kod berikut menunjukkan cara untuk mentakrifkan struktur Syarikat yang mengandungi struktur Orang:

type Person struct {
  Name string
  Age int
}

type Company struct {
  Name string
  Address string
  CEO Person
}

Dalam contoh ini, kami mencipta struktur Orang untuk mewakili CEO setiap syarikat, dan kemudian kami membenamkannya dalam struktur Syarikat . Dengan cara ini, kita boleh mengakses medan CEO sama seperti struktur biasa.

2. Mulakan struktur bersarang

Seterusnya, kita perlu memulakan struktur bersarang. Kita boleh menggunakan literal struktur untuk memulakan struktur bersarang. Kodnya adalah seperti berikut:

company := Company{
  Name: "ABC Inc.",
  Address: "123 Main St.",
  CEO: Person{
    Name: "John Smith",
    Age: 45,
  },
}

Dalam contoh ini, kami memulakan struktur Syarikat melalui literal. Ambil perhatian bahawa kami menggunakan struktur Orang secara literal dalam medan CEO untuk memulakannya.

3. Akses medan struktur bersarang

Kini kami telah menentukan dan memulakan struktur bersarang. Kita boleh mengakses bidang struktur bersarang seperti struktur biasa. Begini caranya untuk mengakses medan nama dan umur CEO:

fmt.Println(company.CEO.Name) // 输出 “John Smith”
fmt.Println(company.CEO.Age) // 输出 “45”

Dalam contoh ini, kami menggunakan operator titik untuk mengakses medan Nama dan Umur dalam struktur CEO. Ini sama seperti mengakses struktur biasa.

4. Pewarisan dan timpa

Dalam sesetengah senario, kita mungkin perlu mewarisi dan menimpa dalam struktur bersarang.

Diwarisi

Jika dua struktur dalam struktur bersarang mempunyai medan yang sama, struktur bersarang akan menimpa medan dalam struktur terbenam. Jika struktur bersarang mengandungi medan tambahan, ia akan ditambahkan pada struktur terbenam. Berikut ialah contoh:

type Animal struct {
  Name string
  Age int
}

type Bird struct {
  Animal // 继承Animal结构体
  CanFly bool
}

bird := Bird{
  Animal: Animal{
    Name: "Polly",
    Age: 2,
  },
  CanFly: true,
}

fmt.Println(bird.Name) // 输出 “Polly”
fmt.Println(bird.Age) // 输出 “2”
fmt.Println(bird.CanFly) // 输出 “true”

Dalam contoh ini, struktur Burung membenamkan struktur Haiwan, jadi kita boleh mengakses medan struktur Haiwan seperti kita mengakses struktur Burung. Apabila memulakan struktur Burung, kami memulakannya menggunakan literal struktur Haiwan. Oleh kerana struktur Burung mewarisi struktur Haiwan, ia secara semula jadi boleh mewarisi nama dan medan umur struktur Haiwan.

Timpa

Jika anda perlu mengatasi beberapa medan atau kaedah dalam struktur bersarang, kami boleh melebihkan dengan cara yang sama seperti struktur biasa. Berikut ialah contoh:

type Person struct {
  Name string
  Age int
}

type Employee struct {
  Person // 继承Person结构体
  EmployeeID string
}

func (p Person) Greet() {
  fmt.Println("Hello")
}

func (e Employee) Greet() {
  fmt.Println("Hi, I'm an employee")
}

employee := Employee{
  Person: Person{
    Name: "John Smith",
    Age: 35,
  },
  EmployeeID: "12345",
}

employee.Person.Greet() // 输出 “Hello”
employee.Greet() // 输出 “Hi, I'm an employee”

Dalam contoh ini, kami mentakrifkan struktur Orang dan struktur Pekerja. Struktur Pekerja mewarisi daripada struktur Orang. Kami menentukan kaedah Sambut dalam struktur Orang, yang mencetak "Hello". Dalam struktur Pekerja, kami membebankan kaedah Greet, yang mencetak "Hai, saya seorang pekerja". Selepas kita memulakan pembolehubah pekerja menggunakan struktur Pekerja, kita boleh memanggil kaedah Greet struktur Orang untuk mencetak "Hello", atau memanggil kaedah Greet struktur Pekerja untuk mencetak "Hai, saya pekerja".

5. Antara muka dan penunjuk bersarang

Apabila menggunakan struktur bersarang, kami juga boleh menyusun antara muka dan penunjuk. Berikut ialah contoh:

type Talker interface {
  Talk()
}

type Person struct {
  Name string
  Age int
}

func (p *Person) Talk() {
  fmt.Println("Hi, I'm " + p.Name)
}

type Employee struct {
  *Person // 嵌套指针类型
  EmployeeID string
  Role string
}

func (e *Employee) Talk() {
  fmt.Println("Hi, I'm" + e.Name + ", and I work as a " + e.Role)
}

employee := Employee{
  Person: &Person{
    Name: "John Smith",
    Age: 35,
  },
  EmployeeID: "12345",
  Role: "software engineer",
}

var talker Talker // 声明一个接口类型的变量
talker = &employee // 将employee赋值给talker

talker.Talk() // 输出 “Hi, I'm John Smith, and I work as a software engineer”

Dalam contoh ini, kami mentakrifkan antara muka Talker, yang mempunyai kaedah Talk. Kami menentukan struktur Orang dan struktur Pekerja, yang kedua-duanya melaksanakan antara muka Talker. Struktur Pekerja mempunyai penunjuk Orang yang bersarang di dalamnya, jadi kita boleh menggunakan kaedah Bicara struktur Orang. Selepas memulakan pembolehubah pekerja, kami menetapkannya kepada pembolehubah jenis antara muka Talker, supaya kami boleh menggunakan kaedah jenis antara muka untuk mengakses pembolehubah pekerja.

6. Kesimpulan

Dalam bahasa Go, struktur bersarang ialah teknologi yang sangat berguna yang boleh menguraikan model data yang kompleks kepada bahagian yang lebih kecil. Apabila menggunakan struktur bersarang, kita perlu memberi perhatian kepada penggunaan pewarisan dan penggantian, serta penggunaan antara muka dan penunjuk bersarang. Dengan menguasai teknologi ini, kami boleh membangunkan dan mengekalkan projek bahasa Go dengan lebih baik.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan struktur bersarang dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!