Cara menggunakan jenis peta, keratan, struktur dan antara muka fungsi Golang

Golang ialah bahasa pengaturcaraan sumber terbuka yang dibangunkan oleh Google Ia menggunakan mekanisme penaipan statik dan pengumpulan sampah, serta menyokong pengaturcaraan serentak. Fungsi ialah komponen penting dalam Golang, dan peta, hirisan, struct dan antara muka adalah jenis data yang biasa digunakan dalam fungsi. Artikel ini akan memperkenalkan penggunaan jenis data ini di Golang.

1. Jenis peta

Peta ialah struktur data pasangan nilai kunci Di Golang, penggunaannya sangat mudah. Berikut ialah contoh:

package main

import "fmt"

func main() {
    m := make(map[string]int)
    m["apple"] = 1
    m["banana"] = 2
    m["orange"] = 3
    fmt.Println(m)
}

Dalam contoh di atas, kita mula-mula menggunakan fungsi make untuk mencipta peta kosong, dan kemudian menambah pasangan nilai kunci pada peta dalam urutan. Akhirnya, peta dikeluarkan menggunakan fungsi println dalam pakej fmt.

Selain menggunakan fungsi make untuk mencipta peta, kami juga boleh menggunakan literal untuk mencipta peta bukan kosong, seperti yang ditunjukkan di bawah:

package main

import "fmt"

func main() {
    m := map[string]int{"apple": 1, "banana": 2, "orange": 3}
    fmt.Println(m)
}

Kami juga boleh menggunakan peta apabila mengisytiharkan pembolehubah Isytiharkan bersama-sama seperti berikut:

package main

import "fmt"

func main() {
    var m map[string]int
    m = make(map[string]int)
    m["apple"] = 1
    m["banana"] = 2
    m["orange"] = 3
    fmt.Println(m)
}

Sudah tentu, jika pasangan nilai kunci tidak wujud dalam peta, kita boleh menggunakan fungsi padam untuk memadamkannya, seperti yang ditunjukkan di bawah:

package main

import "fmt"

func main() {
    m := make(map[string]int)
    m["apple"] = 1
    m["banana"] = 2
    m["orange"] = 3
    delete(m, "banana")
    fmt.Println(m)
}

2. slice Type

slice ialah tatasusunan dinamik di mana elemen boleh ditambah atau dialih keluar pada bila-bila masa. Berikut ialah contoh:

package main

import "fmt"

func main() {
    s := make([]string, 3)
    s[0] = "apple"
    s[1] = "banana"
    s[2] = "orange"
    s = append(s, "grape")
    fmt.Println(s)
}

Dalam contoh di atas, kami menggunakan fungsi make untuk mencipta kepingan dengan jenis elemen rentetan dan panjang 3. Kemudian, kami menambah 3 elemen pada kepingan, dan akhirnya menambah elemen baharu pada kepingan menggunakan fungsi tambah.

Sudah tentu, kita juga boleh menggunakan literal untuk mencipta kepingan bukan kosong, seperti yang ditunjukkan di bawah:

package main

import "fmt"

func main() {
    s := []string{"apple", "banana", "orange"}
    s = append(s, "grape")
    fmt.Println(s)
}

Kami juga boleh mengisytiharkan kepingan itu bersama-sama apabila mengisytiharkan pembolehubah, seperti yang ditunjukkan di bawah:

package main

import "fmt"

func main() {
    var s []string
    s = make([]string, 3)
    s[0] = "apple"
    s[1] = "banana"
    s[2] = "orange"
    s = append(s, "grape")
    fmt.Println(s)
}

3. jenis struct

struct ialah jenis komposit tersuai yang boleh menyimpan berbilang jenis data. Berikut ialah contoh:

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Tom", 18}
    fmt.Println(p)
}

Dalam contoh di atas, kami menggunakan kata kunci jenis untuk mencipta jenis struct bernama Person. Kemudian, kami mencipta pembolehubah p, yang jenisnya ialah Orang, dan memberikan nilai kepadanya.

Selain itu, kita juga boleh menggunakan penunjuk struktur untuk mengakses medan dalam jenis struct, seperti yang ditunjukkan di bawah:

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    p := &Person{"Tom", 18}
    p.Name = "Jerry"
    fmt.Println(p)
}

4 jenis antara muka

antara muka ialah jenis abstrak yang boleh digunakan untuk mewakili sebarang jenis. Berikut ialah contoh:

package main

import "fmt"

type Animal interface {
    Eat()
}

type Cat struct {
    Name string
}

func (c *Cat) Eat() {
    fmt.Printf("%s is eating
", c.Name)
}

func main() {
    var a Animal
    a = &Cat{"Tom"}
    a.Eat()
}

Dalam contoh di atas, kami menggunakan kata kunci jenis untuk mencipta jenis antara muka bernama Animal, yang hanya mempunyai satu kaedah Eat. Kemudian, kami menggunakan kata kunci jenis untuk mencipta jenis struct bernama Cat, yang melaksanakan kaedah Eat jenis Haiwan. Akhir sekali, kami mencipta pembolehubah a yang jenisnya ialah Haiwan dan menetapkannya kepada pembolehubah jenis Cat. Apabila kita memanggil kaedah Makan a, ayat dikeluarkan yang menunjukkan bahawa Kucing sedang makan.

Selain itu, kami juga boleh menggunakan penegasan jenis untuk menentukan sama ada pembolehubah melaksanakan antara muka tertentu, seperti yang ditunjukkan di bawah:

package main

import "fmt"

type Animal interface {
    Eat()
}

type Cat struct {
    Name string
}

func (c *Cat) Eat() {
    fmt.Printf("%s is eating
", c.Name)
}

func main() {
    var a Animal
    a = &Cat{"Tom"}
    _, ok := a.(*Cat)
    fmt.Println(ok)
}

Dalam contoh di atas, kami menggunakan kata kunci jenis untuk mencipta Terdapat jenis antara muka bernama Animal, yang hanya mempunyai satu kaedah Eat. Kemudian, kami menggunakan kata kunci jenis untuk mencipta jenis struct bernama Cat, yang melaksanakan kaedah Eat jenis Haiwan. Akhir sekali, kami mencipta pembolehubah a yang jenisnya ialah Haiwan dan menetapkannya kepada pembolehubah jenis Cat. Kami menggunakan penegasan jenis untuk menentukan sama ada a melaksanakan jenis Cat dan output benar.

Atas ialah kandungan terperinci Cara menggunakan jenis peta, keratan, struktur dan antara muka fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!