Příklad 1: Odlitek základního typu Golang
Začněme příkladem přímého a základního castingu v Go, protože vyžadujeme typ casting, abychom mohli změnit typ proměnné kdekoli.
balík hlavníimport (
'fmt'
)
func hlavní () {
byl X int = 31
a := plovák64 ( X )
fmt . Println ( a )
}
Zde začneme s hlavní funkcí deklarováním proměnné s názvem „x“ typu „int“ a přiřadíme jí hodnotu 31. Poté je proměnná „y“ deklarována pomocí zkráceného přiřazovacího operátoru „:=“. Typ „y“ je automaticky určen z výrazu na pravé straně, který je výsledkem převodu „x“ na „float64“. Takže v tomto programu je hodnota „x“ převedena na „float64“ a přiřazena k „y“.
Výsledky, které jsou načteny ze základního castingu v Go, se zobrazí následovně:
Příklad 2: Odlévání implicitního typu Golang
Mezi různými typy není povoleno implicitní přetypování. Go vynucuje silné psaní, což znamená, že nemůžeme přímo přiřadit nebo použít hodnotu jednoho typu jako jiný typ bez explicitní konverze. V následujícím se pokusíme provést implicitní přetypování, které generuje výjimku pomocí Go:
balík hlavní
import 'fmt'
func hlavní () {
byl celé číslo int = 9 . 08
fmt . Printf ( 'Celé číslo je %g' , celé číslo )
}
Zde je kód, který začíná funkcí main(), kde je proměnná „integer“ deklarována s typem „int“. Hodnota přiřazená proměnné „integer“ je 9,08, což je číslo s plovoucí desetinnou čárkou. Protože se pokoušíme přiřadit hodnotu s plovoucí desetinnou čárkou přímo celočíselné proměnné, výsledkem je chyba nesouladu typu. Poté pomocí funkce „printf“ z balíčku „fmt“ vytiskneme hodnotu proměnné „integer“ pomocí specifikátoru formátu „%g“.
Jak se očekávalo, implicitní přetypování není v Golangu přijatelné. Předchozí implicitní přetypování generuje následující chybu:
Příklad 3: Odlévání explicitního typu Golang
Explicitní převod typu nám umožňuje bezpečně převádět hodnoty mezi kompatibilními typy a přitom explicitně uvádět záměr. Zajišťuje, že jsme si vědomi převodu typu a pomáhá předcházet náhodným chybám typu. Zvažte následující explicitní casting:
balík hlavníimport 'fmt'
func hlavní () {
byl floatVal plovák32 = 6 . 75
byl intVal int = int ( floatVal )
fmt . Printf ( 'Pohyblivá hodnota je %g \n ' , floatVal )
fmt . Printf ( 'Celočíselná hodnota je %d' , intVal )
}
Zde je vytvořena proměnná „floatVal“ s typem „float32“ a je jí přiřazena hodnota „6.75“. Poté je deklarována proměnná „intVal“ s typem „int“. K přiřazení hodnoty floatVal k intVal se používá převod typu. K transformaci floatVal na celočíselnou hodnotu se použije funkce „int“ s floatVal jako vstupem. Poté „fmt.Printf(“Float Value is %g\n”, floatVal)” vytiskne hodnotu floatVal pomocí specifikátoru formátu %g, který je vhodný pro tisk hodnot s plovoucí desetinnou čárkou. Zatímco řádek kódu „fmt.Printf(“Integer Value is %d”, intVal)” vytiskne hodnotu intVal pomocí specifikátoru formátu %d, který je vhodný pro tisk celočíselných hodnot.
Následující výstup po přetypování generuje hodnoty pro floatVal i intVal:
Příklad 4: Obsazení typu Golang pro získání průměru
Dále provedeme odlévání, abychom získali průměrné číslo z daných hodnot. Pojďme si projít zdrojový kód, který je uveden v následujícím textu:
balík hlavníimport 'fmt'
func hlavní () {
byl celkový int = 900
byl Moje číslo int = dvacet
byl průměrný plovák32
průměrný = plovák32 ( celkový ) / plovák32 ( Moje číslo )
fmt . Printf ( 'Průměr je = %f \n ' , průměrný )
}
Zde nejprve deklarujeme tři proměnné. „Total“ je celočíselná proměnná, která je inicializována hodnotou 900. „MyNumber“ je celočíselná proměnná, která je inicializována hodnotou 20. Vypočítaný průměr je pak uložen do proměnné float32 „average“. Poté je uveden průměrný vzorec pro provedení výpočtu. Aby bylo zajištěno, že dělení bude provedeno jako dělení s plovoucí desetinnou čárkou, jsou hodnoty „total“ a „MyNumber“ převedeny na float32 pomocí převodu typu. Vypočtený průměr je přiřazen k proměnné „průměr“. Nakonec formátovací řetězec „%f\n“, který se používá ve funkci „printf“, určuje, že se má vytisknout plovoucí hodnota následovaná znakem nového řádku.
Výsledná hodnota jako průměr je načtena po implikaci přetypování v předchozím kódu:
Příklad 5: Odlévání typu Golang Int a typu strun
Kromě toho Go také nabízí casting mezi typy Int a String. Toho můžeme dosáhnout pomocí funkce balíčku strconv.
balík hlavníimport (
'fmt'
'strconv'
)
func hlavní () {
byl str tětiva = '1999'
v , _ := strconv . upoutávka ( s )
fmt . Println ( v )
byl celé číslo int = 1999
toStr := strconv . utopil ( celé číslo )
fmt . Println ( toStr )
}
Zde je kód, který začíná deklarací dvou proměnných. „str“ je řetězcová proměnná, která je inicializována hodnotou „1999“ a „celé číslo“ je celočíselná proměnná, která je inicializována hodnotou „1999“. Poté se použije funkce „strconv.Atoi()“ k převodu řetězce „str“ na celočíselnou hodnotu. Vrácená hodnota „v“ představuje převedené celé číslo a prázdný identifikátor „_“ se používá k ignorování jakékoli potenciální chyby, kterou vrací Atoi().
Dále je funkce strconv.Itoa() použita k transformaci celého čísla na hodnotu řetězce. Vrácená hodnota, která je „toStr“, představuje převedený řetězec.
Výstup zobrazuje převod z řetězce „1999“ na celé číslo a zpět na řetězec, který vytváří původní hodnotu „1999“:
Příklad 6: Přelévání typu Golang mezi řetězec a bajty
Přetypování v Go lze navíc provádět také v řetězcích a bajtech. Následující kódy demonstrují převod mezi řetězci a bajtovými řezy:
balík hlavníimport (
'fmt'
)
func hlavní () {
byl mystr tětiva = 'Nazdárek'
byl b1 [] byte = [] byte ( myStr )
fmt . Println ( b1 )
toString := tětiva ( b1 )
fmt . Println ( toString )
}
Zde jsou proměnné nejprve deklarovány jako „myStr“ a „b1“, které jsou inicializovány určitými hodnotami. Potom výraz []byte(myStr) převede řetězec „myStr“ na bajtový řez pomocí převodu typu. Výsledný bajtový řez přiřadí proměnné „b1“. Poté výraz „string(b1)“ převede bajtový řez b1 zpět na řetězec pomocí převodu typu. Výsledný řetězec přiřadí proměnné „toString“.
Výstup ukazuje převod mezi řetězcem „Hey There“ a jeho odpovídající reprezentací bajtového řezu v následujícím:
Příklad 7: Obsazení typu Golang pro získání druhé odmocniny
Nyní provedeme casting v Go, abychom našli výsledky druhé odmocniny. Kód je umístěn následovně:
balík hlavníimport (
'fmt'
'matematika'
)
func hlavní () {
byl n int = 177
byl SqrtN plovák64
SqrtN = matematika . Sqrt ( plovák64 ( n ))
fmt . Printf ( 'Druhá odmocnina z %d je %.2f \n ' , n , SqrtN )
}
Zde je proměnná „n“ deklarována jako int a přiřadí jí hodnotu „144“. Proměnná „SqrtN“ je deklarována jako float64 a ukládá vypočtenou druhou odmocninu z „n“. Poté je nasazena funkce math.Sqrt() k výpočtu druhé odmocniny z „n“. Protože math.Sqrt() očekává argument float64 a hodnota „n“ je převedena na float64 pomocí float64(n). Poté zavolá formátový řetězec „Druhá odmocnina %d %.2f\n“ funkci „printf“, která specifikuje celočíselnou hodnotu (%d) a hodnotu s pohyblivou řádovou čárkou (%.2f). Specifikátor přesnosti „.2“ v „%.2f“ zajišťuje, že se druhá odmocnina vytiskne se dvěma desetinnými místy.
Načte se následující výstup, který udává druhou odmocninu dané hodnoty:
Závěr
Casting v Go je diskutován s odlišnými příklady, které jsou všechny spustitelné. Mějte na paměti, že v Go je přetypování explicitní, což vynucuje silné psaní a podporuje srozumitelnost a spolehlivost kódu.