Golangas liešanas piemēri

Golangas Liesanas Piemeri



Vērtības datu veida maiņas process no viena veida uz citu ir pazīstams kā tipa izliešana, ko dažkārt sauc par tipa konvertēšanu. Veida apraide tiek veikta lietotnē Go, izmantojot precīzas tipa pārveidojumus. Go atbalsta spēcīgu rakstīšanu. Tādējādi, pārveidojot starp veidiem, mums ir skaidri jānorāda mūsu mērķis. Tas veicina rakstīšanas drošību un samazina drukas kļūdu iespējamību. Šajā rakstā mēs izpētīsim apraidi ar dažādiem Go veidiem.

1. piemērs: Golang pamata tipa liešana

Sāksim ar piemēru par tiešo un pamata apraidi pakalpojumā Go, jo mums ir nepieciešama tipa apraide, lai jebkurā vietā mainītu mainīgā veidu.

iepakojums galvenais
imports (
'fmt'
)
func galvenais () {
bija x starpt = 31
un := pludiņš64 ( x )
fmt . Println ( un )
}

Šeit mēs sākam ar galveno funkciju, deklarējot mainīgo ar nosaukumu “x” tipa “int” un piešķirot tam vērtību 31. Pēc tam mainīgais “y” tiek deklarēts, izmantojot īsraksta piešķiršanas operatoru “:=”. “Y” veids tiek automātiski noteikts pēc izteiksmes labajā pusē, kas ir rezultāts, pārvēršot “x” par “float64”. Tātad šajā programmā “x” vērtība tiek pārvērsta par “float64” un tiek piešķirta “y”.







Rezultāti, kas iegūti no Go pamata apraides, tiek parādīti šādi:





2. piemērs: Golang implicit Type Casting

Netieša tipa liešana starp dažādiem veidiem nav atļauta. Go nodrošina stingru rakstīšanu, kas nozīmē, ka mēs nevaram tieši piešķirt vai izmantot viena veida vērtību kā cita veida vērtību bez skaidras pārveidošanas. Tālāk mēs mēģinām veikt netiešo apraidi, kas ģenerē Go izņēmumu.





iepakojums galvenais
imports 'fmt'
func galvenais () {
bija vesels skaitlis starpt = 9 . 08
fmt . Printf ( 'Vesels skaitlis ir %g' , vesels skaitlis )
}

Šeit ir kods, kas sākas ar funkciju main (), kur mainīgais “vesels skaitlis” tiek deklarēts ar “int” veidu. Vērtība, kas tiek piešķirta mainīgajam “vesels skaitlis”, ir 9,08, kas ir peldošā komata skaitlis. Tā kā mēs cenšamies piešķirt peldošā komata vērtību tieši veselam mainīgajam, tas rada tipa neatbilstības kļūdu. Pēc tam mēs izmantojam funkciju “printf” no “fmt” pakotnes, lai izdrukātu “integer” mainīgā vērtību, izmantojot “%g” formāta specifikāciju.

Kā gaidīts, netiešā tipa liešana Golangā nav pieņemama. Iepriekšējā netiešā tipa izliešana rada šādu kļūdu:



3. piemērs: Golanga skaidra veida apraide

Skaidra tipa konvertēšana ļauj mums droši konvertēt vērtības starp saderīgiem veidiem, vienlaikus skaidri norādot nodomu. Tas nodrošina, ka esam informēti par tipa pārveidošanu un palīdz novērst nejaušas tipa kļūdas. Apsveriet tālāk norādīto precīzo apraidi.

iepakojums galvenais
imports 'fmt'

func galvenais () {
bija floatVal pludiņš32 = 6 . 75
bija intVal starpt = starpt ( floatVal )
fmt . Printf ( 'Peldošā vērtība ir %g \n ' , floatVal )
fmt . Printf ( 'Vesels skaitlis ir %d' , intVal )
}

Šeit tiek izveidots mainīgais “floatVal” ar tipu “float32”, un tam tiek piešķirta vērtība “6,75”. Pēc tam mainīgais “intVal” tiek deklarēts ar “int” tipu. Lai piešķirtu floatVal vērtību intVal, tiek izmantota tipa konvertēšana. Lai pārveidotu floatVal par veselu skaitli, funkcija “int” tiek izmantota ar floatVal ievadi. Pēc tam “fmt.Printf(“Float Value ir %g\n”, floatVal)” izdrukā floatVal vērtību, izmantojot %g formāta specifikāciju, kas ir piemērota peldošā komata vērtību drukāšanai. Kamēr koda rinda “fmt.Printf(“Integer Value ir %d”, intVal)” drukā intVal vērtību, izmantojot %d formāta specifikāciju, kas ir piemērota veselu skaitļu vērtību drukāšanai.

Tālāk norādītā izvade ģenerē gan floatVal, gan intVal vērtības pēc tā atrašanas:

4. piemērs. Golang tipa apraide, lai iegūtu vidējo

Tālāk mēs veicam liešanu, lai iegūtu vidējo skaitli no dotajām vērtībām. Apskatīsim tālāk norādīto avota kodu:

iepakojums galvenais
imports 'fmt'
func galvenais () {
bija Kopā starpt = 900
bija Mans numurs starpt = divdesmit
bija vidēji pludiņš32
vidēji = pludiņš32 ( Kopā ) / pludiņš32 ( Mans numurs )
fmt . Printf ( 'Vidējais ir = %f \n ' , vidēji )
}

