Tutustu Go-ohjelmointikielen heijastuksen käsitteeseen ja tutki sen tehokkaita kykyjä dynaamiseen koodin analysointiin ja manipulointiin.

Go-ohjelmointikieli on laajalti tunnettu ilmeisyydestään. Se on vahvasti kirjoitettu kieli, mutta silti antaa sovelluksille mahdollisuuden dynaamisesti käsitellä ja tarkastaa objekteja, mukaan lukien muuttujat, funktiot ja tyypit ajon aikana.

Heijastus on mekanismi, jota Go käyttää saavuttaakseen tämän kyvyn. Mitä heijastus sitten on, ja miten voit käyttää reflektiota Go-sovelluksissasi?

Mikä on heijastus?

Heijastus on ohjelman kykyä tutkia sen muuttujia ja rakennetta ja käsitellä niitä ajon aikana.

Reflection in Go on mekanismi, jonka kieli tarjoaa dynaamiseen tyyppien ja objektien käsittelyyn. Saatat joutua tutkimaan objekteja, päivittämään niitä, kutsumaan niiden menetelmiä tai jopa suorittamaan toimintoja, jotka liittyvät niiden tyyppeihin tietämättä niiden tyyppejä käännöshetkellä. Heijastus tekee tämän kaiken mahdolliseksi.

Gossa erilaisia ​​paketteja, mukaan lukien

instagram viewer
koodaus joka mahdollistaa sen työskentele JSONin kanssa, ja fmt, luottavat vahvasti konepellin alla olevaan heijastukseen tehtäviensä suorittamiseksi.

Heijastuspaketin ymmärtäminen Gossa

Golangin oppiminen Se voi olla haastavaa semantiikan ja tehokkaan ohjelmiston kehittämistä mahdollistavien pakettien ja menetelmien vankan kirjaston vuoksi.

The heijastaa paketti on yksi näistä monista paketeista. Se koostuu kaikista menetelmistä, joita tarvitset reflektoinnin toteuttamiseen Go-sovelluksissa.

Aloitaksesi heijastaa paketti, voit tuoda sen seuraavasti:

import"reflect"

Paketti määrittelee kaksi päätyyppiä, jotka luovat perustan pohdiskelulle Go: ssa: heijastaa. Tyyppi ja heijastaa. Arvo.

A Tyyppi on yksinkertaisesti Go-tyyppiä. heijastaa. Tyyppi on käyttöliittymä, joka koostuu erilaisista menetelmistä eri tyyppien tunnistamiseen ja niiden komponenttien tutkimiseen.

Toiminto minkä tahansa Go-objektin tyypin tarkistamiseksi, heijastaa. Tyyppi, hyväksyy minkä tahansa arvon (an käyttöliittymä{}) ainoana argumenttina ja palauttaa a heijastaa. Tyyppi arvo, joka edustaa objektin dynaamista tyyppiä.

Alla oleva koodi näyttää käytön heijastaa. Tyyppi:

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

Toinen tyyppi heijastaa paketti, heijastaa. Arvo voi sisältää minkä tahansa tyyppisen arvon. The heijastaa. Jonkin arvo toiminto hyväksyy minkä tahansa käyttöliittymä{} ja palauttaa käyttöliittymän dynaamisen arvon.

Tässä on esimerkki, joka näyttää, miten sitä käytetään heijastaa. Jonkin arvo tarkistaaksesi yllä olevat arvot:

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

Voit tarkistaa arvojen lajit ja tyypit käyttämällä Ystävällinen ja Tyyppi menetelmä näin:

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

Vaikka molempien funktiokutsujen tulos on sama, ne eroavat toisistaan. typeOfX2 on periaatteessa sama asia kuin typeOfX koska ne ovat molemmat dynaamisia heijastaa. Tyyppi arvot, mutta kindOfX on vakio, jonka arvo on tietty laji x, merkkijono.

Tästä syystä on olemassa rajallinen määrä erilaisia, kuten int, merkkijono, kellua, joukkojne., mutta tyyppejä on ääretön määrä, koska käyttäjän määrittämiä tyyppejä voi olla useita.

An käyttöliittymä{} ja a heijastaa. Arvo toimii lähes samalla tavalla, ne voivat sisältää minkä tahansa tyyppisiä arvoja.

Niiden välinen ero on siinä, kuinka tyhjä käyttöliittymä{} ei koskaan paljasta sen arvon alkuperäisiä toimintoja ja menetelmiä. Useimmiten sinun on siis tiedettävä arvon dynaaminen tyyppi ja käytettävä tyypin väitettä päästäksesi siihen (esim. i.(merkkijono), x.(int)jne.) ennen kuin voit suorittaa sen kanssa toimintoja.

