Дубоко уроњење у рефлексију у Го

Програмски језик Го је надалеко познат по својој експресивности. То је јако куцани језик, али и даље даје апликацијама могућност да динамички манипулишу и прегледају објекте укључујући променљиве, функције и типове током времена извршавања.

Рефлексија је механизам који Го користи да би постигао ову способност. Шта је онда рефлексија и како можете применити рефлексију у својим Го апликацијама?

Шта је рефлексија?

Рефлексија је способност програма да испита своје варијабле и структуру и манипулише њима у току извршавања.

Рефлексија у Го је механизам који језик обезбеђује за динамичку манипулацију типом и објектом. Можда ћете морати да испитујете објекте, ажурирате их, позивате њихове методе или чак изводите операције које су изворне за њихове типове без познавања њихових типова у време компајлирања. Рефлексија све ово чини могућим.

Разни пакети у Го укључујући

кодирање што вам омогућава да рад са ЈСОН-ом, и фмт, у великој мери се ослањају на рефлексију испод хаубе да би обављали своје дужности.

Разумевање рефлекс пакета у Го

Леарнинг Голанг може бити изазован због своје семантике и робусне библиотеке пакета и метода које олакшавају развој ефикасног софтвера.

Тхе одразити пакет је један од ових многих пакета. Састоји се од свих метода које су вам потребне за имплементацију рефлексије у Го апликацијама.

Да бисте започели са одразити пакет, можете га једноставно увести овако:

import"reflect"

Пакет дефинише два главна типа који постављају основу за рефлексију у Го: одразити. Тип и одразити. Валуе.

А Тип је једноставно Го тип. одразити. Тип је интерфејс који се састоји од различитих метода за идентификацију различитих типова и испитивање њихових компоненти.

Функција за проверу типа било ког објекта у Го, одразити. Тип, прихвата било коју вредност (ан интерфејс{}) као једини аргумент и враћа а одразити. Тип вредност која представља динамички тип објекта.

Код испод показује употребу одразити. Тип:

x := "3.142"
y := 3.142
z := 3
typeOfX := reflect.TypeOf(x)
typeOfY := reflect.TypeOf(y)
typeOfZ := reflect.TypeOf(z)
fmt.Println(typeOfX, typeOfY, typeOfZ) // string float64 int

Други тип у одразити пакет, одразити. Валуе може да садржи вредност било које врсте. Тхе одразити. Вредност функција прихвата било коју интерфејс{} и враћа динамичку вредност интерфејса.

Ево примера који показује како се користи одразити. Вредност да проверите вредности изнад:

valueOfX := reflect.ValueOf(x)
valueOfY := reflect.ValueOf(y)
valueOfZ := reflect.ValueOf(z)
fmt.Println(valueOfX, valueOfY, valueOfZ) // 3.142 3.142 3

Да бисте проверили врсте и типове вредности, можете користити Врста и Тип метод овако:

typeOfX2 := valueOfX.Type()
kindOfX := valueOfX.Kind()
fmt.Println(typeOfX2, kindOfX) // string string

Иако је резултат оба позива функције исти, они су различити. типеОфКс2 је у основи иста ствар као типеОфКс јер су обоје динамични одразити. Тип вредности, али киндОфКс је константа чија је вредност специфична врста Икс, низ.

Због тога постоји коначан број врста као нпр инт, низ, пловак, низ, итд., али бесконачан број типова јер може постојати неколико типова које дефинише корисник.

Ан интерфејс{} и а одразити. Валуе ради скоро на исти начин, могу да садрже вредности било које врсте.

Разлика између њих лежи у томе како је празан интерфејс{} никада не открива изворне операције и методе вредности које има. Дакле, већину пута морате да знате динамички тип вредности и користите тврдњу типа да бисте јој приступили (тј. и.(стринг), к.(инт), итд.) пре него што можете да извршите операције са њим.

Насупрот томе, а одразити. Валуе има методе које можете користити да бисте испитали његов садржај и својства, без обзира на његов тип. Следећи одељак практично испитује ова два типа и показује колико су они корисни у програмима.

Имплементација Рефлецтион у Го програмима

