Hluboký ponor do reflexe na cestě

Programovací jazyk Go je široce známý pro svou expresivitu. Je to silně typovaný jazyk, ale stále dává aplikacím schopnost dynamicky manipulovat a kontrolovat objekty včetně proměnných, funkcí a typů za běhu.

Odraz je mechanismus, který Go používá k dosažení této schopnosti. Co je tedy reflexe a jak můžete reflexi použít ve svých aplikacích Go?

Co je odraz?

Reflexe je schopnost programu zkoumat své proměnné a strukturu a manipulovat s nimi za běhu.

Reflection in Go je mechanismus, který jazyk poskytuje pro manipulaci s dynamickým typem a objekty. Možná budete muset zkoumat objekty, aktualizovat je, volat jejich metody nebo dokonce provádět operace nativní pro jejich typy, aniž byste znali jejich typy v době kompilace. Reflexe toto vše umožňuje.

Různé balíčky v Go včetně kódování což vám umožňuje pracovat s JSON, a fmt, se při plnění svých povinností silně spoléhají na odraz pod kapotou.

Pochopení odrazového balíčku v Go

Učení Golangu může být náročný díky své sémantice a rozsáhlé knihovně balíčků a metod, které usnadňují vývoj efektivního softwaru.

The odrážet balíček je jedním z těchto mnoha balíčků. Skládá se ze všech metod, které potřebujete k implementaci reflexe v aplikacích Go.

Chcete-li začít s odrážet balíček, můžete jej jednoduše importovat takto:

import"reflect"

Balíček definuje dva hlavní typy, které pokládají základy reflexe v Go: odrážet. Typ a odrážet. Hodnota.

A Typ je prostě typ Go. odrážet. Typ je rozhraní, které se skládá z různých metod pro identifikaci různých typů a zkoumání jejich součástí.

Funkce pro kontrolu typu libovolného objektu v Go, odrážet. Typ, přijímá jakoukoli hodnotu (an rozhraní{}) jako svůj jediný argument a vrátí a odrážet. Typ hodnotu, která představuje dynamický typ objektu.

Níže uvedený kód ukazuje použití odrážet. Typ:

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

Druhý typ v odrážet balík, odrážet. Hodnota může obsahovat hodnotu jakéhokoli typu. The odrážet. Hodnota funkce přijímá jakékoli rozhraní{} a vrátí dynamickou hodnotu rozhraní.

Zde je příklad ukazující, jak používat odrážet. Hodnota pro kontrolu výše uvedených hodnot:

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

Chcete-li zkontrolovat druhy a typy hodnot, můžete použít Druh a Typ metoda takhle:

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

Přestože je výsledek obou volání funkcí stejný, jsou odlišné. typeOfX2 je v podstatě to samé jako typeOfX protože jsou oba dynamické odrážet. Typ hodnoty, ale druhX je konstanta, jejíž hodnota je konkrétní druh X, tětiva.

To je důvod, proč existuje konečný počet druhů jako např int, tětiva, plovák, pole, atd., ale nekonečný počet typů, protože může existovat několik typů definovaných uživatelem.

An rozhraní{} a a odrážet. Hodnota funguje téměř stejně, mohou obsahovat hodnoty jakéhokoli typu.

Rozdíl mezi nimi spočívá v tom, jak jsou prázdné rozhraní{} nikdy neodhaluje nativní operace a metody hodnoty, kterou má. Většinou tedy potřebujete znát dynamický typ hodnoty a pro přístup k ní použít aserci typu (tj. i. (řetězec), x. (int), atd.), než s ním budete moci provádět operace.

Naproti tomu a odrážet. Hodnota má metody, které můžete použít k prozkoumání jeho obsahu a vlastností, bez ohledu na jeho typ. Následující část zkoumá tyto dva typy prakticky a ukazuje, jak jsou užitečné v programech.

Implementace Reflection v Go programech

Reflexe je velmi široká a může najít využití v programu kdykoli v čase. Níže je uvedeno několik praktických příkladů, které demonstrují použití reflexe v programech:

• Zkontrolujte hlubokou rovnost: The odrážet balíček poskytuje DeepEqual funkce pro kontrolu hodnot dvou objektů do hloubky na rovnost. Například dvě struktury jsou hluboce stejné, pokud všechna jejich odpovídající pole mají stejné typy a hodnoty. Zde je příklad kódu:

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

• Kopírování řezů a polí: Můžete také použít rozhraní Go reflection API ke zkopírování obsahu jednoho řezu nebo pole do jiného. Zde je postup:

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

• Definování generických funkcí: Jazyky jako TypeScript poskytnout obecný typ, žádný, který můžete použít k uložení proměnných libovolného typu. I když Go nepřichází s vestavěným obecným typem, můžete použít reflexi k definování obecných funkcí. Například:

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

• Přístup ke značkám struct: Tagy se používají k přidávání metadat do polí Go struct a mnoho knihoven je používá k určení a manipulaci s chováním každého pole. Ke značkám struct máte přístup pouze s odrazem. Následující ukázkový kód to ukazuje:

   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
  

• Zamyšlení nad rozhraními: Je také možné zkontrolovat, zda hodnota implementuje rozhraní. To může být užitečné, když potřebujete provést nějakou další vrstvu ověřování na základě požadavků a cílů vaší aplikace. Níže uvedený kód ukazuje, jak vám reflexe pomáhá kontrolovat rozhraní a určovat jejich vlastnosti:

   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
  

Výše uvedené příklady představují několik způsobů, jak můžete použít reflexi ve vašich reálných programech Go. The odrážet balíček je velmi robustní a o jeho schopnostech se můžete dozvědět více v oficiálním Jdi se zamyslet dokumentace.

Kdy použít reflexi a doporučené postupy

Může existovat několik scénářů, kdy se reflexe může zdát ideální, ale je důležité si uvědomit, že reflexe má své vlastní kompromisy a může negativně ovlivnit program, pokud není správně používána.

Zde je několik věcí, které je třeba o reflexi poznamenat:

• Reflexi byste měli používat pouze tehdy, když nejste schopni předem určit typ objektu ve vašem programu.
• Odraz může snížit výkon vaší aplikace, takže byste se měli vyhnout jeho používání pro operace kritické pro výkon.
• Reflexe může také ovlivnit čitelnost vašeho kódu, takže se chcete vyhnout tomu, abyste ho všude házeli.
• Díky reflexi nejsou chyby zachyceny v době kompilace, takže můžete svou aplikaci vystavit většímu počtu chyb za běhu.

V případě potřeby použijte reflexi

Reflection je k dispozici v mnoha jazycích včetně C# a JavaScriptu a Go dělá dobře, že implementuje API skvěle. Hlavní výhodou reflexe v Go je, že můžete vyřešit problémy s menším množstvím kódu, když využijete schopnosti knihovny.

Typová bezpečnost je však zásadní pro zajištění spolehlivého kódu a rychlost je dalším důležitým faktorem pro bezproblémové uživatelské prostředí. To je důvod, proč byste měli reflexi používat až po zvážení svých možností. A snažte se, aby byl váš kód čitelný a optimální.