Näide 1: Golangi põhitüüpi valamine
Alustame Go otsese ja põhiülekandmise näitega, sest muutuja tüübi muutmiseks igal pool on vaja tüübiedastust.
pakett peamineimportida (
'fmt'
)
func peamine () {
oli x int = 31
ja := ujuk64 ( x )
fmt . Println ( ja )
}
Siin alustame põhifunktsiooniga, deklareerides muutuja nimega “x” tüübiga “int” ja omistades sellele väärtuse 31. Seejärel deklareeritakse muutuja “y”, kasutades stenogrammi määramise operaatorit “:=”. 'Y' tüüp määratakse automaatselt paremal pool oleva avaldise järgi, mis on 'x' teisendamisel 'float64'-ks. Niisiis, selles programmis teisendatakse 'x' väärtus väärtuseks 'float64' ja määratakse 'y'.
Go põhiülekandmiselt hangitud tulemused kuvatakse järgmiselt.
Näide 2: Golangi kaudse tüübi valamine
Kaudne tüübivalamine ei ole erinevate tüüpide vahel lubatud. Go jõustab tugevat tippimist, mis tähendab, et me ei saa ühe tüübi väärtust otse teise tüübina määrata ega kasutada ilma selgesõnalise teisenduseta. Järgnevalt proovime teostada kaudset ülekandmist, mis loob Go poolt erandi:
pakett peamine
importida 'fmt'
func peamine () {
oli täisarv int = 9 . 08
fmt . Printf ( 'Täisarv on %g' , täisarv )
}
Siin on kood, mis algab funktsiooniga main(), kus muutuja 'täisarv' deklareeritakse tüübiga 'int'. Muutujale 'täisarv' omistatud väärtus on 9,08, mis on ujukomaarv. Kuna proovime määrata ujukoma väärtuse otse täisarvulisele muutujale, on tulemuseks tüübi mittevastavuse viga. Seejärel kasutame funktsiooni 'printf' paketist 'fmt', et printida muutuja 'täisarv' väärtus, kasutades vormingu spetsifikaatorit '%g'.
Nagu oodatud, ei ole kaudne tüübivalamine Golangis vastuvõetav. Eelmine kaudse tüübi valamine tekitab järgmise vea:
Näide 3: Golangi selgesõnalise tüübi ülekandmine
Selgesõnaline tüübiteisendus võimaldab meil turvaliselt teisendada väärtusi ühilduvate tüüpide vahel, väljendades samal ajal selgesõnaliselt kavatsust. See tagab, et oleme tüübiteisendusest teadlikud ja aitab vältida juhuslikke tüübivigu. Kaaluge järgmist selgesõnalist ülekandmist:
pakett peamineimportida 'fmt'
func peamine () {
oli floatVal ujuk32 = 6 . 75
oli intVal int = int ( floatVal )
fmt . Printf ( 'Ujuv väärtus on %g \n ' , floatVal )
fmt . Printf ( 'Täisarv väärtus on %d' , intVal )
}
Siin luuakse muutuja 'floatVal' tüübiga 'float32' ja sellele määratakse väärtus '6,75'. Seejärel deklareeritakse muutuja 'intVal' tüübiga 'int'. FloatVal väärtuse määramiseks intVal-ile kasutatakse tüübiteisendust. FloatVal muutmiseks täisarvuks kasutatakse funktsiooni 'int' ja floatVal sisendiks. Pärast seda prindib 'fmt.Printf('Float Value on %g\n', floatVal)' floatVal väärtuse, kasutades %g vorminguspetsiifikat, mis sobib ujukomaväärtuste printimiseks. Kui koodirida “fmt.Printf(“Täisarv on %d”, intVal)” prindib intVal väärtuse, kasutades %d vorminguspetsiifikat, mis sobib täisarvu väärtuste printimiseks.
Järgmine väljund genereerib pärast ülekandmist nii floatVal kui ka intVal väärtused:
Näide 4: Golangi tüüpi ülekandmine keskmise saamiseks
Järgmisena teostame valamise, et saada etteantud väärtustest keskmine arv. Vaatame läbi lähtekoodi, mis on esitatud järgmises:
pakett peamineimportida 'fmt'
func peamine () {
oli kokku int = 900
oli MinuNumber int = kakskümmend
oli keskmine ujuk32
keskmine = ujuk32 ( kokku ) / ujuk32 ( MinuNumber )
fmt . Printf ( 'Keskmine on = %f \n ' , keskmine )
}
Siin deklareerime algselt kolm muutujat. 'Total' on täisarv muutuja, mis initsialiseeritakse väärtusega 900. 'MyNumber' on täisarv muutuja, mis initsialiseeritakse väärtusega 20. Arvutatud keskmine salvestatakse seejärel float32 'average' muutujasse. Seejärel antakse arvutamiseks keskmine valem. Tagamaks, et jagamine toimub ujukomajaotisena, teisendatakse tüübiteisendust kasutades väärtused “total” ja “MyNumber” väärtuseks float32. Arvutatud keskmine määratakse muutujale 'keskmine'. Lõpuks määrab funktsioonis 'printf' kasutatav vormingu string '%f\n', et printida tuleb ujuvväärtus, millele järgneb reavahetus.
Saadud väärtus keskmisena tuuakse pärast eelmises koodis tüübivaldamise vihjamist:
Näide 5: Golang Int ja String Type Casting
Lisaks pakub Go ka ülekandmist Int ja String tüüpide vahel. Seda saame teha paketi strconv funktsiooni abil.
pakett peamineimportida (
'fmt'
'strconv'
)
func peamine () {
oli str string = '1999'
sisse , _ := strconv . treiler ( s )
fmt . Println ( sisse )
oli täisarv int = 1999. aasta
toStr := strconv . uppus ( täisarv )
fmt . Println ( toStr )
}
Siin on kood, mis algab kahe muutuja deklaratsiooniga. 'str' on stringi muutuja, mis initsialiseeritakse väärtusega '1999' ja 'integer' on täisarv muutuja, mis initsialiseeritakse väärtusega '1999'. Pärast seda kasutatakse stringi stringi täisarvuks teisendamiseks funktsiooni 'strconv.Atoi()'. Tagastatud väärtus 'v' tähistab teisendatud täisarvu ja tühja identifikaatorit '_' kasutatakse mis tahes võimaliku vea ignoreerimiseks, mille Atoi() tagastab.
Järgmisena kasutatakse funktsiooni strconv.Itoa() täisarvu teisendamiseks stringiväärtuseks. Tagastatud väärtus, mis on 'toStr', tähistab teisendatud stringi.
Väljund kuvab teisenduse stringist „1999” täisarvuks ja tagasi stringiks, mis annab algse väärtuse „1999”.
Näide 6: Golangi tüübi ülekandmine stringi ja baitide vahel
Lisaks saab Go-s valamist teostada ka stringi- ja baiditüüpides. Järgmised koodid näitavad stringide ja baidilõikude vahelist teisendamist:
pakett peamineimportida (
'fmt'
)
func peamine () {
oli mystr string = 'Tere seal'
oli b1 [] bait = [] bait ( myStr )
fmt . Println ( b1 )
toString := string ( b1 )
fmt . Println ( toString )
}
Siin deklareeritakse muutujad esmalt kui 'myStr' ja 'b1', mis initsialiseeritakse teatud väärtustega. Seejärel teisendab avaldis []byte(myStr) stringi 'myStr' tüübiteisendust kasutades baidilõiguks. See määrab saadud baidilõigu muutujale 'b1'. Pärast seda teisendab avaldis 'string(b1)' baidilõigu b1 tagasi stringiks, kasutades tüübiteisendust. See määrab saadud stringi muutujale 'toString'.
Väljund näitab teisendust stringi 'Hey There' ja sellele vastava baidilõigu esituse vahel järgmiselt:
Näide 7: Golangi tüüpi valamine ruutjuure saamiseks
Nüüd teeme ruutjuure tulemuste leidmiseks valamise rakenduses Go. Kood paigutatakse järgmiselt:
pakett peamineimportida (
'fmt'
'matemaatika'
)
func peamine () {
oli n int = 177
oli SqrtN ujuk64
SqrtN = matemaatika . Sqrt ( ujuk64 ( n ))
fmt . Printf ( '%d ruutjuur on %.2f \n ' , n , SqrtN )
}
Siin deklareeritakse muutuja 'n' kui int ja see määrab väärtuse '144'. Muutuja 'SqrtN' deklareeritakse kui float64 ja see salvestab 'n' arvutatud ruutjuure. Seejärel võetakse kasutusele funktsioon math.Sqrt(), et arvutada n ruutjuur. Kuna math.Sqrt() eeldab float64 argumenti ja väärtus “n” teisendatakse float64-ks, kasutades float64(n). Pärast seda kutsub '%d ruutjuur %.2f\n' vormingu stringi väljakutse funktsioonis 'printf', mis määrab täisarvu (%d) ja ujukoma väärtuse (%.2f). Täpsusspetsifikaat '.2' failis '%.2f' tagab, et ruutjuur trükitakse kahe kümnendkohaga.
Tõmbatakse järgmine väljund, mis näitab antud väärtuse ruutjuurt:
Järeldus
Go castingut arutatakse erinevate näidetega, mis kõik on käivitatavad. Pidage meeles, et Go puhul on tüübiülekanne selgesõnaline, mis sunnib tugevat tippimist ning edendab koodi selgust ja usaldusväärsust.