O autorovi překladu
Jan Mercl, autor překladu, pracuje v Laboratořích CZ.NIC jako programátor pro výzkum a vývoj.
Portál AbcLinuxu, 27. dubna 2024 22:47
Na oficiálním blogu jazyka Go se objevil další zajímavý a užitečnými informacemi nabitý článek (Rob Pike: „The Laws of Reflection“), který je níže přeložen do češtiny. Informace o typech dostupné za běhu programu jsou v Go srovnatelné s tím, co poskytují některé jiné programovací jazyky, a podobně též umožňují typy nejenom prozkoumávat, ale, v rámci jistých omezení, také např. vytvářet jejich instance. Tohoto tématu jsme se v seriálu dosud nedotkli.
Schopnost programu zkoumat svou vlastní strukturu, jmenovitě typy v programu deklarované, je formou metaprogramování a (nejenom) v Go se nazývá „reflection“ (reflexe). Reflection je také vděčným zdrojem zmatků a počátečních nepochopení.
Pokusem o ujasnění práce s Go reflection je tento článek. Modely reflection jsou v každém programovacím jazyce trochu jiné (a spoustu z nich reflection nemá vůbec), nicméně tento článek je o Go, takže význam reflection následujícím textu je „reflection v Go“.
Reflection je postaveno na systému typů, takže na začátek si zopakujme co o typech v Go už víme.
Go je staticky typovaný jazyk. Jakákoli proměnná má svůj statický typ, tedy právě jeden typ, který je pevně určen při kompilaci: int, float32, *MyType, []byte apod. Pokud deklarujeme
type MyInt int var i int var j MyInt
Pak i má typ int a j typ MyInt. Statické typy i a j jsou rozdílné, nelze je vzájemně přiřazovat, přestože se shodují v typu, ze kterého jsou typy i a j odvozené.
Důležitou kategorií typů jsou ty, které reprezentují pevnou množinu metod, tedy rozhraní. Hodnotou proměnné s typem rozhraní může být libovolná konkrétní hodnota (jiného typu, který sám není rozhraním), pokud tato hodnota implementuje všechny metody rozhraní (toho, který je typem oné proměnné). Dobře známým příkladem jsou rozhraní io.Reader a io.Writer, tedy typy Reader a Writer modulu io:
// Reader je rozhraní deklarující základní metodu Read.
type Reader interface {
Read(p []byte) (n int, err os.Error)
}
// Writer je rozhraní deklarující základní metodu Write.
type Writer interface {
Write(p []byte) (n int, err os.Error)
}
Rozhraní io.Reader (nebo io.Writer) je implementováno každým typem, který implementuje metodu Read (nebo Write) s výše uvedeným podpisem (method signature). V rámci tohoto výkladu to znamená, že proměnná typu io.Reader může obsahovat libovolnou hodnotu, jejíž typ implementuje metodu Read:
var r io.Reader r = os.Stdin r = bufio.NewReader(r) r = new(bytes.Buffer) // a tak dále
Ať už bude r obsahovat jakoukoli hodnotu, je důležité aby bylo jasné, že typem r je vždy io.Reader: Go je staticky typovaný jazyk a statickým typem r je io.Reader.
Prázdné rozhraní je typem rozhraní, které je mimořádně důležitým příkladem:
interface{}
Reprezentuje prázdnou množinu metod a protože jakýkoli typ má nulový nebo větší počet metod, je splněno libovolnou hodnotou.
Často můžete od některých lidí slyšet, že Go rozhraní mají dynamický typ, to je však zavádějící. Mají statický typ a proměnná typu rozhraní má vždy stejný statický typ. A přestože se za běhu programu může hodnota proměnné typu rozhraní měnit tak bude vždy splňovat rozhraní, které je statickým typem dané proměnné.
Bylo nutné si toto vše upřesnit, protože reflection a rozhraní jsou úzce propojeny.
Vnitřní reprezentaci Go rozhraní popsal Russ Cox detailně ve svém blog postu. Nemusíme tady nutně celý článek opakovat, ale zjednodušený souhrn je potřebný.
Proměnná typu rozhraní je dvojice: konkrétní hodnota přiřazená proměnné a deskriptor typu této hodnoty. Přesněji řečeno, hodnota jsou konkrétní data typu, který splňuje rozhraní a deskriptor určuje plně typ těchto dat. Například po
var r io.Reader
tty, err = os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil { return nil, err }
r = tty
zjednodušeně obsahuje r dvojici (hodnota, typ), v tomto případě (tty, *os.File). Všimněte si, že *os.File implementuje i jiné metody než Read přestože hodnota (r, typu rozhraní io.Reader) zpřístupňuje pouze metodu Read. Hodnota r ale má všechny informace o svém (skutečném/dynamickém – pozn. př.) typu. Díky tomu můžeme napsat třeba:
var w io.Writer w = r.(io.Writer)
Výraz na pravé straně přiřazení je ověření typu (type assertion). Ověřujeme zde, že hodnota uložená v r (taktéž) implementuje rozhraní io.Writer a že ji tedy můžeme přiřadit do w. Výsledkem přiřazení je, že w bude obsahovat dvojici (tty, *os.File). To je ovšem stejná dvojice, která byla uložena v r. Statický typ rozhraní určuje které metody můžeme pro danou proměnou typu rozhraní volat a není důležité, že hodnota v proměnné uložená může mít množinu metod větší.
Pokračujeme-li ve stejném duchu:
var empty interface{}
empty = w
tak proměnná empty bude zase obsahovat tu samou dvojici (tty, *os.File). To se hodí: prázdnému rozhraní (proměnné takového typu) můžeme přiřadit hodnotu jakéhokoli typu, ta si sebou stále ponese veškeré informace, které o této hodnotě a jejím typu budeme kdy potřebovat.
(Na tomto místě jsme nepotřebovali ověřit typ. To, že typ proměnné w splňuje prázdné rozhraní, je známo staticky. V předchozím případě, kdy jsme přiřazovali mezi proměnnou typu io.Reader a typu io.Writer, to bylo nutné vyjádřit explicitně, protože množina metod io.Writer není podmnožinou metod io.Reader)
Podstatným detailem je, že dvojice uvnitř rozhraní má vždy tvar (hodnota, konkrétní typ) a nemůže mít formu (hodnota, rozhraní [interface type]). Do proměnné typu rozhraní nelze uložit hodnotu typu rozhraní.
Nyní jsme připraveni si probrat reflection.
Mechanismus reflection je na své základní úrovni pouhým zkoumáním dvojice (hodnota, typ) uložené v rozhraní. Na úvod potřebujeme znát dva typy modulu reflect – Type a Value. Tyto dva typy zpřístupňují obsah rozhraní. Dvě jednoduché funkce reflect.TypeOf a reflect.ValueOf vracejí reflect.Type a reflect.Value typované hodnoty, získané z proměnné typu rozhraní. (Navíc je možné z reflect.Value snadno získat i reflect.Type, ale ponechme koncepty Value a Type zatím oddělené.)
Začněme s TypeOf:
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
fmt.Println("type:", reflect.TypeOf(x))
}
Tento program vypíše
type: float64
Možná se divíte – kde je tady nějaké rozhraní? Vypadá to přece tak, že program předává proměnnou x typu float64, nikoli hodnotu typu rozhraní funkci reflect.TypeOf. Ale rozhraní tam je. Jak vidno v dokumentaci, argumentem TypeOf je hodnota typu prázdného rozhraní.
// TypeOf returns the reflection Type of the value in the interface{}.
func TypeOf(i interface{}) Type
Při volání reflect.TypeOf(x) je x nejrpve uloženo do prázdného rozhraní, které je pak předáno jako argument, reflect.TypeOf pak z tohoto prázdného rozhraní vrátí informaci o typu x.
Funkce reflect.ValueOf pak pochopitelně vrací hodnotu (dále už vynecháváme opakující se kód a soustředíme se jen na důležitý kód)
var x float64 = 3.4
fmt.Println("value:", reflect.ValueOf(x))
vypíše
value: <float64 Value>
Jak reflect.Type tak reflect.Value mají hodně metod, které nám umožňují je zkoumat a manipulovat s nimi. Jedním z důležitých příkladů je, že Value má metodu Type, která vrací Type dané reflect.Value. Dalším je, že Type i Value mají metodu Kind, která vrací konstantu, příznak jakého druhu je hodnota v nich uložená: Uint, Float64, Slice atd. Dále metody Value s názvy jako Int nebo Float vracejí uložené hodnoty (typu int64 resp. Float64):
var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())
fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
fmt.Println("value:", v.Float())
vypíše
type: float64 kind is float64: true value: 3.4
Existují také metody jako SetInt a SetFloat, ale bychom je mohli použít musíme nejprve pochopit koncept „měnitelnosti“ (settability), který je předmětem třetího pravidla, to ale přijde na řadu později.
Některé vlastnosti modulu reflect stojí za poznámku. Za prvé, aby bylo API jednoduché, operují „getter“ a „setter“ metody Value na největším typu, do kterého je možné hodnotu uložit: např. int64 pro všechny celočíselné hodnoty se znaménkem. Takže metoda Int typu Value vrací int64 a argumentem metody SetInt je int64, je tedy možné, že bude třeba konverze na ten který typ se kterým skutečně pracujeme:
var x uint8 = 'x'
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type()) // uint8.
fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
x = uint8(v.Uint()) // v.Uint returns a uint64.
Další vlastností je, že Kind reflection objektu popisuje hodnotu obsaženou v proměnné typu rozhraní, nikoli statický typ onoho rozhraní. Pokud je tedy v reflection objektu uložena hodnota uživatelem definovaného typu jako v:
type MyInt int var x MyInt = 7 v := reflect.ValueOf(x)
pak v.Kind bude stále vracet reflect.Int přestože statický typ x je MyInt, nikoli int. Jinak řečeno, Kind neumí rozlišit int a MyInt ačkoli Type to samozřejmě umí.
Anglické slovo „reflection“ lze přeložit jako odraz. Tak jako odraz ve fyzice má „odraz“ v Go svou vlastní inverzi.
Máme-li reflect.Value, tak můžeme získat zpět hodnotu s typem rozhraní pomocí metody Interface, ve svém důsledku tato metoda znovu poskládá dvojici (hodnota, typ) do dříve popsané reprezentace rozhraní a tuto vrátí:
// Interface vrátí hodnotu v jako interface{}.
func (v Value) Interface() interface{}
Můžeme tedy psát
y := v.Interface().(float64) // y bude mít typ float64. fmt.Println(y)
pro vypsání float64 hodnoty reprezentovanou reflection objektem v.
Ale jde to i lépe. Argumenty fmt.Println, fmt.Printf apod. jsou předávány jako hodnoty prázdného rozhraní, které si potom modul fmt vnitřně rozbaluje přesně tak, jako jsme činili v předcházejících příkladech. Pro korektní vypsání hodnoty reflect.Value tedy stačí předat formátovacím funkcím výsledek metody Interface:
fmt.Println(v.Interface())
(Proč ne rovnou fmt.Println(v)? Kvůli tomu, že v je reflect.Value; chceme vypsat konkrétní hodnotu, která je ve v uložena.) Protože naše hodnota je typu float64, tak když budeme chtít, můžeme dokonce použít i formátování pro čísla v plovoucí čárce:
fmt.Printf("value is %7.1e\n", v.Interface())
a dostaneme v tomto případě
3.4e+00
Zopakujme, že není potřeba dělat ověření typu u výsledku v.Interface() na float64; hodnota typu prázdné rozhraní si s sebou specifickou informaci o obsaženém typu vždy nese a Printf si ji odtud získá.
Stručně řečeno – metoda Interface je opakem funkce ValueOf, odlišnost je jen v tom, že její výsledek má vždy statický typ interface{}.
Zopakujme: Cesta dat v reflection jde z hodnot typu rozhraní do reflection objektů a zase zpět
Třetí zákon je ze všeho nejvíc jen drobným upřesněním, současně je však i největším zdrojem zmatení. Nicméně jej snadno pochopíme, pokud začneme u prvotních principů.
Tady je kód, který nebude fungovat, ale stojí za prostudování.
var x float64 = 3.4 v := reflect.ValueOf(x) v.SetFloat(7.1) // Chyba: vyvolá výjimku (panic).
Pokud byste takový program spustili, uvidíte tajemnou hlášku
panic: reflect.Value.SetFloat using unaddressable value
Problém netkví v tom, že hodnota 7.1 není adresovatelná – potíž způsobuje, že v není měnitelné.
Metoda CanSet typu Value nám řekne, je-li Value měnitelné; v našem případě,
var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("settability of v:" , v.CanSet())
vypíše
settability of v: false
Volání metody Set u hodnoty Value, která není měnitelná, je chyba. Co je ona „měnitelnost“?
Je to téměř něco jako adresovatelnost, ale zpřísněná. Tato vlastnost říká, že reflection objekt smí přepisovat původní místo v paměti, které posloužilo k vytvoření reflection objektu. Měnitelnost je určena tím kterým reflection objektem, který „drží“ původní data. Když napíšeme
var x float64 = 3.4 v := reflect.ValueOf(x)
pak předáváme reflect.ValueOf kopii x, tedy hodnota typu rozhraní předaná reflect.ValueOf nese kopii x a nikoli x samotné. Pokud by tedy příkazu
v.SetFloat(7.1)
bylo „dovoleno“ fungovat, tak by novou hodnotu nenastavil proměnné x, ačkoli se v tváří, jako by bylo z x vytvořeno. Místo toho by došlo k nastavení hodnoty kopie x uvnitř reflection objektu a samo x by zůstalo nezměněno. To by bylo nejen k ničemu, ale i překvapující; je to tedy zakázáno a koncept měnitelnosti je určen právě k tomu, aby tyto potíže nenastávaly.
Zdá-li se vám to podivné, není tomu tak. Ve skutečnosti jde o známou situaci v novém hávu. Představte si předání x funkci:
f(x)
Neočekáváme, že f by mohla měnit x, protože jsme předali kopii hodnoty x, nikoli x samo. Pokud bychom od f chtěli měnit x, museli bychom naší funkci předat adresu x (čili ukazatel na x):
f(&x)
Toto považujeme za samozřejmost a známou věc; jenže reflection pracuje stejným způsobem. Jestliže chceme pomocí reflection x měnit, pak musíme reflection knihovně předat ukazatel na hodnotu, kterou chceme modifikovat:
Zkusme to. Nejprve nastavíme x jako obvykle a pak vytvoříme reflection objekt, který ukazuje na x, nazvěme jej p.
var x float64 = 3.4
p := reflect.ValueOf(&x) // Pozn.: ukazatel na x.
fmt.Println("type of p:", p.Type())
fmt.Println("settability of p:" , p.CanSet())
Zatím bude výstup
type of p: *float64 settability of p: false
Reflection objekt p není měnitelný, ale není to p, které chceme měnit, tím je (v důsledku) *p. Pomocí metody Elem typu Value se dostaneme k tomu, na co odkazuje p, a výsledek uložíme do proměnné v typu reflection.Value:
v := p.Elem()
fmt.Println("settability of v:" , v.CanSet())
Teď už je v měnitelný reflection objekt, jak vidíme z výpisu,
settability of v: true
a protože reprezentuje x, jsme konečně schopni použít v.SetFloat a změnit hodnotu x:
v.SetFloat(7.1) fmt.Println(v.Interface()) fmt.Println(x)
Výstup je dle očekávání
7.1 7.1
Reflection je možná obtížnější na pochopení, ale to co se děje je přesně totéž, jako běžně provádíme v Go. Jen je cesta nepřímá přes reflection objekty Type a Value, to může zastínit jak se věci odehrávají. Postačí si uvědomit, že reflection Value potřebuje ukazatel na něco, jedině pak je možné hodnotu, kterou Value reprezentuje, změnit.
V našich předcházejících příkladech nebylo v samo o sobě ukazatelem, bylo z něj pouze vytvořeno. Běžně se do takové situace dostáváme, když používáme reflection pro změny polí struktur. Měnit pole struktury můžeme, jestliže máme ukazatel na strukturu.
Tady je jednoduchý příklad, ve kterém prozkoumáváme hodnotu struktury t. Vytvoříme reflection objekt z ukazatele na strukturu, protože ji budeme chtít později měnit. Následně nastavíme typeOfT na typ struktury a budeme prostě procházet jednotlivá pole pomocí volání metod (podrobnosti v dokumentaci modulu reflect). Všimněte si, že získáváme jména polí z typu struktury, ale přístup k polím je přes normální reflect.Value objekty.
type T struct {
A int
B string
}
t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
f := s.Field(i)
fmt.Printf("%d: %s %s = %v\n", i,
typeOfT.Field(i).Name, f.Type(), f.Interface())
}
Výstupem tohoto programu je
0: A int = 23 1: B string = skidoo
Tím se dostáváme ještě k jedné poznámce o měnitelnosti: názvy polí T začínají velkým písmenem (jsou exportovaná), protože pouze taková pole jsou pomocí reflection měnitelná.
Díky tomu, že s je měnitelný reflection objekt, tak můžeme nastavovat hodnoty polí struktury.
s.Field(0).SetInt(77)
s.Field(1).SetString("Sunset Strip")
fmt.Println("t is now", t)
A tady je výsledek:
t is now {77 Sunset Strip}
Kdybychom program změnili tak, že s vytvoříme z t a nikoli &t, pak by volání SetInt a SetString selhala, protože pole t by nebyla měnitelná.
Zopakujme pravidla reflection:
Z hodnot typu rozhraní vytváříme reflection objekty.
Z reflection objektů vytváříme hodnoty typu rozhraní.
Nastavit hodnotu reprezentovanou reflection objektem můžeme jedině pokud je reflection objekt měnitelný.
Jakmile pochopíte tato pravidla reflection v Go, bude jeho použití o hodně snazší, přestože některé detaily mohou stále překvapit. Reflection je mocný nástroj a jako všechny takové nástroje by mělo být používáno s rozmyslem, a to jen tam, kde je to nezbytně nutné.
Kolem reflection je toho o hodně více, než jsme probrali — posílání a příjem u kanálů (channels), alokace paměti, používání řezů a map, volání metod a funkcí — jenže tento text je dlouhý už dost. K některým těmto tématům se vrátíme v pozdějším článku.
(Originální text v angličtině: vizte odkazy v záhlaví této české verze. Licence pro šíření: Creative Commons Attribution 3.0 License)
Jan Mercl, autor překladu, pracuje v Laboratořích CZ.NIC jako programátor pro výzkum a vývoj.
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.