Mga Halimbawa ng Golang Casting

Halimbawa 1: Golang Basic Type Casting

Magsimula tayo sa halimbawa ng direkta at pangunahing pag-cast sa Go dahil kailangan namin ng typecasting upang baguhin ang uri ng variable, kahit saan.

Dito, nagsisimula tayo sa pangunahing function sa pamamagitan ng pagdedeklara ng variable na pinangalanang 'x' ng uri ng 'int' at italaga ito na may halaga na 31. Pagkatapos, ang variable na 'y' ay idineklara gamit ang shorthand assignment operator na ':='. Ang uri ng 'y' ay awtomatikong tinutukoy mula sa expression sa kanang bahagi na resulta ng pag-convert ng 'x' sa isang 'float64'. Kaya, sa programang ito, ang halaga ng 'x' ay na-convert sa isang 'float64' at itinalaga sa 'y'.

Ang mga resulta na nakuha mula sa pangunahing pag-cast sa Go ay ipinapakita bilang mga sumusunod:

Halimbawa 2: Golang Implicit Type Casting

Hindi pinapayagan ang implicit na uri ng pag-cast sa pagitan ng iba't ibang uri. Ipinapatupad ng Go ang malakas na pag-type na nangangahulugang hindi kami maaaring direktang magtalaga o gumamit ng isang halaga ng isang uri bilang isa pang uri nang walang tahasang conversion. Sa mga sumusunod, sinusubukan naming gawin ang implicit na pag-cast na bumubuo ng pagbubukod ng Go:

Narito ang code na nagsisimula sa main() function kung saan ang isang 'integer' na variable ay idineklara na may 'int' na uri. Ang value na itinalaga sa variable na 'integer' ay 9.08 na isang floating-point na numero. Dahil sinusubukan naming magtalaga ng floating-point value nang direkta sa isang integer variable, nagreresulta ito sa isang error sa mismatch ng uri. Pagkatapos, ginagamit namin ang function na 'printf' mula sa package na 'fmt' para i-print ang value ng variable na 'integer' gamit ang '%g' format specifier.

Gaya ng inaasahan, hindi katanggap-tanggap sa Golang ang implicit na uri ng pag-cast. Ang nakaraang implicit na uri ng pag-cast ay bumubuo ng sumusunod na error:

Halimbawa 3: Golang Explicit Type Casting

Ang tahasang uri ng conversion ay nagbibigay-daan sa amin na ligtas na ma-convert ang mga halaga sa pagitan ng mga katugmang uri habang tahasang nagsasaad ng intensyon. Tinitiyak nito na alam namin ang uri ng conversion at nakakatulong na maiwasan ang hindi sinasadyang mga error sa uri. Isaalang-alang ang sumusunod na tahasang pag-cast:

Dito, ang isang variable na 'floatVal' ay nilikha gamit ang uri ng 'float32', at ito ay itinalaga ang '6.75' na halaga. Pagkatapos, ang isang variable na 'intVal' ay ipinahayag na may uri ng 'int'. Upang italaga ang halaga ng floatVal sa intVal, ginagamit ang uri ng conversion. Upang gawing integer value ang floatVal, ginagamit ang function na 'int' kasama ang floatVal bilang input. Pagkatapos nito, ang 'fmt.Printf('Float Value is %g\n', floatVal)' ay nagpi-print ng value ng floatVal gamit ang %g format specifier na angkop para sa pag-print ng mga floating-point value. Habang ang linya ng code na 'fmt.Printf('Integer Value is %d', intVal)' ay nagpi-print ng value ng intVal gamit ang %d format specifier na angkop para sa pag-print ng mga integer value.

Ang sumusunod na output ay bumubuo ng mga halaga para sa parehong floatVal at intVal pagkatapos itong i-cast:

Halimbawa 4: Golang Type Casting para Makuha ang Average

Susunod, ginagawa namin ang pag-cast upang makuha ang average na numero mula sa mga ibinigay na halaga. Tingnan natin ang source code na ibinigay sa sumusunod:

