Basic Syntax of Go language (PART 2)

The standard library FMT provides the following output related functions.

The Fprint series of functions will print the content to a variable w of type IO.Writer interface. We usually use this function to write content to a file.

func Fprint(w io.Writer, a ...interface{}) (n int, err error)
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
func Fprintln(w io.Writer, a ...interface{}) (n int, err error)
Copy the code

Here’s an example:

// Write to standard output
fmt.Fprintln(os.Stdout, "Write to standard output")
fileObj, err := os.OpenFile("./xx.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
iferr ! =nil {
	fmt.Println("Error opening file, err:", err)
	return
}
name := "The Little Prince of Sand River"
// Write to an open file handle
fmt.Fprintf(fileObj, "Write to file as message: %s", name)
Copy the code

Note that any type that satisfies the IO.Writer interface supports writing.

The Errorf function generates a formatted string from the format argument and returns an error containing the string.

func Errorf(format string, a ...interface{}) error
Copy the code

This is often used to customize error types, for example:

err := fmt.Errorf("This is a mistake.")
Copy the code

Go1.13 added a %w placeholder for fmt.Errorf to generate a Wrapping Error.

e := errors.New("Original error E")
w := fmt.Errorf("Wrap an error %w", e)
Copy the code

Example code is as follows:

fmt.Printf("%v\n".100)
fmt.Printf("%v\n".false)
o := struct{ name string} {"The Little Prince"}
fmt.Printf("%v\n", o)
fmt.Printf("%#v\n", o)
fmt.Printf("%T\n", o)
fmt.Printf("100%%\n")
Copy the code

The following output is displayed:

100
falseStruct {name string}{name:"The Little Prince"}
struct { name string }
100%
Copy the code

Example code is as follows:

n := 65
fmt.Printf("%b\n", n)
fmt.Printf("%c\n", n)
fmt.Printf("%d\n", n)
fmt.Printf("%o\n", n)
fmt.Printf("%x\n", n)
fmt.Printf("%X\n", n)
Copy the code

The following output is displayed:

1000001
A
65
101
41
41
Copy the code

Example code is as follows:

s := "The Little Prince"
fmt.Printf("%s\n", s)
fmt.Printf("%q\n", s)
fmt.Printf("%x\n", s)
fmt.Printf("%X\n", s)
Copy the code

The following output is displayed:

The little prince"The Little Prince"
e5b08fe78e8be5ad90
E5B08FE78E8BE5AD90
Copy the code

The width is specified by a decimal number immediately following the percent sign, and if the width is not specified, the value is represented without padding beyond what is required. Precision is specified by the (optional) width followed by a dot number followed by a decimal number. If no precision is specified, the default precision is used. If the dot is not followed by a number, the precision is 0. Examples are as follows:

Example code is as follows:

n := 12.34
fmt.Printf("%f\n", n)
fmt.Printf("%9f\n", n)
fmt.Printf("%.2f\n", n)
fmt.Printf("% 9.2 f \ n", n)
fmt.Printf("%9.f\n", n)
Copy the code

The following output is displayed:

12.340000
12.340000
12.34
    12.34
       12
Copy the code

The FMT package of Go language has three functions, FMT.Scan, FMT.Scanf and FMT.Scanln, which can obtain user input from standard input during program running.

The function signature is as follows:

func Scanf(format string, a ...interface{}) (n int, err error)
Copy the code

• Scanf scans text from standard input, reading whitespace delimited values in the format specified by the format argument and saving them to arguments passed to the function.
• This function returns the number of successfully scanned data and any errors encountered.

A code example is as follows:

func main(a) {
	var (
		name    string
		age     int
		married bool
	)
	fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)
	fmt.Printf("Scan result Name :%s age:%d married:%t \n", name, age, married)
}
Copy the code

Compile the above code and run it on the terminal, where you enter prince, 28, and false in the specified format.

$./scan_demo 1: Little Prince 2: 283 3:falseName: Young prince age:28 Married:false 
Copy the code

