Príklady odlievania Golang

Priklady Odlievania Golang



Proces zmeny typu údajov hodnoty z jedného typu na druhý je známy ako pretypovanie, niekedy známe ako konverzia typu. Pretypovanie sa vykonáva v Go pomocou explicitných typových konverzií. Go podporuje silné písanie. Preto pri prevode medzi typmi musíme výslovne uviesť náš cieľ. To podporuje bezpečnosť písania a znižuje pravdepodobnosť preklepov. V tomto článku sa pozrieme na casting s rôznymi typmi v Go.

Príklad 1: Odlievanie základného typu Golang

Začnime príkladom priameho a základného pretypovania v Go, pretože na úpravu typu premennej kdekoľvek potrebujeme typové obsadenie.

balík Hlavná
importovať (
'fmt'
)
func Hlavná () {
bol X int = 31
a := plavák64 ( X )
fmt . Println ( a )
}

Tu začneme s hlavnou funkciou deklarovaním premennej s názvom „x“ typu „int“ a priradíme jej hodnotu 31. Potom sa premenná „y“ deklaruje pomocou skratkového operátora priradenia „:=“. Typ „y“ sa automaticky určí z výrazu na pravej strane, ktorý je výsledkom prevodu „x“ na „float64“. Takže v tomto programe sa hodnota „x“ prevedie na „float64“ a priradí sa „y“.







Výsledky, ktoré sa načítajú zo základného prenášania v Go, sa zobrazia takto:





Príklad 2: Odlievanie implicitného typu Golang

Implicitné pretypovanie nie je povolené medzi rôznymi typmi. Go vynucuje silné písanie, čo znamená, že nemôžeme priamo priradiť alebo použiť hodnotu jedného typu ako iný typ bez explicitnej konverzie. V nasledujúcom texte sa pokúsime vykonať implicitné pretypovanie, ktoré generuje výnimku pomocou Go:





balík Hlavná
importovať 'fmt'
func Hlavná () {
bol celé číslo int = 9 . 08
fmt . Printf ( 'Celé číslo je %g' , celé číslo )
}

Tu je kód, ktorý začína funkciou main(), kde je premenná „celé číslo“ deklarovaná s typom „int“. Hodnota, ktorá je priradená premennej „integer“ je 9,08, čo je číslo s pohyblivou rádovou čiarkou. Keďže sa pokúšame priradiť hodnotu s pohyblivou rádovou čiarkou priamo celočíselnej premennej, výsledkom je chyba nesúladu typu. Potom pomocou funkcie „printf“ z balíka „fmt“ vytlačíme hodnotu premennej „integer“ pomocou špecifikátora formátu „%g“.

Ako sa očakávalo, implicitné pretypovanie nie je v Golangu prijateľné. Predchádzajúce pretypovanie implicitného typu generuje nasledujúcu chybu:



Príklad 3: Odlievanie explicitného typu Golang

Explicitná konverzia typov nám umožňuje bezpečne konvertovať hodnoty medzi kompatibilnými typmi a zároveň explicitne uviesť zámer. Zabezpečuje, že sme si vedomí konverzie typu a pomáha predchádzať náhodným chybám typu. Zvážte nasledujúce explicitné casting:

balík Hlavná
importovať 'fmt'

