Exemple de turnare Golang

Exemple De Turnare Golang



Procesul de modificare a tipului de date al unei valori de la un tip la altul este cunoscut sub numele de tip casting, uneori cunoscut sub numele de conversie de tip. Castarea tipului se realizează în Go utilizând conversiile explicite ale tipului. Go acceptă tastarea puternică. Astfel, atunci când facem conversie între tipuri, trebuie să ne indicăm în mod explicit obiectivul. Acest lucru promovează siguranța tipului și scade probabilitatea erorilor de tastare. În acest articol, vom explora despre casting cu diferite tipuri în Go.

Exemplul 1: Turnare de tip Golang Basic

Să începem cu exemplul de casting direct și de bază în Go, deoarece avem nevoie de typecasting pentru a modifica tipul variabilei, oriunde.

pachet principal
import (
'fmt'
)
func principal () {
a fost X int = 31
și := float64 ( X )
fmt . Println ( și )
}

Aici, începem cu funcția principală prin declararea unei variabile numite „x” de tip „int” și atribuirea acesteia cu o valoare de 31. Apoi, variabila „y” este declarată folosind operatorul de atribuire scurtă „:=”. Tipul „y” este determinat automat din expresia din partea dreaptă care este rezultatul conversiei „x” la un „float64”. Deci, în acest program, valoarea lui „x” este convertită într-un „float64” și este atribuită lui „y”.







Rezultatele care sunt preluate din castingul de bază în Go sunt afișate după cum urmează:





Exemplul 2: Turnare tip implicit Golang

Turnarea de tip implicit nu este permisă între diferite tipuri. Go impune tastarea puternică, ceea ce înseamnă că nu putem atribui direct sau folosi o valoare de un tip ca alt tip fără conversie explicită. În cele ce urmează, încercăm să realizăm turnarea implicită care generează excepția prin Go:





pachet principal
import 'fmt'
func principal () {
a fost întreg int = 9 . 08
fmt . Printf ( „Numărul întreg este %g” , întreg )
}

Iată codul care începe cu funcția main() unde o variabilă „întreg” este declarată cu tipul „int”. Valoarea care este atribuită variabilei „întreg” este 9,08, care este un număr în virgulă mobilă. Deoarece încercăm să atribuim o valoare în virgulă mobilă direct unei variabile întregi, rezultă o eroare de nepotrivire de tip. Apoi, folosim funcția „printf” din pachetul „fmt” pentru a tipări valoarea variabilei „integer” folosind specificatorul de format „%g”.

După cum era de așteptat, turnarea de tip implicit nu este acceptabilă în Golang. Turnarea anterioară a tipului implicit generează următoarea eroare:



Exemplul 3: Casting de tip explicit Golang

Conversia explicită a tipului ne permite să convertim în siguranță valorile între tipuri compatibile, în timp ce declarăm în mod explicit o intenție. Ne asigură că suntem conștienți de conversia tipului și ajută la prevenirea erorilor accidentale de tip. Luați în considerare următoarea distribuție explicită:

pachet principal
import 'fmt'