Рефлексија је веома широка и може се користити у програму у било ком тренутку. Испод су неки практични примери који показују употребу рефлексије у програмима:

• Проверите дубоку једнакост: Тхе одразити пакет пружа ДеепЕкуал функција за проверу вредности два објекта по дубини на једнакост. На пример, две структуре су дубоко једнаке ако сва њихова одговарајућа поља имају исте типове и вредности. Ево примера кода:

   // deep equality of two arrays
   arr1 := [...]int{1, 2, 3}
   arr2 := [...]int{1, 2, 3}
   fmt.Println(reflect.DeepEqual(arr1, arr2)) // true
  

• Копирајте исечке и низове: Такође можете користити Го рефлексион АПИ за копирање садржаја једног пресека или низа у други. Ево како:

   slice1 := []int{1, 2, 3}
   slice2 := []int{4, 5, 6}
   reflect.Copy(reflect.ValueOf(slice1), reflect.ValueOf(slice2))
   fmt.Println(slice1) // [4 5 6]
  

• Дефинисање генеричких функција: Језици као што је ТипеСцрипт обезбедити генерички тип, било који, који можете користити за држање променљивих било ког типа. Иако Го не долази са уграђеним генеричким типом, можете користити рефлексију да дефинишете генеричке функције. На пример:

   // print the type of any value
   funcprintType(x reflect.Value) {
   fmt.Println("Value type:", x.Type())
   }
  

• Приступ ознакама структуре: Ознаке се користе за додавање метаподатака у поља структуре Го, а многе библиотеке их користе да одреде и манипулишу понашањем сваког поља. Можете приступити само струцт ознакама са рефлексијом. Следећи пример кода то демонстрира:

   type User struct {
   Name string`json:"name" required:"true"`
   }
   user := User{"John"}
   field, ok := reflect.TypeOf(user).Elem().FieldByName("Name")
   if !ok {
   fmt.Println("Field not found")
   }
   // print all tags, and value of "required"
   fmt.Println(field.Tag, field.Tag.Get("required"))
   // json:"name" required:"true" true
  

• Размишљајући о интерфејсима: Такође је могуће проверити да ли вредност имплементира интерфејс. Ово може бити корисно када треба да извршите неки додатни слој валидације на основу захтева и циљева ваше апликације. Код испод показује како вам рефлексија помаже да прегледате интерфејсе и одредите њихова својства:

   var i interface{} = 3.142
   typeOfI := reflect.TypeOf(i)
   stringerInterfaceType := reflect.TypeOf(new(fmt.Stringer))
   // check if i implements the stringer interface
   impl := typeOfI.Implements(stringerInterfaceType.Elem())
   fmt.Println(impl) // false
  

Горе наведени примери су неки од начина на које можете да користите рефлексију у својим Го програмима из стварног света. Тхе одразити пакет је веома робустан и можете сазнати више о његовим могућностима у званичном Иди размисли документацију.

Када користити рефлексију и препоручене праксе

Може постојати више сценарија у којима рефлексија може изгледати идеално, али важно је напоменути да рефлексија има своје компромисе и може негативно утицати на програм када се не користи на одговарајући начин.

Ево неколико ствари које треба напоменути о рефлексији:

• Требало би да користите рефлексију само када нисте у могућности да унапред одредите тип објекта у свом програму.
• Рефлекција може да смањи перформансе ваше апликације, тако да би требало да избегавате да је користите за операције које су критичне за перформансе.
• Рефлексија такође може утицати на читљивост вашег кода, тако да желите да избегнете да га бацате свуда.
• Уз размишљање, грешке се не хватају у време компајлирања, тако да можда излажете своју апликацију већем броју грешака током извршавања.

Користите рефлексију када је потребно

Рефлецтион је доступан на многим језицима, укључујући Ц# и ЈаваСцрипт, а Го одлично имплементира АПИ. Главна предност рефлексије у Го-у је то што можете решити проблеме са мање кода када искористите могућности библиотеке.

Међутим, безбедност типа је кључна за обезбеђивање поузданог кода, а брзина је још један важан фактор за глатко корисничко искуство. Због тога би требало да користите рефлексију тек након што одмерите своје могућности. И настојте да ваш код буде читљив и оптималан.