[go ~ 0 to 1] day 4 June 30 defer, structure, method

1. defer Delay call

take defer Later statements delay execution , It will save the state of execution when changing the line of code ( Changes in subsequent values of variables do not affect ) It is mainly used for the release of resources similar Java Medium finally

func defermethod() {
    
	fmt.Println(" The first to perform ")
	defer fmt.Println(" Finally, execute ")
	fmt.Println(" Second, implementation ")
	defer fmt.Println(" The penultimate execution execution ")
}

Output results by : The first to perform -> Second, implementation -> The penultimate execution execution -> The first to perform

matters needing attention :

1. There are more than one... In the function defer when , Will adopt First in, then out ( Declare first and then execute , queue )

2. defer It will keep the state when running to this line of code Although the implementation will be delayed

	i := 10
	defer fmt.Println(i)
	i = 20

For example, the above code The final print result of the console is still 10

2. Structure

2.1 What is a structure

The structure is interpreted as Combine one or more variables together , Form a new type , This type is the structure

Java The essence of class in is Go The structure of language however Go The structure in a language is a reference type and Java Class in Is the reference data type

2.2 Declaration and assignment of structure

type  Structure name  struct{
    
     Field one   Type of field one 
     Field 2   Type of field 2 
}

	// Declare the structure first 
	type Person struct {
    
		name string
		age  int
	}

    //  To assign a value 
	var no1 Person
	no1.name = " Zhang San "
	no1.age = 19

	fmt.Println(no1)

	// Assign values while declaring the structure 
	type Person struct {
    
		name string
		age  int
	}

	p1 := Person{
    
		name: " Zhang San ",
		age:  19,
	}

	fmt.Println(p1)

Be careful : The structure field without assignment will use the default value

2.3 Structure pointer

A structure is a value type , All assignments are copies

When there are many structural fields , In order to reduce memory, structure pointers can be passed

2.4 Constructors

type studnet struct {
    
	name string
	age  int
}


func structmethod(name string, age int) studnet {
    

	return studnet{
    
		name: name,
		age:  age,
	}

}

3. Structure and JSON Transformation

3.1 serialize

//  Structure 
type teach struct {
    
	Name string `json:"name,omitempty"`
	Age  int    `json:"age,omitempty"`
}


func serialmethod() {
    

	// Create an object and assign a value 
	t1 := teach{
    
		Name: " Mr. Zhang San ",
		Age:  23,
	}

	// serialize 
	marshal, err := json.Marshal(t1)

	if err != nil {
    
		panic(err)
	}

	fmt.Println(string(marshal))
}

3.2 Deserialization

func unserialmethod() {
    

	str := "{\"name\":\" Miss Zhang Si \",\"age\":24}"

	// Create objects 
	var t2 teach

	// Deserialization   Be careful   Need to transmit t2 Object reference address   Otherwise you can't change  t2  Value 
	err := json.Unmarshal([]byte(str), &t2)

	if err != nil {
    
		panic(err)
	}

	fmt.Println(t2)

}

4. Method

4.1 Method definition

stay Go In language , Functions and methods are different , There is a clear conceptual distinction . In other languages , such as Java, Generally speaking, a function is a method , The method is the function , But in Go In language , Function means that it doesn't belong to any structure 、 Method of type , In other words, the function has no receiver ; And the method has a receiver , The method we are talking about belongs to a structure , Of a newly defined type .

Method declaration is similar to function , The difference between them is ： Method when defined , Will be in func Add a parameter between and method name , This parameter is the receiver , In this way, the method we defined is bound to the receiver , The way to call it this recipient .

Method recipients usually use lowercase of the type

//  Structure 
type China struct {
    
	City string `json:"city,omitempty"`
	Popu int    `json:"popu,omitempty"`
}


//  Serialization method 
func (c China) seriMethod() []byte {
    

	// Serialize the structure 
	marshal, err := json.Marshal(c)

	if err != nil {
    
		panic(err)
	}

	return marshal

}

//  Deserialization method 
func unseriMethod(bts []byte) China {
    

	var cnew China

	json.Unmarshal(bts, &cnew)

	return cnew
}