Scanf is different from FMT.Scan, which simply uses Spaces as delimiters for input data. FMT.Scanf specifies a specific input format for the input data. Only the input format is scanned and stored in corresponding variables.

For example, if we continue to type in the whitespace delimited way we did in the previous example, FMT.Scanf will not scan the entered data correctly.

$./scan_demo Little Prince 28falseName: age:0 Married:false 
Copy the code

Sometimes we want to get the input in its entirety, and the input may contain Spaces, in which case we can use the Bufio package. Example code is as follows:

func bufioDemo(a) {
	reader := bufio.NewReader(os.Stdin) // Generate read objects from standard input
	fmt.Print("Please enter:")
	text, _ := reader.ReadString('\n') // Read the newline
	text = strings.TrimSpace(text)
	fmt.Printf("%#v\n", text)
}
Copy the code

These functions are similar to fmt.Scan, fmt.Scanf, and fmt.Scanln, except that instead of reading from standard input, they read from a specified string.

func Sscan(str string, a ...interface{}) (n int, err error)
func Sscanln(str string, a ...interface{}) (n int, err error)
func Sscanf(str string, format string, a ...interface{}) (n int, err error)
Copy the code

Time. time indicates the time. We can use time.now () to get the current time object, and then get the time object’s year, month, day, hour, minute, second, etc. Example code is as follows:

func timeDemo(a) {
	now := time.Now() // Get the current time
	fmt.Printf("current time:%v\n", now)

	year := now.Year()     / / year
	month := now.Month()   / / month
	day := now.Day()       / /,
	hour := now.Hour()     / / hour
	minute := now.Minute() / / minute
	second := now.Second() / / SEC.
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}
Copy the code

Time. Duration is a type defined by the time package that represents the elapsed time between two points in time in nanoseconds. Duration indicates an interval of time. The longest period of time available is about 290 years.

The constants of the interval type defined in the time package are as follows:

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)
Copy the code

For example, time.Duration indicates 1 nanosecond, and time.Second indicates 1 Second.

We may encounter the requirement of time + time interval in the daily coding process. The time object of Go language provides Add methods as follows:

func (t Time) Add(d Duration) Time
Copy the code

For example, find the time after an hour:

func main(a) {
	now := time.Now()
	later := now.Add(time.Hour) // The current time plus the time after 1 hour
	fmt.Println(later)
}
Copy the code

func (t Time) Equal(u Time) bool
Copy the code

To determine whether two time zones are the same, the time zone is considered. Therefore, the time of different time zone standards can be correctly compared. Unlike t==u, this method also compares location and time zone information.

func (t Time) After(u Time) bool
Copy the code

Return true if t represents a point in time after u; Otherwise return false.

There is a built-in Format method for formatting time types. It should be noted that in Go language, the time template for formatting time is not the common Y-m-d H: m :S, but the birth time of Go is 15:04 on January 2, 2006 (2006 1 2 3 4). Maybe that’s the romance of the techie.

Add: Specify PM if you want to format to 12-hour mode.

