Ištirkite Go programavimo kalbos atspindžio sampratą, įsigilinkite į jos galingas dinaminės kodo analizės ir manipuliavimo galimybes.

Go programavimo kalba yra plačiai žinoma dėl savo išraiškingumo. Tai stipriai spausdinama kalba, tačiau vis tiek suteikia programoms galimybę dinamiškai manipuliuoti ir tikrinti objektus, įskaitant kintamuosius, funkcijas ir tipus vykdymo metu.

Atspindys yra mechanizmas, kurį Go naudoja šiam gebėjimui pasiekti. Kas tada yra atspindys ir kaip galite pritaikyti refleksiją savo Go programose?

Kas yra Refleksija?

Refleksija – tai programos gebėjimas ištirti jos kintamuosius ir struktūrą bei jais manipuliuoti vykdymo metu.

Reflection in Go yra mechanizmas, kurį kalba suteikia dinaminei manipuliacijai tipais ir objektais. Gali tekti ištirti objektus, juos atnaujinti, iškviesti jų metodus ar net atlikti operacijas, būdingas jų tipams, nežinant jų tipų kompiliavimo metu. Refleksijos leidžia visa tai padaryti.

Įvairūs „Go“ paketai, įskaitant kodavimas kuri leidžia jums dirbti su JSON, ir fmt, atlikdami savo pareigas, labai pasikliauja apmąstymais po gaubtu.

instagram viewer

„Go“ atspindžio paketo supratimas

Mokytis Golango gali būti sudėtinga dėl savo semantikos ir tvirtos paketų bei metodų bibliotekos, palengvinančios efektyvios programinės įrangos kūrimą.

The atspindėti paketas yra vienas iš daugelio paketų. Jį sudaro visi metodai, kurių reikia norint įgyvendinti atspindį „Go“ programose.

Norėdami pradėti su atspindėti paketą, galite tiesiog importuoti taip:

import"reflect"

Paketas apibrėžia du pagrindinius tipus, kurie sudaro pagrindą apmąstymams Go: atspindėti. Tipas ir atspindėti. Vertė.

A Tipas yra tiesiog Go tipas. atspindėti. Tipas yra sąsaja, susidedanti iš įvairių metodų skirtingiems tipams nustatyti ir jų komponentams ištirti.

Funkcija, skirta patikrinti bet kurio objekto tipą Go, atspindėti. Tipas, priima bet kokią vertę (an sąsaja{}) kaip vienintelį argumentą ir grąžina a atspindėti. Tipas reikšmė, nurodanti objekto dinaminį tipą.

Žemiau pateiktas kodas parodo naudojimą atspindėti. Tipas:

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

Antrasis tipas atspindėti paketas, atspindėti. Vertė gali turėti bet kokio tipo vertę. The atspindėti. Vertė funkcija priima bet kurią sąsaja{} ir grąžina sąsajos dinaminę vertę.

Štai pavyzdys, rodantis, kaip naudoti atspindėti. Vertė Norėdami patikrinti aukščiau nurodytas vertes:

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

Norėdami patikrinti verčių rūšis ir tipus, galite naudoti Malonus ir Tipas toks metodas:

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

Nors abiejų funkcijų iškvietimų rezultatas yra tas pats, jie skiriasi. TypeOfX2 iš esmės yra tas pats, kas TypeOfX nes jie abu yra dinamiški atspindėti. Tipas vertybes, bet kindOfX yra konstanta, kurios reikšmė yra konkreti rūšis x, styga.

Štai kodėl yra ribotas skaičius rūšių, tokių kaip tarpt, styga, plūdė, masyvasir tt, bet begalinis tipų skaičius, nes gali būti keli vartotojo nustatyti tipai.

An sąsaja{} ir a atspindėti. Vertė veikia beveik taip pat, jie gali turėti bet kokio tipo reikšmes.

Skirtumas tarp jų slypi tuo, kaip tuščia sąsaja{} niekada neatskleidžia savo turimos vertės operacijų ir metodų. Taigi dažniausiai reikia žinoti dinaminį vertės tipą ir naudoti tipo tvirtinimą, kad jį pasiektumėte (t. y. i. (eilutė), x.(int)ir tt) prieš atlikdami su juo operacijas.

Priešingai, a atspindėti. Vertė yra metodai, kuriuos galite naudoti norėdami ištirti jo turinį ir savybes, neatsižvelgiant į jo tipą. Kitame skyriuje šie du tipai nagrinėjami praktiškai ir parodoma, kaip jie naudingi programose.

