Примери за отливане на Golang

Пример 1: Отливане на основен тип Golang

Нека започнем с примера за директно и основно кастинг в Go, защото ние изискваме тип кастинг, за да променим типа на променливата навсякъде.

Тук започваме с основната функция, като декларираме променлива с име „x“ от тип „int“ и й присвояваме стойност 31. След това променливата „y“ се декларира с помощта на съкратения оператор за присвояване „:=“. Типът 'y' се определя автоматично от израза от дясната страна, който е резултат от преобразуването на 'x' в 'float64'. И така, в тази програма стойността на 'x' се преобразува в 'float64' и се присвоява на 'y'.

Резултатите, които се извличат от основното кастинг в Go, се показват, както следва:

Пример 2: Неявно прехвърляне на типове на Golang

Неявното преобразуване на типове не е разрешено между различни типове. Go налага силно въвеждане, което означава, че не можем директно да присвоим или използваме стойност от един тип като друг тип без изрично преобразуване. По-долу се опитваме да извършим имплицитното кастинг, което генерира изключението от Go:

Ето кода, който започва с функцията main(), където променлива „integer“ е декларирана с типа „int“. Стойността, която се присвоява на променливата 'integer', е 9.08, което е число с плаваща запетая. Тъй като се опитваме да присвоим стойност с плаваща запетая директно на целочислена променлива, това води до грешка при несъответствие на типа. След това използваме функцията “printf” от пакета “fmt”, за да отпечатаме стойността на променливата “integer”, като използваме спецификатора на формат “%g”.

Както се очакваше, имплицитното кастинг на типове не е приемливо в Golang. Предишното неявно преобразуване на тип генерира следната грешка:

Пример 3: Изрично прехвърляне на типове на Golang

Изричното преобразуване на тип ни позволява безопасно да преобразуваме стойностите между съвместими типове, докато изрично заявяваме намерение. Той гарантира, че сме наясно с преобразуването на типа и помага за предотвратяване на случайни грешки в типа. Помислете за следното изрично кастинг:

Тук се създава променлива „floatVal“ с тип „float32“ и й се присвоява стойността „6.75“. След това се декларира променлива „intVal“ с тип „int“. За да присвоите стойността на floatVal на intVal, се използва преобразуването на типа. За да трансформирате floatVal в цяло число, функцията 'int' се използва с floatVal като вход. След това „fmt.Printf(“Float Value is %g\n”, floatVal)” отпечатва стойността на floatVal с помощта на спецификатора на формат %g, който е подходящ за отпечатване на стойностите с плаваща запетая. Докато кодовият ред „fmt.Printf(„Цялата стойност е %d“, intVal)“ отпечатва стойността на intVal с помощта на спецификатора на формат %d, който е подходящ за отпечатване на целочислените стойности.

Следният изход генерира стойностите както за floatVal, така и за intVal след прехвърлянето му:

Пример 4: Кастиране на типа Golang за получаване на средната стойност

След това извършваме кастинга, за да получим средното число от дадените стойности. Нека да преминем през изходния код, който е предоставен в следното:

Тук първоначално декларираме три променливи. „Total“ е цяло число променлива, която се инициализира със стойност 900. „MyNumber“ е цяло число променлива, която се инициализира със стойност 20. След това изчислената средна стойност се съхранява в променливата float32 „average“. След това се дава средната формула за извършване на изчислението. За да се гарантира, че делението се извършва като деление с плаваща запетая, стойностите на „total“ и „MyNumber“ се преобразуват в float32 с помощта на преобразуването на типа. Изчислената средна стойност се присвоява на променливата „средно“. И накрая, форматиращият низ „%f\n“, който се използва във функцията „printf“, указва, че трябва да се отпечата стойност с плаваща задна буква, последвана от знак за нов ред.

Получената стойност като средна се извлича след загатване на преобразуването на типа в предишния код:

Пример 5: Golang Int и String Type Casting

Освен това Go предлага и кастинг между типове Int и String. Можем да постигнем това с помощта на функцията на пакета strconv.

Ето кода, който започва с декларацията на две променливи. „Str“ е низова променлива, която се инициализира със стойността „1999“, а „integer“ е цяло число, която се инициализира със стойността „1999“. След това функцията “strconv.Atoi()” се използва за преобразуване на низа “str” в целочислена стойност. Върнатата стойност на „v“ представлява преобразуваното цяло число, а празният идентификатор „_“ се използва за игнориране на всяка потенциална грешка, която се връща от Atoi().

След това функцията strconv.Itoa() се използва за трансформиране на цялото число в стойност на низ. Върнатата стойност, която е „toStr“, представлява преобразувания низ.

Резултатът показва преобразуването от низа „1999“ в цяло число и обратно в низ, който произвежда оригиналната стойност на „1999“:

Пример 6: Прехвърляне на тип Golang между низ и байтове

Освен това кастингът в Go може да се извърши и в типове низ и байт. Следните кодове демонстрират преобразуването между низове и байтове:

Тук променливите първо се декларират като “myStr” и “b1”, които се инициализират с определени стойности. След това изразът []byte(myStr) преобразува низа “myStr” в байтов отрязък, като използва преобразуването на типа. Той присвоява резултантния байт срез на променливата 'b1'. След това изразът „string(b1)“ преобразува байтовия отрязък b1 обратно в низ, използвайки преобразуването на типа. Той присвоява получения низ към променливата „toString“.

Резултатът показва преобразуването между низа „Hey There“ и съответстващото му представяне на байтов отрязък в следното:

Пример 7: Преобразуване на типа Golang за получаване на квадратен корен

Сега правим кастинг в Go, за да намерим резултатите от квадратния корен. Кодът се поставя, както следва:

Тук променливата 'n' е декларирана като int и присвоява стойността на '144'. Променливата “SqrtN” е декларирана като float64 и съхранява изчисления квадратен корен от “n”. След това функцията math.Sqrt() се внедрява за изчисляване на корен квадратен от „n“. Тъй като math.Sqrt() очаква аргумент float64 и стойността на „n“ се преобразува в float64 с помощта на float64(n). След това форматираният низ „Квадратният корен на %d е %.2f\n“ извиква функцията „printf“, която указва цяло число (%d) и стойност с плаваща запетая (%.2f). Спецификаторът за точност „.2“ в „%.2f“ гарантира, че квадратният корен се отпечатва с два знака след десетичната запетая.

Извлича се следният изход, който показва квадратния корен на дадената стойност:

Заключение

Кастингът в Go се обсъжда с различни примери, които са изпълними. Имайте предвид, че в Go преобразуването на типове е изрично, което налага силно въвеждане и насърчава яснотата и надеждността на кода.