Contoh 1: Casting Jenis Asas Golang
Mari kita mulakan dengan contoh penghantaran langsung dan asas dalam Go kerana kami memerlukan penghantaran taip untuk mengubah suai jenis pembolehubah, di mana-mana sahaja.
pakej utamaimport (
'fmt'
)
fungsi utama () {
adalah x int = 31
dan := terapung64 ( x )
fmt . Println ( dan )
}
Di sini, kita mulakan dengan fungsi utama dengan mengisytiharkan pembolehubah bernama 'x' jenis 'int' dan menetapkannya dengan nilai 31. Kemudian, pembolehubah 'y' diisytiharkan menggunakan operator tugasan singkatan ':='. Jenis 'y' ditentukan secara automatik daripada ungkapan di sebelah kanan yang merupakan hasil daripada menukar 'x' kepada 'float64'. Jadi, dalam program ini, nilai 'x' ditukar kepada 'float64' dan diberikan kepada 'y'.
Keputusan yang diambil daripada penghantaran asas dalam Go dipaparkan seperti berikut:
Contoh 2: Casting Jenis Tersirat Golang
Pemutus jenis tersirat tidak dibenarkan antara jenis yang berbeza. Go menguatkuasakan penaipan yang kuat yang bermaksud bahawa kami tidak boleh menetapkan atau menggunakan nilai satu jenis secara langsung sebagai jenis lain tanpa penukaran yang jelas. Dalam perkara berikut, kami cuba melakukan penghantaran tersirat yang menjana pengecualian oleh Go:
pakej utama
import 'fmt'
fungsi utama () {
adalah integer int = 9 . 08
fmt . Cetakanf ( 'Integer ialah %g' , integer )
}
Berikut ialah kod yang bermula dengan fungsi main() di mana pembolehubah 'integer' diisytiharkan dengan jenis 'int'. Nilai yang diberikan kepada pembolehubah 'integer' ialah 9.08 yang merupakan nombor titik terapung. Memandangkan kami cuba untuk menetapkan nilai titik terapung terus kepada pembolehubah integer, ia mengakibatkan ralat tidak padan jenis. Kemudian, kami menggunakan fungsi 'printf' daripada pakej 'fmt' untuk mencetak nilai pembolehubah 'integer' menggunakan penentu format '%g'.
Seperti yang dijangkakan, pemutus jenis tersirat tidak boleh diterima di Golang. Penghantaran jenis tersirat sebelumnya menjana ralat berikut:
Contoh 3: Casting Jenis Eksplisit Golang
Penukaran jenis eksplisit membolehkan kami menukar nilai antara jenis yang serasi dengan selamat sambil menyatakan niat secara eksplisit. Ia memastikan bahawa kami mengetahui penukaran jenis dan membantu mengelakkan ralat jenis tidak sengaja. Pertimbangkan pemutus eksplisit berikut:
pakej utamaimport 'fmt'
fungsi utama () {
adalah floatVal terapung32 = 6 . 75
adalah intVal int = int ( floatVal )
fmt . Cetakanf ( 'Nilai Terapung ialah %g \n ' , floatVal )
fmt . Cetakanf ( 'Nilai Integer ialah %d' , intVal )
}
Di sini, pembolehubah 'floatVal' dicipta dengan jenis 'float32', dan ia diberikan nilai '6.75'. Kemudian, pembolehubah 'intVal' diisytiharkan dengan jenis 'int'. Untuk menetapkan nilai floatVal kepada intVal, penukaran jenis digunakan. Untuk mengubah floatVal menjadi nilai integer, fungsi 'int' digunakan dengan floatVal sebagai input. Selepas itu, “fmt.Printf(“Nilai Terapung ialah %g\n”, floatVal)” mencetak nilai floatVal menggunakan penentu format %g yang sesuai untuk mencetak nilai titik terapung. Manakala baris kod “fmt.Printf(“Nilai Integer ialah %d”, intVal)” mencetak nilai intVal menggunakan penentu format %d yang sesuai untuk mencetak nilai integer.
Output berikut menjana nilai untuk floatVal dan intVal selepas menghantarnya:
Contoh 4: Casting Jenis Golang untuk Mendapatkan Purata
Seterusnya, kami melakukan pemutus untuk mendapatkan purata nombor daripada nilai yang diberikan. Mari kita lihat kod sumber yang disediakan dalam perkara berikut:
pakej utamaimport 'fmt'
fungsi utama () {
adalah jumlah int = 900
adalah Nombor saya int = dua puluh
adalah purata terapung32
purata = terapung32 ( jumlah ) / terapung32 ( Nombor saya )
fmt . Cetakanf ( 'Purata ialah = %f \n ' , purata )
}
Di sini, kami pada mulanya mengisytiharkan tiga pembolehubah. 'Jumlah' ialah pembolehubah integer yang dimulakan dengan nilai 900. 'Nombor Saya' ialah pembolehubah integer yang dimulakan dengan nilai 20. Purata yang dikira kemudiannya disimpan dalam pembolehubah 'purata' float32. Formula purata kemudiannya diberikan untuk menjalankan pengiraan. Untuk memastikan pembahagian dilakukan sebagai pembahagian titik terapung, nilai 'jumlah' dan 'Nombor Saya' ditukar kepada float32 menggunakan penukaran jenis. Purata yang dikira diberikan kepada pembolehubah 'purata'. Akhir sekali, rentetan format '%f\n' yang digunakan dalam fungsi 'printf' menentukan bahawa nilai apungan harus dicetak, diikuti dengan aksara baris baharu.
Nilai terhasil sebagai purata diambil selepas membayangkan jenis penghantaran dalam kod sebelumnya:
Contoh 5: Golang Int dan Jenis String Casting
Selain itu, Go juga menawarkan penghantaran antara jenis Int dan String. Kita boleh mencapai ini menggunakan fungsi pakej strconv.
pakej utamaimport (
'fmt'
'strconv'
)
fungsi utama () {
adalah str tali = '1999'
dalam , _ := strconv . treler ( s )
fmt . Println ( dalam )
adalah integer int = 1999
kepadaStr := strconv . lemas ( integer )
fmt . Println ( kepadaStr )
}
Berikut ialah kod yang bermula dengan pengisytiharan dua pembolehubah. 'str' ialah pembolehubah rentetan yang dimulakan dengan nilai '1999' dan 'integer' ialah pembolehubah integer yang dimulakan dengan nilai '1999'. Selepas itu, fungsi 'strconv.Atoi()' digunakan untuk menukar rentetan 'str' kepada nilai integer. Nilai 'v' yang dikembalikan mewakili integer yang ditukar, dan pengecam '_' kosong digunakan untuk mengabaikan sebarang kemungkinan ralat yang dikembalikan oleh Atoi().
Seterusnya, fungsi strconv.Itoa() digunakan untuk mengubah integer kepada nilai rentetan. Nilai yang dikembalikan iaitu 'toStr' mewakili rentetan yang ditukar.
Output memaparkan penukaran daripada rentetan '1999' kepada integer dan kembali kepada rentetan yang menghasilkan nilai asal '1999':
Contoh 6: Casting Jenis Golang Antara Rentetan dan Bait
Selain itu, pemutus dalam Go juga boleh dilakukan dalam jenis rentetan dan bait. Kod berikut menunjukkan penukaran antara rentetan dan kepingan bait:
pakej utamaimport (
'fmt'
)
fungsi utama () {
adalah mystr tali = 'Hai Di sana'
adalah b1 [] bait = [] bait ( myStr )
fmt . Println ( b1 )
menjalin := tali ( b1 )
fmt . Println ( menjalin )
}
Di sini, pembolehubah pertama kali diisytiharkan sebagai 'myStr' dan 'b1' yang dimulakan dengan nilai tertentu. Kemudian, ungkapan []byte(myStr) menukar rentetan 'myStr' menjadi kepingan bait menggunakan penukaran jenis. Ia memberikan kepingan bait yang terhasil kepada pembolehubah 'b1'. Selepas itu, ungkapan 'rentetan(b1)' menukarkan kepingan bait b1 kembali kepada rentetan menggunakan penukaran jenis. Ia memberikan rentetan yang terhasil kepada pembolehubah 'toString'.
Output menunjukkan penukaran antara rentetan 'Hey There' dan perwakilan kepingan bait yang sepadan dalam perkara berikut:
Contoh 7: Tuangan Jenis Golang untuk Mendapatkan Punca Kuasa Dua
Sekarang, kami melakukan pemutus dalam Go untuk mencari hasil punca kuasa dua. Kod diletakkan seperti berikut:
pakej utamaimport (
'fmt'
'matematik'
)
fungsi utama () {
adalah n int = 177
adalah SqrtN terapung64
SqrtN = matematik . Sqrt ( terapung64 ( n ))
fmt . Cetakanf ( 'Punca kuasa dua %d ialah %.2f \n ' , n , SqrtN )
}
Di sini, pembolehubah 'n' diisytiharkan sebagai int dan memberikan nilai '144'. Pembolehubah 'SqrtN' diisytiharkan sebagai float64 dan menyimpan punca kuasa dua yang dikira 'n'. Kemudian, fungsi math.Sqrt() digunakan untuk mengira punca kuasa dua 'n'. Memandangkan math.Sqrt() menjangkakan hujah float64 dan nilai 'n' ditukar kepada float64 menggunakan float64(n). Selepas itu, panggilan rentetan format 'Punca kuasa dua %d ialah %.2f\n' dalam fungsi 'printf' yang menentukan nilai integer (%d) dan nilai titik terapung (%.2f). Penentu ketepatan '.2' dalam '%.2f' memastikan punca kuasa dua dicetak dengan dua tempat perpuluhan.
Output berikut diambil yang menunjukkan punca kuasa dua nilai yang diberikan:
Kesimpulan
Pemutus dalam Go dibincangkan dengan contoh berbeza yang semuanya boleh dilaksanakan. Perlu diingat bahawa dalam Go, taip adalah eksplisit yang menguatkuasakan penaipan yang kuat dan menggalakkan kejelasan dan kebolehpercayaan kod.