Šeit mēs sākotnēji deklarējam trīs mainīgos. “Total” ir vesels mainīgais, kas tiek inicializēts ar vērtību 900. “MyNumber” ir vesels mainīgais, kas tiek inicializēts ar vērtību 20. Aprēķinātais vidējais tiek saglabāts mainīgajā float32 “average”. Pēc tam tiek dota vidējā formula, lai veiktu aprēķinu. Lai nodrošinātu, ka dalīšana tiek veikta kā peldošā komata dalījums, vērtības “total” un “MyNumber” tiek pārveidotas par float32, izmantojot tipa konvertēšanu. Aprēķinātais vidējais tiek piešķirts mainīgajam “vidējais”. Visbeidzot, “%f\n” formāta virkne, kas tiek izmantota funkcijā “printf”, norāda, ka ir jādrukā peldošā vērtība, kam seko jaunas rindiņas rakstzīme.

Rezultātā iegūtā vērtība kā vidējā vērtība tiek iegūta pēc tam, kad iepriekšējā kodā ir norādīts, ka veids ir noteikts:

5. piemērs: Golang Int un String Type Casting

Turklāt Go piedāvā arī apraidi starp Int un String veidiem. Mēs to varam paveikt, izmantojot strconv pakotnes funkciju.

iepakojums galvenais
imports (
'fmt'
'strconv'
)
func galvenais () {
bija str stīga = '1999'
iekšā , _ := strconv . piekabe ( s )
fmt . Println ( iekšā )
bija vesels skaitlis starpt = 1999. gads
toStr := strconv . noslīka ( vesels skaitlis )

fmt . Println ( toStr )
}

Šeit ir kods, kas sākas ar divu mainīgo lielumu deklarāciju. “str” ir virknes mainīgais, kas tiek inicializēts ar vērtību “1999”, un “integer” ir vesels skaitlis, kas inicializēts ar vērtību “1999”. Pēc tam funkcija “strconv.Atoi()” tiek izmantota, lai pārvērstu virkni “str” par veselu skaitli. Atgrieztā vērtība “v” apzīmē pārveidoto veselo skaitli, un tukšais “_” identifikators tiek izmantots, lai ignorētu visas iespējamās kļūdas, ko atgriež Atoi ().

Tālāk tiek izmantota funkcija strconv.Itoa(), lai pārveidotu veselu skaitli virknes vērtībā. Atgrieztā vērtība, kas ir “toStr”, apzīmē konvertēto virkni.

Izvade parāda pārvēršanu no virknes “1999” uz veselu skaitli un atpakaļ uz virkni, kas rada sākotnējo vērtību “1999”.

6. piemērs: Golang tipa apraide starp virkni un baitiem

Turklāt Go liešanu var veikt arī virkņu un baitu veidos. Šie kodi parāda konvertēšanu starp virknēm un baitu šķēlītēm:

iepakojums galvenais
imports (
'fmt'
)
func galvenais () {
bija mystr stīga = 'Sveiks'
bija b1 [] baits = [] baits ( myStr )
fmt . Println ( b1 )
toString := stīga ( b1 )
fmt . Println ( toString )
}

Šeit mainīgie vispirms tiek deklarēti kā “myStr” un “b1”, kas tiek inicializēti ar noteiktām vērtībām. Pēc tam izteiksme []byte(myStr) pārvērš “myStr” virkni baita daļā, izmantojot tipa konvertēšanu. Tas piešķir iegūto baita daļu mainīgajam “b1”. Pēc tam izteiksme “string(b1)” pārvērš baita šķēli b1 atpakaļ par virkni, izmantojot tipa konvertēšanu. Tas piešķir iegūto virkni mainīgajam “toString”.

Izvade parāda konversiju starp virkni 'Hey There' un tai atbilstošo baitu šķēlumu attēlojumu šādā veidā:

7. piemērs. Golang tipa apraide, lai iegūtu kvadrātsakni

Tagad mēs veicam liešanu programmā Go, lai atrastu kvadrātsaknes rezultātus. Kods tiek ievietots šādi:

iepakojums galvenais
imports (
'fmt'
'matemātika'
)
func galvenais () {
bija n starpt = 177
bija SqrtN pludiņš64
SqrtN = matemātika . Sqrt ( pludiņš64 ( n ))
fmt . Printf ( '%d kvadrātsakne ir %.2f \n ' , n , SqrtN )
}

Šeit mainīgais “n” tiek deklarēts kā int un piešķir vērtību “144”. Mainīgais “SqrtN” tiek deklarēts kā float64 un saglabā “n” aprēķināto kvadrātsakni. Pēc tam tiek izmantota funkcija math.Sqrt(), lai aprēķinātu “n” kvadrātsakni. Tā kā math.Sqrt() sagaida float64 argumentu, un vērtība “n” tiek pārveidota par float64, izmantojot float64(n). Pēc tam “%d kvadrātsakne ir %.2f\n” formāta virknes izsaukumus funkcijā “printf”, kas norāda vesela skaitļa vērtību (%d) un peldošā komata vērtību (%.2f). Precizitātes norāde “.2” failā “%.2f” nodrošina, ka kvadrātsakne tiek drukāta ar divām zīmēm aiz komata.

Tiek iegūta šāda izvade, kas norāda dotās vērtības kvadrātsakni:

Secinājums

Kasting programmā Go tiek apspriests ar atsevišķiem piemēriem, kas visi ir izpildāmi. Ņemiet vērā, ka lietotnē Go ir nepārprotama teksta apraide, kas nodrošina spēcīgu rakstīšanu un veicina koda skaidrību un uzticamību.