1. példa: Golang Basic Type Casting
Kezdjük a Go közvetlen és alapszintű öntésének példájával, mert a típusküldésre van szükségünk a változó típusának bárhol módosításához.
csomag fő-import (
'fmt'
)
func fő- () {
volt x int = 31
és := úszó64 ( x )
fmt . Println ( és )
}
Itt kezdjük a főfüggvénnyel egy „x” nevű „int” típusú változó deklarálásával, és 31-es értékkel rendeljük hozzá. Ezután az „y” változót a „:=” gyorsírási hozzárendelési operátor segítségével deklaráljuk. Az „y” típusát a rendszer automatikusan meghatározza a jobb oldalon lévő kifejezésből, ami az „x” „float64”-re való konvertálásának eredménye. Tehát ebben a programban az „x” értéke „float64”-re lesz konvertálva, és „y”-hez van rendelve.
A Go programban az alapcastingból lekért eredmények a következőképpen jelennek meg:
2. példa: Golang implicit típusú öntvény
Az implicit típusú öntvény nem megengedett a különböző típusok között. A Go erős gépelést kényszerít ki, ami azt jelenti, hogy nem tudunk közvetlenül hozzárendelni vagy használni az egyik típus értékét másik típusként explicit átalakítás nélkül. A következőkben megpróbáljuk végrehajtani az implicit öntést, amely kivételt generál a Go által:
csomag fő-
import 'fmt'
func fő- () {
volt egész szám int = 9 . 08
fmt . Printf ( 'Az egész szám %g' , egész szám )
}
Ez a kód, amely a main() függvénnyel kezdődik, ahol egy „integer” változót „int” típussal deklarálunk. Az „integer” változóhoz rendelt érték 9,08, ami egy lebegőpontos szám. Mivel egy lebegőpontos értéket próbálunk közvetlenül hozzárendelni egy egész változóhoz, ez típushibát eredményez. Ezután az „fmt” csomag „printf” függvényét használva kinyomtatjuk az „integer” változó értékét a „%g” formátummeghatározó használatával.
Ahogy az várható volt, az implicit típusú öntvény nem elfogadható Golangban. Az előző implicit típusú öntvény a következő hibát generálja:
3. példa: Golang Explicit Type Casting
Az explicit típuskonverzió lehetővé teszi számunkra, hogy biztonságosan konvertáljuk az értékeket a kompatibilis típusok között, miközben kifejezetten kifejezzük a szándékunkat. Biztosítja, hogy tisztában legyünk a típusátalakítással, és segít megelőzni a véletlen típushibákat. Fontolja meg a következő explicit castingot:
csomag fő-import 'fmt'
func fő- () {
volt floatVal úszó32 = 6 . 75
volt intVal int = int ( floatVal )
fmt . Printf ( 'A lebegő érték %g \n ' , floatVal )
fmt . Printf ( 'Az egész szám %d' , intVal )
}
Itt egy „floatVal” változó jön létre „float32” típussal, és hozzárendeljük a „6.75” értéket. Ezután egy „intVal” változót deklarálunk „int” típussal. A floatVal értékének intValhoz rendeléséhez a típuskonverziót kell használni. A floatVal egész értékké alakításához az „int” függvényt floatVal bemenettel használjuk. Ezt követően az „fmt.Printf(“Float Value %g\n”, floatVal)” kiírja a floatVal értékét a %g formátumspecifikátor segítségével, amely alkalmas a lebegőpontos értékek nyomtatására. Míg az 'fmt.Printf('Integer Value is %d', intVal)' kódsor az intVal értékét írja ki a %d formátumspecifikátor használatával, amely alkalmas az egész értékek nyomtatására.
A következő kimenet generálja a floatVal és az intVal értékeket az öntést követően:
4. példa: Golang Type Casting az átlag eléréséhez
Ezután végezzük el az öntést, hogy a megadott értékekből megkapjuk az átlagos számot. Nézzük végig a forráskódot, amely a következőkben található:
csomag fő-import 'fmt'
func fő- () {
volt teljes int = 900
volt A számom int = húsz
volt átlagos úszó32
átlagos = úszó32 ( teljes ) / úszó32 ( A számom )
fmt . Printf ( 'Az átlag = %f \n ' , átlagos )
}
Itt először három változót deklarálunk. A „total” egy egész szám változó, amely 900-as értékkel van inicializálva. A „MyNumber” egy egész szám változó, amely 20-as értékkel inicializálódik. A kiszámított átlagot ezután a float32 „average” változója tárolja. Ezután megadjuk az átlagos képletet a számítás elvégzéséhez. Annak biztosítására, hogy az osztás lebegőpontos osztásként történjen, a „total” és a „MyNumber” értékeket float32-re konvertálják a típuskonverzió segítségével. A számított átlagot az „átlag” változóhoz rendeljük. Végül a „%f\n” formátumú karakterlánc, amelyet a „printf” függvényben használunk, meghatározza, hogy egy lebegő értéket kell kinyomtatni, amelyet egy újsor karakter követ.
Az eredményül kapott érték átlagként kerül leolvasásra, miután az előző kódban szereplő típus-öntvényre utal:
5. példa: Golang Int és String Type Casting
Ezenkívül a Go az Int és String típusok közötti castingot is kínálja. Ezt az strconv csomag függvényével érhetjük el.
csomag fő-import (
'fmt'
'strconv'
)
func fő- () {
volt str húr = '1999'
ban ben , _ := strconv . filmelőzetes ( s )
fmt . Println ( ban ben )
volt egész szám int = 1999
toStr := strconv . megfulladt ( egész szám )
fmt . Println ( toStr )
}
Itt van a kód, amely két változó deklarálásával kezdődik. Az „str” egy karakterlánc-változó, amelyet „1999” értékkel, az „integer” pedig egy „1999” értékkel inicializált egész szám változó. Ezt követően az „strconv.Atoi()” függvény az „str” karakterláncot egész értékké alakítja. A „v” visszaadott értéke a konvertált egész számot jelöli, az üres „_” azonosító pedig figyelmen kívül hagyja az Atoi() által visszaadott esetleges hibákat.
Ezután az strconv.Itoa() függvény az egész számot karakterlánc értékké alakítja. A „toStr” visszaadott érték a konvertált karakterláncot jelöli.
A kimenet megjeleníti az „1999” karakterlánc konverzióját egész számmá, majd vissza egy karakterláncra, amely az „1999” eredeti értékét adja:
6. példa: Golang típusú átküldés karakterlánc és bájtok között
Sőt, az öntvény Go-ban string és byte típusban is végrehajtható. A következő kódok a karakterláncok és bájtszeletek közötti konverziót mutatják be:
csomag fő-import (
'fmt'
)
func fő- () {
volt mystr húr = 'Halihó'
volt b1 [] byte = [] byte ( myStr )
fmt . Println ( b1 )
toString := húr ( b1 )
fmt . Println ( toString )
}
Itt a változókat először „myStr” és „b1” néven deklarálják, amelyeket bizonyos értékekkel inicializálnak. Ezután a []byte(myStr) kifejezés a „myStr” karakterláncot bájtszeletté alakítja a típuskonverzió segítségével. Az eredményül kapott bájtszeletet a „b1” változóhoz rendeli. Ezt követően a „string(b1)” kifejezés a b1 bájtszeletet a típuskonverzió segítségével visszaalakítja karakterláncsá. Az eredményül kapott karakterláncot a „toString” változóhoz rendeli.
A kimenet a „Hey There” karakterlánc és a megfelelő bájtszelet ábrázolása közötti konverziót mutatja a következőképpen:
7. példa: Golang Type Casting a négyzetgyök eléréséhez
Most a Go alkalmazásban végezzük az öntést, hogy megtaláljuk a négyzetgyök eredményét. A kód a következőképpen kerül elhelyezésre:
csomag fő-import (
'fmt'
'matematika'
)
func fő- () {
volt n int = 177
volt SqrtN úszó64
SqrtN = matematika . Sqrt ( úszó64 ( n ))
fmt . Printf ( '%d négyzetgyöke %.2f \n ' , n , SqrtN )
}
Itt az „n” változó intként van deklarálva, és hozzárendeli a „144” értéket. Az „SqrtN” változó float64-ként van deklarálva, és tárolja az „n” számított négyzetgyökét. Ezután a math.Sqrt() függvényt alkalmazzuk az „n” négyzetgyökének kiszámításához. Mivel a math.Sqrt() float64 argumentumot vár, és az „n” értéke float64-re konvertálódik a float64(n) használatával. Ezt követően a „%d négyzetgyöke %.2f\n” formátumú karakterláncot hív meg a „printf” függvényben, amely egy egész számot (%d) és egy lebegőpontos értéket (%.2f) ad meg. A „.2” precíziós specifikáció a „%.2f”-ben biztosítja, hogy a négyzetgyök két tizedesjegy pontossággal kerüljön nyomtatásra.
A következő kimenet kerül leolvasásra, amely az adott érték négyzetgyökét jelzi:
Következtetés
A Go-ban végzett öntést külön példákkal tárgyaljuk, amelyek mindegyike végrehajtható. Ne feledje, hogy a Go-ban a typecasting explicit, ami erőteljes gépelést kényszerít ki, és elősegíti a kód egyértelműségét és megbízhatóságát.