Reflect reflect

The concept of reflection in programming languages

In the field of Computer Science , Reflection is a kind of application , They can describe and control themselves . in other words , This kind of application uses some mechanism to describe its behavior （self-representation） And monitoring （examination）, And according to the state and result of their own behavior , Adjust or modify the state and related semantics of the behavior described by the application .

Each language has a different reflection model , And some languages don't support reflection at all .Golang Language realizes reflection , Reflection mechanism is to dynamically call the methods and properties of objects at run time , official reflect Packages are reflection related , As long as you include this package, you can use .

One more sentence ,Golang Of gRPC It is also achieved through reflection .

interface and Reflection

Before we talk about reflection , First look at it. Golang Some principles about type design

• Variables include （type, value） Two parts
• type Include static type and concrete type. Simply speaking static type It's the type you see in coding ( Such as int、string),concrete type yes runtime The type the system sees
• Whether the type assertion can succeed , Depends on the of the variable concrete type, instead of static type. therefore , One reader Variable if its concrete type It has also been realized. write Method words , It can also be asserted by type as writer.

What's next Reflection , Is based on type ,Golang The type of the variable of the specified type is static （ That is to designate int、string These variables , its type yes static type）, It was determined when the variable was created , Reflection is mainly related to Golang Of interface Type related （ its type yes concrete type）, Only interface It's the type that reflects .

stay Golang In the implementation of , Every interface Variables have a corresponding pair,pair The value and type of the actual variable are recorded in :

(value, type)

value Is the actual variable value ,type Is the type of actual variable . One interface{} A variable of type contains 2 A pointer to the , A pointer to the type of value 【 Corresponding concrete type】, Another pointer points to the actual value 【 Corresponding value】.

for example , Creation type is *os.File The variable of , Then assign it to an interface variable r：

tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)

var r io.Reader
r = tty

Interface variables r Of pair The following information will be recorded ：(tty, *os.File), This pair It is constant during the continuous assignment of interface variables , Change interface variables r Assign to another interface variable w:

var w io.Writer
w = r.(io.Writer)

Interface variables w Of pair And r Of pair identical , All are :(tty, *os.File), Even if w Is an empty interface type ,pair It's the same .

interface And its pair The existence of , yes Golang The premise of realizing reflection in , I understand pair, It's easier to understand reflection . Reflection is used to detect data stored inside interface variables ( value value; type concrete type) pair A mechanism for .

package main

import (
	"fmt"
	"io"
	"os"
)


func main() {
	tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
	if err != nil {
		fmt.Println("open file error", err)
		return
	}

	var r io.Reader
	r = tty

	var w io.Writer
	w = r.(io.Writer)
	w.Write([]byte("HELLO THIS IS A TEST!!!\n"))
}

Another example :

package main

import "fmt"

type Reader interface {
	ReadBook()
}

type Writer interface {
	WriteBook()
}

// The specific type 
type Book struct {
}

func (this *Book) ReadBook() {
	fmt.Println("Read a book.")
}

func (this *Book) WriteBook() {
	fmt.Println("Write a book.")
}

func main() {
	b := &Book{}

	var r Reader
	r = b

	r.ReadBook()

	var w Writer
	w = r.(Writer)
	w.WriteBook()
}

Golang Reflection of reflect

reflect Basic functions of TypeOf and ValueOf

Since reflection is used to detect data stored in interface variables ( value value; type concrete type) pair A mechanism for . So in Golang Of reflect What ways can we get the information inside the variable directly in the reflection package ？ It provides two types （ Or two ways ） Let's easily access the contents of interface variables , Namely reflect.ValueOf() and reflect.TypeOf(), Look at the official explanation

// ValueOf returns a new Value initialized to the concrete value
// stored in the interface i.  ValueOf(nil) returns the zero 
func ValueOf(i interface{}) Value {...}

//ValueOf Used to obtain the value of data in the input parameter interface , If the interface is empty, return 0


// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {...}

//TypeOf The type used to dynamically obtain the value in the input parameter interface , If the interface is empty, return nil