func Hlavná () {
bol floatVal plavák32 = 6 . 75
bol intVal int = int ( floatVal )
fmt . Printf ( 'Pohyblivá hodnota je %g.' \n ' , floatVal )
fmt . Printf ( 'Celočíselná hodnota je %d' , intVal )
}

Tu sa vytvorí premenná „floatVal“ s typom „float32“ a priradí sa jej hodnota „6,75“. Potom je deklarovaná premenná „intVal“ s typom „int“. Na priradenie hodnoty floatVal k intVal sa používa typová konverzia. Na transformáciu floatVal na celočíselné hodnoty sa používa funkcia „int“ s floatVal ako vstupom. Potom „fmt.Printf(“Float Value is %g\n”, floatVal)” vytlačí hodnotu floatVal pomocou špecifikátora formátu %g, ktorý je vhodný na tlač hodnôt s pohyblivou rádovou čiarkou. Kým riadok kódu „fmt.Printf(“Integer Value is %d”, intVal)” vytlačí hodnotu intVal pomocou špecifikátora formátu %d, ktorý je vhodný na tlač celočíselných hodnôt.

Nasledujúci výstup generuje hodnoty pre floatVal aj intVal po jeho pretypovaní:

Príklad 4: Casting typu Golang na získanie priemeru

Ďalej vykonáme odlievanie, aby sme získali priemerné číslo z daných hodnôt. Poďme si prejsť zdrojový kód, ktorý je uvedený v nasledujúcom texte:

balík Hlavná
importovať 'fmt'
func Hlavná () {
bol Celkom int = 900
bol Moje číslo int = dvadsať
bol priemer plavák32
priemer = plavák32 ( Celkom ) / plavák32 ( Moje číslo )
fmt . Printf ( 'Priemer je = %f \n ' , priemer )
}

Tu najprv deklarujeme tri premenné. „Total“ je celočíselná premenná, ktorá je inicializovaná hodnotou 900. „MyNumber“ je celočíselná premenná, ktorá je inicializovaná hodnotou 20. Vypočítaný priemer sa potom uloží do premennej float32 „average“. Potom je uvedený priemerný vzorec na vykonanie výpočtu. Aby sa zabezpečilo, že sa delenie vykoná ako delenie s pohyblivou rádovou čiarkou, hodnoty „total“ a „MyNumber“ sa skonvertujú na float32 pomocou konverzie typu. Vypočítaný priemer je priradený k premennej „priemer“. Nakoniec formátovací reťazec „%f\n“, ktorý sa používa vo funkcii „printf“, určuje, že sa má vytlačiť plávajúca hodnota, po ktorej bude nasledovať znak nového riadku.

Výsledná hodnota ako priemer sa získa po implikovaní typového pretypovania v predchádzajúcom kóde:

Príklad 5: Odlievanie typu Golang Int a typu strún

Okrem toho Go ponúka aj prenášanie medzi typmi Int a String. Môžeme to dosiahnuť pomocou funkcie balíka strconv.

balík Hlavná
importovať (
'fmt'
'strconv'
)
func Hlavná () {
bol str reťazec = '1999'
    v , _ := strconv . príves ( s )
fmt . Println ( v )
bol celé číslo int = 1999
toStr := strconv . utopil ( celé číslo )

fmt . Println ( toStr )
}

Tu je kód, ktorý začína deklaráciou dvoch premenných. „str“ je reťazcová premenná, ktorá je inicializovaná hodnotou „1999“ a „celé číslo“ je celočíselná premenná, ktorá je inicializovaná hodnotou „1999“. Potom sa použije funkcia „strconv.Atoi()“ na konverziu reťazca „str“ na celočíselné hodnoty. Vrátená hodnota „v“ predstavuje prevedené celé číslo a prázdny identifikátor „_“ sa používa na ignorovanie akejkoľvek potenciálnej chyby, ktorú vráti Atoi().

Ďalej sa použije funkcia strconv.Itoa() na transformáciu celého čísla na hodnotu reťazca. Vrátená hodnota, ktorá je „toStr“, predstavuje konvertovaný reťazec.

Výstup zobrazuje prevod z reťazca „1999“ na celé číslo a späť na reťazec, ktorý vytvára pôvodnú hodnotu „1999“:

Príklad 6: Prelievanie typu Golang medzi reťazec a bajty

Okrem toho sa casting v Go môže vykonávať aj v reťazcoch a typoch bajtov. Nasledujúce kódy demonštrujú konverziu medzi reťazcami a bajtovými rezmi:

balík Hlavná
importovať (
'fmt'
)
func Hlavná () {
bol mystr reťazec = 'Hej ty tam'
bol b1 [] byte = [] byte ( myStr )
fmt . Println ( b1 )
natiahnuť := reťazec ( b1 )
fmt . Println ( natiahnuť )
}

Tu sú premenné najprv deklarované ako „myStr“ a „b1“, ktoré sú inicializované určitými hodnotami. Potom výraz []byte(myStr) skonvertuje reťazec „myStr“ na bajtový rez pomocou konverzie typu. Výsledný bajtový rez priradí premennej „b1“. Potom výraz „string(b1)“ skonvertuje bajtový rez b1 späť na reťazec pomocou konverzie typu. Výsledný reťazec priradí premennej „toString“.

Výstup zobrazuje konverziu medzi reťazcom „Hey There“ a jeho zodpovedajúcou reprezentáciou bajtových rezov v nasledujúcom texte:

Príklad 7: Odlievanie typu Golang na získanie druhej odmocniny

Teraz vykonáme pretypovanie v Go, aby sme našli výsledky druhej odmocniny. Kód je umiestnený takto:

balík Hlavná
importovať (
'fmt'
'matematika'
)
func Hlavná () {
bol n int = 177
bol SqrtN plavák64
SqrtN = matematika . Sqrt ( plavák64 ( n ))
fmt . Printf ( 'Druhá odmocnina %d je %.2f \n ' , n , SqrtN )
}

Tu je premenná „n“ deklarovaná ako int a priraďuje jej hodnotu „144“. Premenná „SqrtN“ je deklarovaná ako float64 a ukladá vypočítanú druhú odmocninu z „n“. Potom sa nasadí funkcia math.Sqrt() na výpočet druhej odmocniny z „n“. Keďže math.Sqrt() očakáva argument float64 a hodnota „n“ sa skonvertuje na float64 pomocou float64(n). Potom reťazec formátu „Odmocnina %d je %.2f\n“ volá funkciu „printf“, ktorá špecifikuje celočíselnú hodnotu (%d) a hodnotu s pohyblivou rádovou čiarkou (%.2f). Špecifikátor presnosti „.2“ v „%.2f“ zaisťuje, že sa druhá odmocnina vytlačí s dvomi desatinnými miestami.

Načíta sa nasledujúci výstup, ktorý označuje druhú odmocninu danej hodnoty:

Záver

Casting v Go je diskutovaný s odlišnými príkladmi, ktoré sú všetky spustiteľné. Majte na pamäti, že v Go je pretypovanie explicitné, čo si vyžaduje silné písanie a podporuje jasnosť a spoľahlivosť kódu.