func principal () {
a fost floatVal plutitor32 = 6 . 75
a fost intVal int = int ( floatVal )
fmt . Printf ( „Valoarea float este %g \n ' , floatVal )
fmt . Printf ( „Valoarea întregului este %d” , intVal )
}

Aici, o variabilă „floatVal” este creată cu tipul „float32” și i se atribuie valoarea „6.75”. Apoi, o variabilă „intVal” este declarată cu tipul „int”. Pentru a atribui valoarea floatVal la intVal, se folosește conversia tipului. Pentru a transforma floatVal într-o valoare întreagă, funcția „int” este utilizată cu floatVal ca intrare. După aceea, „fmt.Printf(„Valoarea flotantă este %g\n”, floatVal)” tipărește valoarea floatVal folosind specificatorul de format %g care este potrivit pentru tipărirea valorilor în virgulă mobilă. În timp ce linia de cod „fmt.Printf(„Valoarea întreagă este %d”, intVal)” tipărește valoarea intVal folosind specificatorul de format %d care este potrivit pentru tipărirea valorilor întregi.

Următoarea ieșire generează valorile atât pentru floatVal cât și pentru intVal după turnarea acestuia:

Exemplul 4: Casting de tip Golang pentru a obține media

În continuare, efectuăm turnarea pentru a obține numărul mediu din valorile date. Să trecem prin codul sursă care este furnizat în următoarele:

pachet principal
import 'fmt'
func principal () {
a fost total int = 900
a fost Numărul meu int = douăzeci
a fost in medie plutitor32
in medie = plutitor32 ( total ) / plutitor32 ( Numărul meu )
fmt . Printf ( „Media este = %f \n ' , in medie )
}

Aici, inițial declarăm trei variabile. „Total” este o variabilă întreagă care este inițializată cu valoarea 900. „MyNumber” este o variabilă întreagă care este inițializată cu valoarea 20. Media calculată este apoi stocată în variabila „medie” float32. Se dă apoi formula medie pentru a efectua calculul. Pentru a vă asigura că împărțirea se face ca o diviziune în virgulă mobilă, valorile „total” și „MyNumber” sunt convertite în float32 utilizând conversia tipului. Media calculată este atribuită variabilei „medie”. În cele din urmă, șirul de format „%f\n” care este utilizat în funcția „printf” specifică faptul că trebuie tipărită o valoare flotantă, urmată de un caracter newline.

Valoarea rezultată ca medie este preluată după implicarea tipului de turnare în codul anterior:

Exemplul 5: Turnare de tip Golang Int și String

În plus, Go oferă și casting între tipurile Int și String. Putem realiza acest lucru folosind funcția pachetului strconv.

pachet principal
import (
'fmt'
'strconv'
)
func principal () {
a fost str şir = '1999'
în , _ := strconv . remorcă ( s )
fmt . Println ( în )
a fost întreg int = 1999
toStr := strconv . înecat ( întreg )

fmt . Println ( toStr )
}

Iată codul care începe cu declararea a două variabile. „Str” este o variabilă șir care este inițializată cu valoarea „1999”, iar „întreg” este o variabilă întreagă care este inițializată cu valoarea „1999”. După aceea, funcția „strconv.Atoi()” este folosită pentru a converti șirul „str” într-o valoare întreagă. Valoarea returnată a lui „v” reprezintă întregul convertit, iar identificatorul „_” necompletat este folosit pentru a ignora orice eroare potențială returnată de Atoi().

În continuare, funcția strconv.Itoa() este folosită pentru a transforma întregul într-o valoare șir. Valoarea returnată care este „toStr” reprezintă șirul convertit.

Ieșirea afișează conversia de la șirul „1999” la un număr întreg și înapoi la un șir care produce valoarea inițială a „1999”:

Exemplul 6: Turnarea tip Golang între șir și octeți

Mai mult, turnarea în Go poate fi efectuată și în tipuri de șir și octeți. Următoarele coduri demonstrează conversia între șiruri și felii de octeți:

pachet principal
import (
'fmt'
)
func principal () {
a fost mystr şir = 'Hei acolo'
a fost b1 [] octet = [] octet ( myStr )
fmt . Println ( b1 )
toString := şir ( b1 )
fmt . Println ( toString )
}

Aici, variabilele sunt mai întâi declarate ca „myStr” și „b1” care sunt inițializate cu anumite valori. Apoi, expresia []byte(myStr) convertește șirul „myStr” într-o porțiune de octeți folosind conversia de tip. Acesta atribuie porțiunea de octeți rezultată variabilei „b1”. După aceea, expresia „șir(b1)” convertește porțiunea de octet b1 înapoi într-un șir folosind conversia tipului. Acesta atribuie șirul rezultat variabilei „toString”.

Ieșirea arată conversia dintre șirul „Hey There” și reprezentarea corespunzătoare a secțiunii de octeți în următoarele:

Exemplul 7: Turnarea tip Golang pentru a obține rădăcina pătrată

Acum, facem turnarea în Go pentru a găsi rezultatele rădăcinii pătrate. Codul este plasat astfel:

pachet principal
import (
'fmt'
'matematica'
)
func principal () {
a fost n int = 177
a fost SqrtN float64
SqrtN = matematica . sqrt ( float64 ( n ))
fmt . Printf ( „Rădăcina pătrată a lui %d este %.2f \n ' , n , SqrtN )
}

Aici, variabila „n” este declarată ca int și atribuie valoarea „144”. Variabila „SqrtN” este declarată ca float64 și stochează rădăcina pătrată calculată a lui „n”. Apoi, funcția math.Sqrt() este implementată pentru a calcula rădăcina pătrată a lui „n”. Deoarece math.Sqrt() așteaptă un argument float64, iar valoarea lui „n” este convertită în float64 folosind float64(n). După aceea, „Rădăcina pătrată a lui %d este %.2f\n” apelează șirul de format în funcția „printf” care specifică o valoare întreagă (%d) și o valoare în virgulă mobilă (%.2f). Specificatorul de precizie „.2” în „%.2f” asigură că rădăcina pătrată este imprimată cu două zecimale.

Este preluată următoarea ieșire care indică rădăcina pătrată a valorii date:

Concluzie

Castingul în Go este discutat cu exemple distincte care sunt toate executabile. Rețineți că în Go, tipărirea este explicită, ceea ce impune tastarea puternică și promovează claritatea și fiabilitatea codului.