Refleksijos įgyvendinimas Go programose

Apmąstymas yra labai platus ir gali būti naudojamas programoje bet kuriuo metu. Žemiau pateikiami keli praktiniai pavyzdžiai, kurie parodo refleksijos naudojimą programose:

  • Patikrinkite gilią lygybę: atspindėti paketas suteikia DeepEqual funkcija, skirta dviejų objektų verčių gyliui lygybei patikrinti. Pavyzdžiui, dvi struktūros yra labai lygios, jei visi jų atitinkami laukai turi vienodus tipus ir reikšmes. Štai kodo pavyzdys:
     // deep equality of two arrays
     arr1 := [...]int{1, 2, 3}
     arr2 := [...]int{1, 2, 3}
     fmt.Println(reflect.DeepEqual(arr1, arr2)) // true
  • Nukopijuokite skiltis ir masyvus: Taip pat galite naudoti Go refleksijos API, kad nukopijuotumėte vienos pjūvio ar masyvo turinį į kitą. Štai kaip:
     slice1 := []int{1, 2, 3}
     slice2 := []int{4, 5, 6}
     reflect.Copy(reflect.ValueOf(slice1), reflect.ValueOf(slice2))
     fmt.Println(slice1) // [4 5 6]
  • Bendrųjų funkcijų apibrėžimas: Tokios kalbos kaip TypeScript pateikti bendrą tipą, bet koks, kurį galite naudoti bet kokio tipo kintamiesiems laikyti. Nors „Go“ nėra integruoto bendro tipo, galite naudoti atspindį bendroms funkcijoms apibrėžti. Pavyzdžiui:
     // print the type of any value
     funcprintType(x reflect.Value) {
     fmt.Println("Value type:", x.Type())
     }
  • Prieiga prie struktūrinių žymų: žymos naudojamos metaduomenims pridėti prie „Go struct“ laukų, o daugelis bibliotekų jas naudoja, kad nustatytų ir manipuliuotų kiekvieno lauko elgseną. Struktūrines žymas galite pasiekti tik su atspindžiu. Tai rodo šis pavyzdinis kodas:
     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
  • Apmąstymas apie sąsajas: Taip pat galima patikrinti, ar reikšmė įgyvendina sąsają. Tai gali būti naudinga, kai reikia atlikti papildomą patvirtinimo lygmenį, atsižvelgiant į jūsų programos reikalavimus ir tikslus. Toliau pateiktas kodas parodo, kaip atspindys padeda patikrinti sąsajas ir nustatyti jų savybes:
     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

Aukščiau pateikti pavyzdžiai yra keletas būdų, kaip galite naudoti atspindį savo realaus pasaulio Go programose. The atspindėti Paketas yra labai tvirtas ir daugiau apie jo galimybes galite sužinoti oficialiame puslapyje Eik reflektuoti dokumentacija.

Kada naudoti refleksiją ir rekomenduojamos praktikos

Gali būti keli scenarijai, kai atspindys gali atrodyti idealus, tačiau svarbu atkreipti dėmesį, kad atspindys turi savo kompromisų ir gali neigiamai paveikti programą, jei ji netinkamai naudojama.

Štai keletas dalykų, į kuriuos reikia atkreipti dėmesį apie refleksiją:

  • Turėtumėte naudoti atspindį tik tada, kai negalite iš anksto nustatyti objekto tipo savo programoje.
  • Atspindys gali sumažinti jūsų programos našumą, todėl nenaudokite jos našumui svarbioms operacijoms.
  • Atspindėjimas taip pat gali turėti įtakos kodo skaitomumui, todėl nenorite jo mėtyti visur.
  • Atsižvelgiant į tai, klaidos nėra fiksuojamos kompiliavimo metu, todėl gali būti, kad jūsų programai bus daugiau vykdymo laiko klaidų.

Kai reikia, naudokite atspindį

„Reflection“ galima naudoti daugeliu kalbų, įskaitant C# ir „JavaScript“, o „Go“ puikiai įgyvendina API. Pagrindinis „Go“ apmąstymų pranašumas yra tas, kad galite išspręsti problemas naudodami mažiau kodo, kai naudojate bibliotekos galimybes.

Tačiau tipo sauga yra labai svarbi norint užtikrinti patikimą kodą, o greitis yra dar vienas svarbus veiksnys, užtikrinantis sklandžią vartotojo patirtį. Štai kodėl turėtumėte naudoti atspindį tik įvertinę savo galimybes. Siekite, kad jūsų kodas būtų skaitomas ir optimalus.