Go Generik disokong sejak 1.18 dan digunakan untuk menulis kod generik untuk jenis selamat. 1. Printslice fungsi generik [t] (s [] t) boleh mencetak kepingan mana -mana jenis, seperti [] int atau [] rentetan. 2. Melalui had bilangan kekangan jenis t ke jenis angka seperti int dan float, melaksanakan jumlah [T nombor] (slice [] t) t Summation Safete. 3. Kotak Jenis Struktur Generik [t; Struct {value t} boleh merangkum sebarang nilai jenis dan digunakan dengan pembina kotak baru [t] (v t) *. 4. Tambah set (v t) dan dapatkan () kaedah t untuk kotak [t], tanpa berulang kali mengisytiharkan [t] dalam kaedah. 5. Fungsi parameter multi-jenis mengandungi nilai [k setanding, v mana-mana] (m peta [k] v, nilai v) bool menentukan sama ada terdapat nilai tertentu dalam peta, dan k perlu dibandingkan. 6. Aplikasi praktikal seperti cache jenis cache umum [k setanding, v mana Generik meningkatkan kebolehgunaan semula kod dan keselamatan melalui parameter jenis, kekangan, dan jenis kesatuan, dan sintaks adalah ringkas dan praktikal.

Generik untuk GO telah disokong secara rasmi sejak GO 1.18, yang membolehkan anda menulis fungsi dan struktur data yang boleh mengendalikan pelbagai jenis. Berikut adalah beberapa contoh generik Go tipikal untuk membantu anda dengan cepat memahami cara menggunakan generik dalam amalan.

? 1. Fungsi Generik: PrintSlice[T any]

Jika anda ingin mencetak apa -apa jenis kandungan slice, seperti []int dan []string , anda boleh menulis fungsi generik:

 FuncSlice [t] (s [] t) {
    untuk _, v: = julat s {
        fmt.print (v, "")
    }
    fmt.println ()
}

// Gunakan Contoh Printslice ([] int {1, 2, 3}) // output: 1 2 3
Printslice ([] string {"a", "b"}) // output: ab

• [T any] bermaksud bahawa parameter jenis T boleh dari mana -mana jenis.
• any alias untuk interface{} , menunjukkan tiada kekangan.

? 2. Fungsi generik: dengan kekangan jenis (kekangan)

Jika anda ingin menyekat jenis, seperti hanya jenis angka yang dibenarkan, anda boleh menentukan kekangan:

 Taipkan antara muka {
    int | Int32 | Int64 | Float32 | Float64
}

FUNC SUM [T nombor] (slice [] t) t {
    var total t
    untuk _, v: = keping pelbagai {
        total = v
    }
    Pulangan Jumlah
}

// Gunakan fmt.println (jumlah ([] int {1, 2, 3})) // 6
fmt.println (jumlah ([] float64 {1.1, 2.2})) // 3.3

• Number adalah jenis antara muka, yang menggunakan | Untuk mewakili jenis kesatuan (kesatuan), dan had T mestilah salah satu jenis yang disenaraikan.
• Ini menghalang anda daripada melewati string atau struct dan lain -lain daripada tidak menyokong Jenis operasi.

? 3. Struktur generik

Tentukan bekas Box biasa yang boleh memegang apa -apa jenis nilai:

 Taipkan kotak [t] struct {
    Nilai t
}

Func Newbox [t any] (v t) *box [t] {
    kembali & kotak [t] {value: v}
}

// Gunakan intbox: = newbox (42)
strbox: = newbox ("hello")

fmt.println (intbox.value) // 42
fmt.println (strbox.value) // hello

• Box[T] adalah struktur generik.
• NewBox adalah pembina generik yang secara automatik menyimpulkan jenis.

? 4. Kaedah generik

Tambahkan kaedah ke struktur generik:

 func (b *box [t]) set (v t) {
    B.Value = V.
}

func (b *box [t]) get () t {
    kembali B.Value
}

// Kotak Gunakan: = Newbox (100)
box.set (200)
fmt.println (box.get ()) // 200

Kaedah itu sendiri tidak perlu mengisytiharkan [T] kerana ia sudah menjadi milik Box[T] .

? 5. Generik dan Peta: Cari nilai utama

Tulis fungsi umum untuk mencari sama ada nilai wujud dalam peta:

 Func mengandungi nilai [k setanding, v mana -mana] (m peta [k] v, nilai v) bool {
    untuk _, v: = julat m {
        jika v == nilai {
            kembali benar
        }
    }
    kembali palsu
}

// gunakan m: = peta [string] int {"a": 1, "b": 2}
fmt.println (mengandungi nilai (m, 2)) // benar
fmt.println (mengandungi nilai (m, 3)) // palsu

• K comparable : Jenis utama mestilah setanding (seperti rentetan, int, struct, dan lain -lain).
• V any : Nilai boleh dari mana -mana jenis.
• Parameter jenis berganda dipisahkan oleh koma.

? 6. Senario Aplikasi Praktikal: Cache Umum

Anda boleh melaksanakan struktur cache yang mudah menggunakan generik:

 jenis cache [k setanding, v mana -mana] struct {
    Peta data [k] v
}

func newCache [k setanding, v mana -mana] () *cache [k, v] {
    kembali & cache [k, v] {
        Data: Buat (peta [k] v),
    }
}

Func (C *cache [k, v]) set (kunci k, nilai v) {
    c.data [key] = nilai
}

func (c *cache [k, v]) mendapatkan (kunci k) (v, bool) {
    v, ok: = c.data [key]
    Kembali V, OK
}

Gunakan:

 Cache: = newCache [string, int] ()
cache.set ("Pengguna", 100)
jika val, ok: = cache.get ("pengguna"); ok {
    fmt.println ("Count:", val)
}

Ringkasan: Titik utama generik

• Gunakan [T any] atau [T Constraint] untuk menentukan parameter jenis.
• comparable adalah kekangan yang telah ditetapkan untuk jenis setanding (untuk kunci peta, == penghakiman, dll.).
• Jenis Kesatuan ( | ) boleh menyekat koleksi jenis.
• Generik membuat fungsi dan struktur lebih umum, jenis selamat, dan mengurangkan kod pendua.

Pada dasarnya itu sahaja. Pergi generik tidak mengejar kerumitan, tetapi menekankan kepraktisan dan kejelasan. Apabila anda mula -mula menggunakannya, anda akan merasakan bahawa tatabahasa agak baru, tetapi selepas menulis beberapa contoh, anda akan merasa agak semula jadi.

Atas ialah kandungan terperinci Pergi dengan contoh generik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!