Sitä vastoin a heijastaa. Arvo on menetelmiä, joilla voit tutkia sen sisältöä ja ominaisuuksia sen tyypistä riippumatta. Seuraavassa osiossa tarkastellaan näitä kahta tyyppiä käytännössä ja näytetään, kuinka ne ovat hyödyllisiä ohjelmissa.

Reflectionin käyttöönotto Go-ohjelmissa

Heijastus on hyvin laajaa ja sitä voidaan käyttää ohjelmassa milloin tahansa. Alla on joitain käytännön esimerkkejä, jotka osoittavat reflektoinnin käyttöä ohjelmissa:

  • Tarkista syvä tasa-arvo: heijastaa paketti tarjoaa DeepEqual toiminto kahden objektin arvojen syvälliseen tasa-arvoon tarkistamiseen. Esimerkiksi kaksi rakennetta ovat syvästi samanarvoisia, jos kaikilla niitä vastaavilla kentillä on samat tyypit ja arvot. Tässä esimerkkikoodi:
     // deep equality of two arrays
     arr1 := [...]int{1, 2, 3}
     arr2 := [...]int{1, 2, 3}
     fmt.Println(reflect.DeepEqual(arr1, arr2)) // true
  • Kopioi viipaleita ja taulukoita: Voit myös käyttää Go reflection API: ta kopioimaan yhden siivun tai taulukon sisällön toiseen. Näin:
     slice1 := []int{1, 2, 3}
     slice2 := []int{4, 5, 6}
     reflect.Copy(reflect.ValueOf(slice1), reflect.ValueOf(slice2))
     fmt.Println(slice1) // [4 5 6]
  • Yleisten funktioiden määrittely: Kielet, kuten TypeScript tarjota yleinen tyyppi, minkä tahansa, jota voit käyttää kaikentyyppisten muuttujien säilyttämiseen. Vaikka Gossa ei ole sisäänrakennettua yleistä tyyppiä, voit käyttää heijastusta yleisten toimintojen määrittämiseen. Esimerkiksi:
     // print the type of any value
     funcprintType(x reflect.Value) {
     fmt.Println("Value type:", x.Type())
     }
  • Struktuuritunnisteiden käyttö: Tunnisteita käytetään metatietojen lisäämiseen Go struct -kenttiin, ja monet kirjastot käyttävät niitä määrittämään ja manipuloimaan kunkin kentän toimintaa. Voit käyttää struct-tunnisteita vain heijastuksella. Seuraava esimerkkikoodi osoittaa tämän:
     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
  • Rajapintojen pohdintaa: On myös mahdollista tarkistaa, toteuttaako arvo käyttöliittymän. Tästä voi olla hyötyä, kun sinun on suoritettava ylimääräinen vahvistuskerros sovelluksesi vaatimusten ja tavoitteiden perusteella. Alla oleva koodi osoittaa, kuinka heijastus auttaa sinua tarkastamaan rajapintoja ja määrittämään niiden ominaisuuksia:
     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

Yllä olevat esimerkit ovat joitakin tapoja, joilla voit käyttää heijastusta todellisissa Go-ohjelmissasi. The heijastaa paketti on erittäin vankka ja voit oppia lisää sen ominaisuuksista virallisessa Mene pohtimaan dokumentointi.

Milloin pohdintaa ja suositellut käytännöt

Voi olla useita skenaarioita, joissa reflektio voi tuntua ihanteelliselta, mutta on tärkeää huomata, että reflektiolla on omat kompromissinsa ja se voi vaikuttaa ohjelmaan negatiivisesti, jos sitä ei käytetä asianmukaisesti.

Tässä on joitain huomioitavia asioita heijastuksesta:

  • Käytä heijastusta vain, jos et pysty ennalta määrittämään ohjelmassasi olevan objektin tyyppiä.
  • Heijastus voi heikentää sovelluksesi suorituskykyä, joten sinun tulee välttää sen käyttöä suorituskykykriittisiin toimintoihin.
  • Heijastus voi vaikuttaa myös koodisi luettavuuteen, joten et halua heittää sitä kaikkialle.
  • Harkinnan mukaan virheitä ei tallenneta käännöshetkellä, joten saatat altistaa sovelluksesi useammille ajonaikaisille virheille.

Käytä heijastusta tarvittaessa

Reflection on saatavilla monilla kielillä, mukaan lukien C# ja JavaScript, ja Go toteuttaa sovellusliittymän erinomaisesti. Go: n reflektoinnin suuri etu on se, että voit ratkaista ongelmia vähemmällä koodilla, kun hyödynnät kirjaston ominaisuuksia.

Tyyppiturvallisuus on kuitenkin ratkaisevan tärkeää luotettavan koodin varmistamiseksi, ja nopeus on toinen tärkeä tekijä sujuvan käyttökokemuksen kannalta. Tästä syystä sinun tulee käyttää heijastusta vasta vaihtoehtojen punnitsemisen jälkeen. Pyri pitämään koodisi luettavana ja optimaalisena.