func formatDemo(a) {
	now := time.Now()
	// The formatted template is Go born at 15:04 Mon Jan, 2 January 2006
	// 24-hour system
	fmt.Println(now.Format("The 2006-01-02 15:04:05. Mon 000 Jan"))
	// 12-hour system
	fmt.Println(now.Format(2006-01-02 03:04:05.000 PM Mon Jan"))
	fmt.Println(now.Format("2006/01/02 15:04"))
	fmt.Println(now.Format("15:04 2006/01/02"))
	fmt.Println(now.Format("2006/01/02"))}Copy the code

There are some basic data types in Go, such as string, integer, floating point, Boolean, etc. In Go, you can use the type keyword to define custom types.

A custom type defines an entirely new type. We can define it based on built-in primitive types, or we can define it through structs. Such as:

// define MyInt as an int
type MyInt int
Copy the code

By definition of the type keyword, MyInt is a new type that has the properties of int.

The following code illustrates the apparent difference between a type alias and a type definition with just an equal sign.

// Type definition
type NewInt int

// Type alias
type MyInt = int

func main(a) {
	var a NewInt
	var b MyInt
	
	fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
	fmt.Printf("type of b:%T\n", b) //type of b:int
}
Copy the code

The result shows that the type of a is main.NewInt, which represents the NewInt type defined under the main package. B is of type int. The MyInt type only exists in the code, and does not exist when the compilation is complete.

Use the type and struct keywords to define a structure in the following format:

typeType namestruct{Field name Field Type Field name Field type... }Copy the code

Among them:

• Type name: Identifies the name of a custom structure that cannot be repeated within the same package.
• Field name: Indicates the structure field name. The field names in the structure must be unique.
• Field type: Represents the specific type of a structure field.

For example, we define a Person structure as follows:

type person struct {
	name string
	city string
	age  int8
}
Copy the code

Fields of the same type can also be written on a single line,

type person1 struct {
	name, city string
	age        int8
}
Copy the code

This gives us a custom type of Person with three fields, name, city, and age, representing name, city, and age, respectively. This makes it easy to use the Person structure to represent and store human information in your program.

The base data types built into the language are used to describe a value, while constructs are used to describe a set of values. For example, a person has a name, age, city of residence, etc., which is essentially an aggregated data type

Here’s an example:

type person struct {
	name string
	city string
	age  int8
}

func main(a) {
	var p1 person
	p1.name = shahenaza
	p1.city = "Beijing"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)  //p1={1}
	fmt.Printf("p1=%#v\n", p1) //p1=main. Person {name:" ", city:" ", age:18}
}
Copy the code

We use. To access the structure’s fields (member variables), such as p1.name and p1.age.

We can also get the address of the structure by instantiating it using the new keyword. The format is as follows:

var p2 = new(person)
fmt.Printf("%T\n", p2)     //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}
Copy the code

We can see from the printed result that P2 is a structure pointer.

Note that the Go language supports direct use of structure Pointers. To access the members of the structure.

var p2 = new(person)
p2.name = "The Little Prince"
p2.age = 28
p2.city = "Shanghai"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:" prince ", city:" Shanghai ", age:28}
Copy the code

The member variables of an uninitialized structure are zero values corresponding to their type.

type person struct {
	name string
	city string
	age  int8
}

func main(a) {
	var p4 person
	fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}
}
Copy the code

When initializing a structure, you can write the value directly instead of the key:

p8 := &person{
	shahenaza."Beijing".28,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:" ", city:" ", age:28}
Copy the code

When initializing with this format, note:

1. All fields of a structure must be initialized.
2. The initial values must be filled in the same order as the fields are declared in the structure.
3. This method cannot be used with key value initialization.

Empty structures do not take up space.

var v struct{}
fmt.Println(unsafe.Sizeof(v))  / / 0
Copy the code

A Method in Go is a function that acts on a particular type of variable. This particular type of variable is called Receiver. The concept of a receiver is similar to this or self in other languages.

Methods are defined in the following format:

func (Receiver variable Receiver type)The method name(Parameter list) (Return parameter){function body}Copy the code

Among them,

• Receiver variables: When naming parameter variables in receivers, it is officially recommended to use the lowercase letters of the receiver type name insteadself,thisOr something like that. For example,PersonThe recipient variable of the type should be namedp.ConnectorThe recipient variable of the type should be namedcAnd so on.
• Receiver type: The receiver type is similar to the parameter type and can be pointer or non-pointer.
• Method name, argument list, return arguments: the format is the same as the function definition.

Here’s an example:

/ / Person structure
type Person struct {
	name string
	age  int8
}

//NewPerson constructor
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

// How to Dream
func (p Person) Dream(a) {
	fmt.Printf("%s dream is to learn Go! \n", p.name)
}

func main(a) {
	p1 := NewPerson("The Little Prince".25)
	p1.Dream()
}
Copy the code