Dito, una naming idineklara ang tatlong variable. Ang 'kabuuan' ay isang integer variable na pinasimulan sa halagang 900. Ang 'MyNumber' ay isang integer variable na pinasimulan sa halagang 20. Ang nakalkulang average ay iniimbak sa float32 na 'average' na variable. Ang average na pormula ay ibinibigay upang maisagawa ang pagkalkula. Upang matiyak na ang paghahati ay ginawa bilang isang floating-point division, ang mga halaga ng 'kabuuan' at 'MyNumber' ay kino-convert sa float32 gamit ang uri ng conversion. Ang kinakalkula na average ay itinalaga sa 'average' na variable. Panghuli, ang '%f\n' na format na string na ginagamit sa 'printf' na function ay tumutukoy na ang isang float value ay dapat na i-print, na sinusundan ng isang newline na character.

Ang resultang halaga bilang ang average ay kinukuha pagkatapos ipahiwatig ang uri ng pag-cast sa nakaraang code:

Halimbawa 5: Golang Int at String Type Casting

Bukod pa rito, nag-aalok din ang Go ng pag-cast sa pagitan ng mga uri ng Int at String. Magagawa natin ito gamit ang function ng strconv package.

Narito ang code na nagsisimula sa deklarasyon ng dalawang variable. Ang 'str' ​​ay isang string variable na pinasimulan sa value na '1999' at ang 'integer' ay isang integer variable na sinisimulan sa value na '1999'. Pagkatapos nito, ang function na 'strconv.Atoi()' ay ginagamit upang i-convert ang 'str' ​​string sa isang integer na halaga. Ang ibinalik na halaga ng 'v' ay kumakatawan sa na-convert na integer, at ang blangkong '_' na identifier ay ginagamit upang huwag pansinin ang anumang potensyal na error na ibinalik ng Atoi().

Susunod, ang strconv.Itoa() function ay ginagamit upang baguhin ang integer sa isang string value. Ang ibinalik na halaga na 'toStr' ay kumakatawan sa na-convert na string.

Ang output ay nagpapakita ng conversion mula sa '1999' string sa isang integer at pabalik sa isang string na gumagawa ng orihinal na halaga ng '1999':

Halimbawa 6: Uri ng Golang Casting sa Pagitan ng String at Bytes

Bukod dito, ang pag-cast sa Go ay maaari ding isagawa sa mga uri ng string at byte. Ang mga sumusunod na code ay nagpapakita ng conversion sa pagitan ng mga string at byte slice:

Dito, ang mga variable ay unang idineklara bilang 'myStr' at 'b1' na pinasimulan sa ilang mga halaga. Pagkatapos, kino-convert ng []byte(myStr) expression ang string na 'myStr' sa isang byte slice gamit ang uri ng conversion. Itinalaga nito ang nagresultang byte slice sa variable na 'b1'. Pagkatapos nito, iko-convert ng expression na 'string(b1)' ang byte slice b1 pabalik sa isang string gamit ang uri ng conversion. Itinalaga nito ang nagresultang string sa variable na 'toString'.

Ipinapakita ng output ang conversion sa pagitan ng string na 'Hey There' at ang katumbas nitong byte slice na representasyon sa sumusunod:

Halimbawa 7: Golang Type Casting para Makuha ang Square Root

Ngayon, ginagawa namin ang pag-cast sa Go upang mahanap ang mga resulta ng square root. Ang code ay inilalagay tulad ng sumusunod:

Dito, ang variable na 'n' ay idineklara bilang isang int at itinalaga ang halaga ng '144'. Ang variable na 'SqrtN' ay idineklara bilang isang float64 at iniimbak ang kinakalkula na square root ng 'n'. Pagkatapos, ang math.Sqrt() function ay i-deploy upang kalkulahin ang square root ng “n”. Dahil ang math.Sqrt() ay umaasa ng float64 argument, at ang value ng “n” ay na-convert sa float64 gamit ang float64(n). Pagkatapos noon, ang 'Square root ng %d ay %.2f\n' na format na string ay tumatawag sa function na 'printf' na tumutukoy ng integer value (%d) at floating-point value (%.2f). Tinitiyak ng '.2' na precision specifier sa '%.2f' na ang square root ay naka-print na may dalawang decimal na lugar.

Ang sumusunod na output ay kinukuha na nagpapahiwatig ng square root ng ibinigay na halaga:

Konklusyon

Ang paghahagis sa Go ay tinalakay na may mga natatanging halimbawa na lahat ay maipapatupad. Tandaan na sa Go, tahasan ang pag-typecast na nagpapatupad ng malakas na pag-type at nagpo-promote ng kalinawan at pagiging maaasahan ng code.