Lebih penting lagi, generik mengekalkan keselamatan jenis Go yang kukuh yang membolehkan pemeriksaan jenis statik pada masa penyusunan dan memastikan ketepatan jenis. Mereka menyediakan pengendalian ralat piawai dalam kod generik yang meningkatkan kejelasan dan kebolehselenggaraan. Selain itu, ia menyediakan pengendalian ralat piawai dalam kod generik yang meningkatkan kejelasan dan kebolehselenggaraan. Dalam siaran ini, kami akan mengkaji beberapa aplikasi dan contoh generik Go dunia sebenar.
Contoh 1: Menggunakan Fungsi Generik Golang
Salah satu kes penggunaan utama untuk generik ialah mencipta fungsi yang boleh beroperasi pada jenis yang berbeza. Di sini, kita pergi dengan salah satu contoh di mana fungsi lilitan generik digunakan.
pakej utama
import 'fmt'
fungsi lilitan [ r int | terapung32 ]( jejari r ) {
c := 3 * 2 * jejari
fmt . Println ( 'Lilitan generik ialah:' , c )
}
fungsi utama () {
adalah r1 int = 7
adalah r2 terapung32 = 7 . 5
lilitan ( r1 )
lilitan ( r2 )
}
Pada permulaan kod sebelumnya, baris mengimport pakej 'fmt' yang menyediakan fungsi untuk I/O berformat, termasuk mencetak output ke konsol. Kemudian, kami mentakrifkan fungsi generik bernama 'lilitan' yang mengambil jejari parameter jenis generik 'r' yang boleh sama ada 'int' atau 'float32'. Di dalam fungsi, ia mengira lilitan dengan mendarab jejari dengan nilai malar '3' dan kemudian mendarabkannya dengan '2'. Akhir sekali, ia mencetak lilitan yang dikira menggunakan 'fmt.Println'.
Seterusnya, kita mempunyai fungsi utama di mana dua pembolehubah, r1 dan r2, diisytiharkan dan diberikan dengan nilai 7 dan 7.5, masing-masing. Selepas itu, fungsi 'lilitan' digunakan dua kali, melepasi r1 dan r2 sebagai hujah.
Output memaparkan pengiraan dengan mencetak lilitan bulatan dalam yang berikut:
Contoh 2: Menggunakan Antara Muka Generik Golang
Lebih-lebih lagi, generik Golang membantu kami dengan antara muka mereka. Antara muka dalam Go ialah alat penting untuk memudahkan penggunaan semula kod dan polimorfisme. Dengan membolehkannya berfungsi dengan banyak jenis, generik meningkatkan kuasa antara muka. Berikut ialah kod sumber antara muka generik Golang:
pakej utama
import 'fmt'
menaip EmpAge antara muka {
int64 | int32 | terapung32 | terapung64
}
fungsi newGenericFunc [ umur Umur ]( emp_Umur umur ) {
val := int ( emp_Umur ) + 1
fmt . Println ( val )
}
fungsi utama () {
fmt . Println ( 'Umur Pekerja' )
adalah Umur1 int64 = 24
adalah Umur2 terapung64 = 25 . 5
newGenericFunc ( Umur1 )
newGenericFunc ( Umur2 )
}
Dalam kod sumber sebelumnya, kami menentukan antara muka bernama 'EmpAge' yang menentukan jenis yang mungkin untuk umur pekerja. Antara muka termasuk jenis int64, int32, float32 dan float64. Antara muka ini membenarkan fungsi 'generik' menerima mana-mana jenis ini sebagai hujah. Selepas itu, kami menggunakan fungsi generik bernama newGenericFunc yang mengambil parameter emp_Age bagi jenis umur generik yang boleh menjadi sebarang jenis yang memenuhi antara muka EmpAge. Di dalam fungsi, ia menukar emp_Age kepada int dan menambahnya sebanyak 1 seperti yang ditunjukkan.
Seterusnya, kami mengisytiharkan dua pembolehubah, Age1 dan Age2, dan menetapkan nilai 24 dan 25.5, masing-masing, dalam fungsi utama. Selepas itu, Age1 dan Age2 diluluskan sebagai parameter kepada fungsi GenericFunc baru yang menjalani pelaksanaan dua kali. Dengan ini, umur dinaikkan sebanyak 1 dan menjana nilai yang dikemas kini.
Output yang dihasilkan dalam perkara berikut ialah umur daripada fungsi generik yang menggunakan antara muka:
Contoh 3: Menggunakan Struktur Data Generik Golang
Tambahan pula, Go generik juga memberi kita keupayaan untuk membina struktur data generik seperti tindanan, baris gilir dan senarai terpaut. Pertimbangkan pelaksanaan timbunan generik dalam perkara berikut:
import 'fmt'menaip Timbunan [ T mana-mana ] [] T
fungsi ( st * Timbunan [ T ]) Tolak ( item T ) {
st = tambahkan ( * st , item )
}
fungsi ( st * Timbunan [ T ]) Pop () T {
jika sahaja ( * st ) == 0 {
panik ( 'Tiada apa-apa dalam Stack' )
}
indeks := sahaja ( * st ) - 1
item := ( * st )[ indeks ]
* st = ( * st )[: indeks ]
kembali item
}
fungsi utama () {
timbunan := baru ( Timbunan [ int ])
timbunan . Tolak ( 1 )
timbunan . Tolak ( 2 )
timbunan . Tolak ( 3 )
fmt . Println ( timbunan . Pop ())
fmt . Println ( timbunan . Pop ())
fmt . Println ( timbunan . Pop ())
}
Dalam kod sebelumnya, jenis generik bertajuk 'Timbunan' ditakrifkan yang mewakili timbunan. Pemegang tempat 'T' membenarkan tindanan untuk memegang unsur-unsur apa-apa jenis. Jenis 'Timbunan' dilaksanakan sebagai kepingan unsur jenis 'T'. Di sini, dua fungsi digunakan untuk jenis 'Timbunan': 'Tolak' dan 'Pop.' Fungsi Push() bertanggungjawab untuk menambah elemen pada timbunan. Ia memerlukan item hujah jenis 'T' dan melampirkannya pada kepingan asas menggunakan fungsi append().
Walaupun fungsi Pop() mengambil komponen awal daripada timbunan dan mengembalikannya, ia terlebih dahulu menentukan sama ada timbunan kosong dengan menilai saiz kepingan asas. Pemberitahuan ralat dihantar jika tindanan kelihatan kosong yang menyebabkan panik. Jika tidak, ia mendapatkan semula elemen terakhir daripada hirisan, mengeluarkannya daripada timbunan dengan menghiris hirisan sehingga elemen kedua-ke-terakhir dan mengembalikan item yang dialih keluar.
Seterusnya, tindanan integer baharu dibuat menggunakan sintaks Stack[int] dalam fungsi utama kod ini. Selepas itu, kaedah 'Tolak' kemudian dipanggil tiga kali untuk menambah integer 1, 2, dan 3 pada tindanan. Walau bagaimanapun, kaedah 'Pop' dipanggil tiga kali selepas itu untuk mendapatkan dan mencetak elemen dari timbunan.
Output berikut menunjukkan bahawa unsur-unsur dikeluarkan daripada timbunan dalam susunan terbalik:
Contoh 4: Menggunakan Kekangan Generik Golang
Go juga menawarkan kekangan tersuai yang membolehkan fleksibiliti yang hebat dan menentukan keperluan khusus untuk binaan generik berdasarkan keperluan aplikasinya. Kod kekangan generik tersuai disediakan dalam yang berikut untuk demonstrasi:
pakej utamaimport 'fmt'
menaip Angka antara muka {
int64 | terapung64
}
fungsi utama () {
FloatValue := [] terapung64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
IntegerValue := [] int64 { 2 , 4 , 6 , 8 , 10 }
jumlah1 := genericSum ( FloatValue )
jumlah2 := genericSum ( IntegerValue
fmt . Println ( 'Jumlah apungan64 :' , jumlah1 )
fmt . Println ( 'Jumlah int64 :' , jumlah2 )
}
fungsi genericSum [ n Angka ]( nombor [] n ) n {
adalah saya n
untuk _ , pada satu := julat nombor {
jumlah += pada satu
}
kembali jumlah
}
Dalam kod sumber terdahulu, kami mentakrifkan antara muka Angka dengan kaedah 'Jumlah'. Kemudian, kami mencipta dua jenis tersuai, 'FloatValue' dan 'IntegerValue', yang melaksanakan antara muka Numerics dengan menyediakan kaedah 'Sum' masing-masing. Fungsi genericSum kini boleh menerima kepingan apa-apa jenis yang memenuhi antara muka Numerics. Di dalam fungsi, kami mengulangi elemen dan memanggil kaedah 'Jumlah' untuk mengira jumlah. Akhir sekali, dalam fungsi utama, kami mencipta kepingan FloatValue dan IntegerValue dan menyerahkannya kepada fungsi genericSum() yang mengira jumlah elemen dalam setiap kepingan dengan betul.
Output yang dijangkakan kini boleh dilihat pada skrin berikut:
Kesimpulan
Kami meneroka beberapa contoh praktikal Go generik yang termasuk penciptaan struktur data generik dan fungsi generik, mentakrifkan antara muka generik dan menggunakan kekangan jenis tersuai. Contoh-contoh ini menunjukkan kuasa dan fleksibiliti yang dibawa oleh generik kepada bahasa pengaturcaraan Go. Ambil perhatian bahawa penjanaan kod generik semasa penyusunan memastikan saiz binari dan masa penyusunan yang cekap.