Lebih penting lagi, generik mempertahankan keamanan tipe Go yang kuat yang memungkinkan pemeriksaan tipe statis pada waktu kompilasi dan memastikan kebenaran tipe. Mereka memberikan penanganan kesalahan standar dalam kode generik yang meningkatkan kejelasan dan pemeliharaan. Selain itu, mereka memberikan penanganan kesalahan standar dalam kode generik yang meningkatkan kejelasan dan pemeliharaan. Dalam posting ini, kami akan memeriksa beberapa aplikasi dan contoh generik Go di dunia nyata.
Contoh 1: Menggunakan Fungsi Generik Golang
Salah satu kasus penggunaan utama untuk obat generik adalah membuat fungsi yang dapat beroperasi pada tipe yang berbeda. Di sini, kita menggunakan salah satu contoh di mana fungsi keliling generik digunakan.
kemasan utama
impor 'fmt'
fungsi lingkar [ R int | float32 ]( radius r ) {
C := 3 * 2 * radius
fmt . Println ( 'Lingkar umum adalah:' , C )
}
fungsi utama () {
dulu r1 int = 7
dulu r2 float32 = 7 . 5
lingkar ( r1 )
lingkar ( r2 )
}
Di awal kode sebelumnya, baris mengimpor paket 'fmt' yang menyediakan fungsi untuk I/O terformat, termasuk mencetak output ke konsol. Kemudian, kita mendefinisikan fungsi umum bernama 'keliling' yang mengambil radius parameter dari tipe umum 'r' yang dapat berupa 'int' atau 'float32'. Di dalam fungsi, ia menghitung keliling dengan mengalikan jari-jari dengan nilai konstanta “3” lalu mengalikannya dengan “2”. Terakhir, ia mencetak keliling yang dihitung menggunakan “fmt.Println”.
Selanjutnya, kita memiliki fungsi utama di mana dua variabel, r1 dan r2, dideklarasikan dan diberi nilai masing-masing 7 dan 7,5. Setelah itu, fungsi “keliling” dipanggil dua kali, meneruskan r1 dan r2 sebagai argumen.
Output menampilkan perhitungan dengan mencetak keliling lingkaran sebagai berikut:
Contoh 2: Menggunakan Antarmuka Generik Golang
Selain itu, obat generik Golang membantu kami dengan antarmuka mereka. Antarmuka di Go adalah alat vital untuk memfasilitasi penggunaan kembali kode dan polimorfisme. Dengan mengaktifkannya untuk berfungsi dengan banyak tipe, obat generik meningkatkan kekuatan antarmuka. Berikut ini adalah kode sumber antarmuka generik Golang:
kemasan utama
impor 'fmt'
jenis EmpAge antarmuka {
int64 | int32 | float32 | float64
}
fungsi newGenericFunc [ usia Usia ]( usia emp_Umur ) {
val := int ( emp_Age ) + 1
fmt . Println ( val )
}
fungsi utama () {
fmt . Println ( 'Usia Karyawan' )
dulu Umur1 int64 = 24
dulu Umur2 float64 = 25 . 5
newGenericFunc ( Umur1 )
newGenericFunc ( Umur2 )
}
Di kode sumber sebelumnya, kami mendefinisikan antarmuka bernama 'EmpAge' yang menentukan kemungkinan jenis usia karyawan. Antarmuka mencakup tipe int64, int32, float32, dan float64. Antarmuka ini memungkinkan fungsi 'generik' untuk menerima salah satu dari tipe ini sebagai argumen. Setelah itu, kami menggunakan fungsi generik bernama newGenericFunc yang mengambil parameter emp_Age dari tipe usia generik yang dapat berupa tipe apa pun yang memenuhi antarmuka EmpAge. Di dalam fungsi, itu mengubah emp_Age menjadi int dan menambahkannya 1 seperti yang ditunjukkan.
Selanjutnya, kita mendeklarasikan dua variabel, Age1 dan Age2, dan menetapkan nilai masing-masing 24 dan 25,5, dalam fungsi utama. Setelah itu, Age1 dan Age2 diteruskan sebagai parameter ke fungsi newGenericFunc yang mengalami eksekusi dua kali. Dengan ini, usia dinaikkan 1 dan menghasilkan nilai yang diperbarui.
Keluaran yang dihasilkan berikut ini adalah usia dari fungsi generik yang menggunakan antarmuka:
Contoh 3: Menggunakan Struktur Data Generik Golang
Selain itu, Go generik juga memberi kita kemampuan untuk membangun struktur data umum seperti tumpukan, antrean, dan daftar tertaut. Pertimbangkan penerapan tumpukan umum berikut ini:
impor 'fmt'jenis Tumpukan [ T apapun ] [] T
fungsi ( st * Tumpukan [ T ]) Dorongan ( barang T ) {
st = menambahkan ( * st , barang )
}
fungsi ( st * Tumpukan [ T ]) Pop () T {
jika hanya ( * st ) == 0 {
panik ( 'Tidak ada apa pun di Tumpukan' )
}
indeks := hanya ( * st ) - 1
barang := ( * st )[ indeks ]
* st = ( * st )[: indeks ]
kembali barang
}
fungsi utama () {
tumpukan := baru ( Tumpukan [ int ])
tumpukan . Dorongan ( 1 )
tumpukan . Dorongan ( 2 )
tumpukan . Dorongan ( 3 )
fmt . Println ( tumpukan . Pop ())
fmt . Println ( tumpukan . Pop ())
fmt . Println ( tumpukan . Pop ())
}
Dalam kode sebelumnya, tipe generik berjudul 'Stack' didefinisikan yang mewakili stack. Placeholder 'T' mengizinkan tumpukan untuk menampung elemen dari jenis apa pun. Tipe 'Stack' diimplementasikan sebagai irisan elemen tipe 'T'. Di sini, dua fungsi diterapkan untuk tipe 'Stack': 'Push' dan 'Pop'. Fungsi Push() bertanggung jawab untuk menambahkan elemen ke tumpukan. Dibutuhkan item argumen bertipe 'T' dan menambahkannya ke irisan yang mendasarinya menggunakan fungsi append().
Sementara fungsi Pop() mengambil komponen awal dari tumpukan dan mengembalikannya, pertama-tama ia menentukan apakah tumpukan kosong dengan mengevaluasi ukuran irisan yang mendasarinya. Notifikasi kesalahan dikirim jika tumpukan tampak kosong yang menyebabkan kepanikan. Jika tidak, ia mengambil elemen terakhir dari irisan, menghapusnya dari tumpukan dengan mengiris irisan hingga elemen kedua hingga terakhir, dan mengembalikan item yang dihapus.
Selanjutnya, tumpukan bilangan bulat baru dibuat menggunakan sintaks Stack[int] di dalam fungsi utama kode ini. Setelah itu, metode 'Push' dipanggil tiga kali untuk menambahkan bilangan bulat 1, 2, dan 3 ke stack. Namun, metode 'Pop' dipanggil tiga kali setelahnya untuk mengambil dan mencetak elemen dari tumpukan.
Keluaran berikut menunjukkan bahwa elemen dihapus dari tumpukan dalam urutan terbalik:
Contoh 4: Menggunakan Kendala Generik Golang
Go juga menawarkan batasan khusus yang memungkinkan fleksibilitas tinggi dan menentukan persyaratan khusus untuk konstruksi generik berdasarkan kebutuhan aplikasinya. Kode kendala generik kustom disediakan berikut ini untuk demonstrasi:
kemasan utamaimpor 'fmt'
jenis Numerik antarmuka {
int64 | float64
}
fungsi utama () {
FloatValue := [] float64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
NilaiInteger := [] int64 { 2 , 4 , 6 , 8 , 10 }
jumlah1 := generikSum ( FloatValue )
jumlah2 := generikSum ( NilaiInteger
fmt . Println ( 'Jumlah float64 :' , jumlah1 )
fmt . Println ( 'Jumlah int64 :' , jumlah2 )
}
fungsi generikSum [ n Numerik ]( angka [] N ) N {
dulu Saya n
untuk _ , pada satu := jangkauan angka {
jumlah += pada satu
}
kembali jumlah
}
Dalam kode sumber sebelumnya, kami mendefinisikan antarmuka Numerik dengan metode 'Jumlah'. Kemudian, kami membuat dua jenis kustom, 'FloatValue' dan 'IntegerValue', yang mengimplementasikan antarmuka Numerics dengan menyediakan metode 'Sum' masing-masing. Fungsi genericSum sekarang dapat menerima irisan dari jenis apa pun yang memenuhi antarmuka Numerik. Di dalam fungsi, kami mengulangi elemen dan memanggil metode 'Jumlah' untuk menghitung jumlahnya. Terakhir, dalam fungsi utama, kita membuat irisan FloatValue dan IntegerValue dan meneruskannya ke fungsi genericSum() yang menghitung dengan benar jumlah elemen di setiap irisan.
Output yang diharapkan sekarang terlihat di layar berikut:
Kesimpulan
Kita menjelajahi beberapa contoh praktis Go generik yang mencakup pembuatan struktur data generik dan fungsi generik, mendefinisikan antarmuka generik, dan menggunakan batasan tipe kustom. Contoh-contoh ini menunjukkan kekuatan dan fleksibilitas yang dibawa oleh generik ke bahasa pemrograman Go. Perhatikan bahwa pembuatan kode generik selama kompilasi memastikan ukuran biner dan waktu kompilasi yang efisien.