The difference between methods and functions is that functions are not of any type and methods are of a specific type.

When a method is applied to a value type receiver, the Go language makes a copy of the receiver’s value at runtime. The recipient’s member values can be obtained in the method of the value type receiver, but the modification operation is only for the copy and the recipient variable itself cannot be modified.

// SetAge2 sets p's age
// Use the value receiver
func (p Person) SetAge2(newAge int8) {
	p.age = newAge
}

func main(a) {
	p1 := NewPerson("The Little Prince".25)
	p1.Dream()
	fmt.Println(p1.age) / / 25
	p1.SetAge2(30) // (*p1).SetAge2(30)
	fmt.Println(p1.age) / / 25
}
Copy the code

In the Go language, the receiver can be of any type, not just a structure, but any type can have methods. For example, we can use the type keyword to define new custom types based on the built-in int type, and then add methods to our custom types.

//MyInt defines int as a custom MyInt type
type MyInt int

SayHello adds a SayHello method to MyInt
func (m MyInt) SayHello(a) {
	fmt.Println("Hello, I'm an int.")}func main(a) {
	var m1 MyInt
	m1.SayHello() // I'm an int.
	m1 = 100
	fmt.Printf("%#v %T\n", m1, m1) //100 main.MyInt
}
Copy the code

Note: Non-native types cannot define methods, which means we cannot define methods for other package types.

A structure can contain another structure or structure Pointers nested within it, as shown in the sample code below.

//Address Address structure
type Address struct {
	Province string
	City     string
}

//User User structure
type User struct {
	Name    string
	Gender  string
	Address Address
}

func main(a) {
	user1 := User{
		Name:   "The Little Prince",
		Gender: "Male",
		Address: Address{
			Province: "Shandong",
			City:     Weihai "",
		},
	}
	fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:" little ", Gender:" male ", Address:main.Address{Province:" shandong ", City:" Weihai "}}
}
Copy the code

The same field name may exist inside a nested structure. In this case, you can avoid ambiguity by specifying a specific inline structure field name.

//Address Address structure
type Address struct {
	Province   string
	City       string
	CreateTime string
}

// the Email structure
type Email struct {
	Account    string
	CreateTime string
}

//User User structure
type User struct {
	Name   string
	Gender string
	Address
	Email
}

func main(a) {
	var user3 User
	user3.Name = shahenaza
	user3.Gender = "Male"
	// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
	user3.Address.CreateTime = "2000" // Specify CreateTime in the Address structure
	user3.Email.CreateTime = "2000"   // Specify CreateTime in the Email structure
}
Copy the code

A field in a structure that starts with uppercase indicates publicly accessible, and lowercase indicates private (accessible only in the package that defines the current structure).

The Tag is the meta information of the structure that can be read at runtime via reflection. The Tag is defined after the structure field and is enclosed by a pair of backquotes in the following format:

`key1:"value1" key2:"value2"`
Copy the code

A tag structure consists of one or more key-value pairs. Keys and values are separated by colons, and values are enclosed in double quotes. Multiple key-value pairs can be set for the same structure field, with Spaces separating the different key-value pairs.

Note: When writing a Tag for a structure, you must strictly follow the rules for key-value pairs. The parsing code for structure tags is very fault tolerant, and if the format is incorrectly written, it will not be reported at compile time or run time, and will not be evaluated correctly by reflection. For example, don’t add Spaces between key and value.

For example, we define a Tag for json serialization for each field in the Student structure:

/ / Student Student
type Student struct {
	ID     int    `json:"id"` // Implement the key for serializing the field by specifying a tag
	Gender string // Json serialization uses the field name as key by default
	name   string // Private cannot be accessed by JSON packages
}

func main(a) {
	s1 := Student{
		ID:     1,
		Gender: "Male",
		name:   shahenaza,
	}
	data, err := json.Marshal(s1)
	iferr ! =nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", data) / / json STR: {" id ": 1," Gender ":" male "}
}
Copy the code