Go development
1, Basic knowledge
1.1 basic structure
(1) The suffix of the go file is. Go
(2)package main
Indicates that the package where the hello.go file is located is main. In go, each file must belong to a package.
(3)import "fmt"
Represents the introduction of a package. You can use the functions in the fmt package
(4)func main(){
}
func is a keyword that represents a function.
Main is the function name. It is a main function, which is the entry of the program
*In go language, you must use variables to create variables, otherwise an error will be reported.
*The first capital letter of the identifier indicates that the variable is public, and the first lowercase letter indicates that the variable is private and can only be used in the current package
1.2 escape character
package main import "_fmt" //_ Indicates that the package will not be used for the time being func main( ) { fmt.Println("tom\tjack") //Tab for alignment fmt.Println("hello\nword") //Newline character fmt.Println("D:\\Go tool\\GoLand 2021.1.3\\bin") // "\ \" output a\ fmt.Println("Tianlong Babu snow mountain flying fox\r Zhang") //Overwrite all content }
1.3 code specification
1) Line comment
//Note content
2) Block annotation
/*
Note Content
*/(a block note cannot be nested inside a block note)
3) Code to achieve indentation, you can use the shift+tab key, or use gofmt format
1.4 basic DOS operation
1) dir view the contents of the current directory file
2) cd /d f: switch other disks, for example, from disk d to disk f
3) cd d: \ test100 switch from the current disk to the current disk file package
4) cd... Back to parent directory
5) cd \ back to top level directory
6) md create an empty directory
7) rd delete empty directory
8) rd /q/s delete directory (regardless of content)
9) rd /s delete directory with query
10) echo content > absolute directory path of the file you want to create (d: \ test100\abc100\hello.txt)
11)copy specifies the directory path of the file to be copied (abc.txt d: \ test100)
12)move file name the path of the file directory to be moved (you can add the file name after the path if you want to change it)
13) del *.txt delete all files of this type
14) cls clear screen
15) Exit exit
2, Go language knowledge
2.1. Golang variable
2.1.1 demonstration of creating variable code
package main import "fmt" var( i1 = 100 name2 = "joke" i3 = 1000 ) //Create global variable func main() { var i int; //When specifying a variable type, create a variable format i = 100 fmt.Println("i=",i) n := "tom" //When var is omitted, add:= fmt.Println("name=",n) var n1, n2, n3 int //Create multiple variables fmt.Println(n1,n2,n3) var a, name, b = 100,"tom",88 //Create multiple variables at one time, where are one-to-one correspondence fmt.Println(a,name,b) j, na, k := 100,"tom",88 //Omit var fmt.Println(j,na,k) fmt.Println(i1,name2,i3) }
2.1.2 data type
2.1.2.1
*byte can only store one character. There is no special char type in go
2.1.2.2 integer type
type | Sign or not | Range | remarks |
---|---|---|---|
int | have | -63rd power of 2 ~ 63rd power of 2 - 1 | |
uint | nothing | 64th power of 0 ~ 2 - 1 | |
rune | have | -The 31st power of 2 ~ the 31st power of 2 - 1 | Equivalent to int32, representing a Unicode code |
byte | nothing | 0~255 | Select byte when you want to store characters |
**When using integer variables in Golang program, the principle of keeping small but not large shall be observed, that is, the data type with small occupation space shall be adopted when ensuring the normal operation of the program.
2.1.2.3 floating point
type | Occupied space | Range |
---|---|---|
Single precision (float) | 4 bytes | -3.403E38~3.403E38 |
double | 8 bytes | -1.798E308~1.798E308 |
2.1.2.4 character type
(1) Strings in go are spliced by characters
(2)
package main import "fmt" func main() { var n1 byte = 'a' var n2 byte = '0' fmt.Println("n1",n1) fmt.Println("n2",n2) //Only code values can be output fmt.Printf("n2 = %n2",n2)//Formatted output can output characters //If the ASCII range is exceeded var n3 int = 'north' fmt.Printf("n3 = %n3",n3) //If the variable is assigned a number and then output according to the format, the corresponding character will be output. }
2.1.2.5 boolean type
(1) Boolean type values can only be true and false
2.1.2.6 string type
package main import "fmt" func main() { //Basic use var adress string = "adfadsf sdafdasf" fmt.Println(adress) }
(1) The string in go is immutable
(2) When creating a string variable, you can use
Back quotation marks ` `, you can output the source code. Double quotation marks "" will recognize the special characters in quotation marks
(3) When a splicing operation is very long, it can be written separately, and the plus sign must be on it
var str = "hello" + "world" + "hahaha"
2.1.2.6 data type conversion
var i int32 = 100 var n1 float32 = float32(i) //The rest are similar to this conversion structure. Note that the data type of i after conversion has not changed //Data basic type conversion string //Method 1: use fmt.Sprintf var num1 int = 99 var str string str = fmt.Sprintf("%d",num1) fmt.Printf("str type %T str = %v",str,str) //Method 2: use strconv function. See the Chinese document of go standard library for details str = strconv.FormatFloat(num1,'f',10,64) //Note: 'f' format 10 means that 10 decimal places are reserved, and 64 means that the decimal is float64 //Convert string type to data base type var str string = "true" var b bool b , _ = strconv.ParseBool(str)//Because this function returns two values, the second value is ignored, means ignored
Note: when converting a string to a basic type, ensure that it can be converted to valid data, otherwise Golang will directly convert it to 0
2.2 pointer
package main import ( "fmt" ) func main(){ var num int = 100 //Create go pointer var ptr *int = &num var num2 int = *ptr fmt.Printf(num," ",ptr," ",num2) }
2.3 value type and reference type
2.3.1 value type
Basic data types include int series, float series, bool, string, array and struct
2.3.2 reference type
Pointer, slice slice, map, pipe chan, interface, etc
2.4 operator and terminal input
Note: + + and – can only be used independently, for example
package main import ( "fmt" ) func main(){ var name string var i int = 8 var a int //a = i + +, which is the wrong way to write i++ a = i //i should first implement + + and then assign a value to a //++i or -- i this is wrong. There is no front -- or front in go++ //Input from the terminal, mode 1: fmt.Scanln(&name)//Here is to pass the address of name to the function. You can enter the value of name from the terminal fmt.Printf("name is %v",name) //Mode 2: fmt.Scanf("%s",&name)//Note that multiple entries need to be aligned one by one }
2.5 process control
2.5.1 if statement
//Mode 1: var age int var age1 int fmt.Println("Please enter age") fmt.Scanln(&age) if age < 0 { fmt.Println("You're a fake") } //Mode 2: if age1 = 20; age1 > 18 { fmt.Println("You're an adult, boy") } //In go, add {} no matter how many statements are in the if statement if age > 18 { fmt.Println("You're an adult, boy") }else { //else here must be written on this line, or an error will be reported fmt.Println("You're still a minor") }
2.5.2 switch statement
switch expression { case Expression 1, expression 2.... : Statement block case Expression 1, expression 2.... : Statement block fallthrough//After executing this statement, you can also execute the next statement case Expression 1, expression 2.... : Statement block . . . default: Statement block //In the go language, the switch statement does not have a break, but has a break by default //switch can be followed by a constant or a function return value //switch can not be followed by an expression /*For example: switch{ case age == 10: Statement block } */ }
2.5.3 circular statements
//Mode 1: for i = 1; i < 10; i++ { Statement block } //Mode 2: var j = 1 for j < 10 { j++ } for{ Statement block break }//The for loop does not need to write loop conditions, but needs to add break to terminate the loop //for range string traversal or array traversal str := "hello" for index, val := range str{ fmt.Println("index=%d, val=%c \n",index, val) }//If there is Chinese in the string, Chinese garbled code will appear in traditional traversal, which can be converted into slice STR2: = [] run (STR)
2.6 jump control statement
2.6.1 break
1) Introductory case
package main import ( "fmt" "math/rand" "time" ) func main() { //To generate a random number, you also need a rand to set a seed //time.Now().Unix(): returns the number of seconds from 0 hour, 0 minute, 0 second at 1970:01:01 to the present //rand.Seed(time.Now().Unix()) //How to randomly generate integers from 1 to 100 //n := rand.Intn(100) + 1 //fmt.Println(n) var count int = 0 for { rand.Seed(time.Now().UnixNano()) n := rand.Intn(100) + 1 count++ fmt.Println("n=",n) if(n == 99){ break } } fmt.Println("A total of 99 were generated",count) }
2) Using break in a nested loop, you can specify which loop to jump out of through the tag.
lable1: for i := 0; i < 10; i++ { if i == 2 { break lable1: } }
2.6.2 continue
1) continue can also skip that loop through the tag
lable1: for i := 0; i < 10; i++ { if i == 2 { continue lable1: } fmt.Println(i) }
2.6.3 goto and return
2.7 function
2.7.1 create function
func Function name(Parameter name parameter data type) (Return value data type) {//If there is only one return value, you can not add () Execute statement block... return Return value }
2.7.2 use of package
1) When referring to functions or variables in the package, you need to capitalize the variable name or function name
2) When packaging files, the package name is usually the same as the folder
3) When importing a package, src starts. Instead of replacing src, the compiler will automatically import it from under src
4) You can alias the package, but the original package name cannot be used
package main import ( "fmt" util"go_code/breakDmeo/util" )
5) You cannot have the same global variable name or function name under the same package
2.7.3 function details
1) In go, a function is also a data type and can be assigned to a variable, which is also a variable of this function type. This variable allows you to call a function
package main import "fmt" func getSum(a int, b int) int { return a + b } func main() { n1 := getSum n2 := n1(10,40) //Equivalent to getSum(10,40) }
2) Since the function is a data type, in Go, the function can be used as a formal parameter and called
package main import "fmt" func getSum(a int, b int) int { return a + b } func myFun(funvar func(int,int)int,num1 int, num2 int) { return funvar(num1,num2) } func main() { n1 := getSum n2 := n1(10,40) }
3) You can alias data types
package main import "fmt" type myType func(int,int)int //In this case, myType is func(int,int)int type func myFun(funvar myType,n1 int, n2 int) { return funvar(num1,num2) } func getSum(a int, b int) int { return a + b } func main() { res3 := myFun(getSum,500,600) fmt.Println(res3) }
4) Support naming return values
package main import "fmt" func getSumAndSub (a int, b int) (sum int,sub int { sum = a + b sub = a - b return } func main() { var sum1 int var sub1 int sum1,sub1 = getSumAndSub(12,56) }
5) Go supports variable parameters
//0 to more than one formal parameter is supported func sum(args... int) sum int{ } //One to more formal parameters are supported. At this time, args is a slice, which is equivalent to an array func sum1(n1 int,args... int) sum int{ }
2.7.4 init function
1) The inti function usually runs before the main function to complete some initialization:
package utils import "fmt" var Age int var Name string func init(){ fmt.Println("utils Wrapped init().....") }
2)package main import ("fmt" "go_code/charpter04/utils" ) var i int = test() func test() int { fmt.Println("test() Medium test().....") } func init() { fmt.Println("init Medium init.......") } func main() { fmt.Println("main()......i = ",i) fmt.Println("Age = ", Age, "Name = ", Name) }
2) If a file includes global variable definition, inti function and main function, the general execution order is global variable - "inti function -" main function "
2.7.5 anonymous functions
1) Called directly when defining anonymous functions, but only once
res1 := func (n1 int, n2 int)int { return n1 + n2 }(10,20)
2) Assign the anonymous function func (i int, j int) int to a, and then the function call can be completed through a, but a is not a function name (it can be used to write a function and call)
a := func(i int,j int) int { return i + j } res := a(10 , 20)
3) Global anonymous function
var { fun = func(i int, j int) int { return i + j } } func main() { res := fun(10,20) }
2.7.6 closure
1) A closure is a combination of a function and its associated reference environment
2) Case presentation:
func AddUpper() func(int) int { var n int = 10 //The following are closures return func(x int) int { n = n + x return n } } //above func main() { f := AddUpper() fmt.Println(f(1)) fmt.Println(f(2)) //Every call n is not initialized, but accumulated }
3)
package main import ( "fmt" "strings" ) func makeSuffix(suffix string) func (string) string { return func (name string) string { if !strings.HasSuffix(name, suffix) { return name + suffix } return name } } func main() { f := makeSuffix(".jpg") fmt.Println("The format after file processing is:" , f("winter")) }
2.7.7 defer of function
1)
package main import "fmt" func sum(i int, j int) int { defer fmt.Println("000") //When the defer statement is executed, it is not executed temporarily and pushed into a separate stack. Execution sequence 3 defer fmt.Println("111") //After the function is executed, all defer statements will be executed in the order of first in then out. Execution order 2 tes := i + j fmt.Println("tes",tes) //Execution sequence 1 return tes } func main() { res := sum(10 , 20) fmt.Println("res ",res) //Execution sequence 4 }
2) The advantage of defer is that it can release the resources created by the function in time
2.7.8 common system functions of string
1) Statistics string length
len(str), no need to import package
2) String traversal, and deal with Chinese garbled code at the same time
str2 := "hello world" str3 := []rune(str2) //Convert to slice for i := 0; i < len(str3); i++{ fmt.Printf("character=%C\n", r[i]) }
3) String to integer and integer to string
//This function needs to import "strconv" n, err := strconv.Atoi("123")//String to integer if err != nil { fmt.Println("Conversion error") }else{ fmt.Println("Conversion succeeded",n) } str := strconv.Itoa(123456) //Integer to string
4) String to [] byte: var bytes = []byte("hello go")
Convert to [] byte convert to string
var bytes = []byte("hello go") //You can get the code of hello go str := string([]byte{97,98,99}) //The characters abc corresponding to 97, 98 and 99 can be obtained
5) Hexadecimal to hexadecimal: str = strconv.Formatlnt(132,2), where the returned time string
6) Find whether the substring is in the specified string: strings.Contains("seafood", "foo") / / true
//You need to introduce "strings" strings.Contains("seafood","foo") //Return true
7) Count one string and several specified strings
num := strings.Cont("see","e") //Return 2
8) Compare regardless of case
b := strings.EqualFold("abc","ABC") //Return true //"abc" == "ABC" false "= =" is case sensitive
9) Returns the first occurrence and last occurrence of a substring in a string
index1 := strings.Index("dafdas","f") //Returns 3, or - 1 if not index2 := strings.LastIndex("dafdas","a") //Return 5
10) Replaces the specified substring with another substring
str := strings.Replace("go go beijing","go","hello",1) //Get hello go beijing //Where 1 refers to replacing several. If all of them are replaced, write - 1. At the same time, "go / / Beijing" can be a variable, for example: STR2: = "go Beijing" //STR: = strings. Replace (str2, "go", "hello", 1), where str2 itself has not changed
11) According to a certain character, a string is converted into a character array for segmentation identification
strArr := strings.Split("hello,world",",") //Get strArr=[hello world]
12) Case conversion
str = strings.ToLower("GO") str = strings.ToUpper("go")
13) Remove the left and right spaces from the string: string. Trimspace ("to go")
Remove the specified characters around the string: strings.Trim("! hello!", "!")
Remove the specified character from the left of the string: strings.TrimLeft("")
Remove the specified character from the right side of the string: strings. Trimright ("")
Judge whether the string starts with a character: strings.HasPrefix("adfasdf", "a")
Judge whether the string ends with a character: strings.HasSuffix("adfasdf", "f")
2.7.9 date and time correlation function
//"time" needs to be introduced //1) Get current function now := time.Now() //2) Get additional date information fmt.Printf("year = %v\n",now.Year()) fmt.Printf("month = %v\n",now.Month()) fmt.Printf("day = %v\n",now.Day()) fmt.Printf("hour = %v\n",now.Hour()) fmt.Printf("minute = %v\n",now.Minute()) fmt.Printf("second = %v\n",now.Second()) //3) Format date function fmt.Printf(now.Format("2006-01-02 15:04:05")) //You can get the current time, but the number is fixed and cannot be changed //4) Time sleep function time.Sleep() //Time.second time.hour time.minute time.milliseconds time.microseconds
2.7.10 built in functions
Note: functions that can be used directly without citing packages, for example: 1) new
num2 := new(int) //num2 is of type * int, i.e. pointer
2)len(str)
3) make: mainly used to allocate memory
2.8 exception handling
1) Quick start
package main import "fmt" func test() { //Use defer + recover to catch and handle exceptions defer func() { err := recover() // recove() is a built-in function that can catch exceptions if err != nil { // Description exception caught fmt.Println("err =", err) } }() num1 := 100 num2 := 0 res := num1 / num2 fmt.Println("res=", res) } func main() { test() fmt.Println("main.....") }
2) Custom error
package main import ("fmt" "errors" ) func readConf(name string) (err error) { //If the input file name is incorrect, a custom error is returned if name == "config.ini" { return nil } else { return errors.New("Error reading file..") } } func test() { err := readConf("config.ini") if err != nil { //If there is an error reading the file, output the error and terminate the program panic(err) } fmt.Println("Continue with the program") } func main() { }
2.9 array
2.9.1 one dimensional array
1) Traversal of array: for range
array := [...]int{1,2,3} for index,value := range array{ fmt.Println(value) }
① The first index returns the array index
② The second value is the value
③ Only local variables in the for loop
④ You can use "_" to omit the subscript value
⑤ index and value can be customized variable names
2) Precautions
① var arr []int where arr is slice slice slice
② After the array is created, if there is no assignment, there is a default value
1. Numeric type (integer, floating point number, etc.) = > 0
2. String = > ""
3. Boolean type = > false
2.9.2 two dimensional array
Traversal:
1) Double for loop
2) For range traverses a two-dimensional array
for i, v := range arr { for j, v2 := range v { fmt.Println("arr[%v][%v] = %t", i, j, v2) } }
2.10 slicing
2.10.1 basic introduction
1) Slice is a reference to array, so slice is a reference type. When passing, follow the mechanism of reference passing
2) The length of slices can be changed, which is equivalent to a dynamically changing array
3) Demo:
package main import "fmt" func main() { var intArr [5]int = [...]int{1,22,5,5,6} //Define a slice //slice := intArr[1:3] //intArr[1:3] indicates that slice refers to the array intArr //The starting subscript of the referenced intArr array is 1 and the last subscript is 3 (excluding 3) slice := intArr[1:3] fmt.Println("slice element =",slice) // 22,33 fmt.Println("slice Number of elements =",len(slice))//2 fmt.Println("slice capacity =",cap(slice))//The capacity of slices can change dynamically }
2.10.2 slice memory layout
Note: 1.slice is a reference type
2.slice is equivalent to a structure from the bottom layer:
type slice struct{
ptr *int / / the address where the data is stored
Len int / / number of slice elements
Capacity of cap int //slice
}
2.10.3 use of slices
1) Define a slice, and then let the slice reference a created array, as in the above example
2) Create slices with make
func main() { var slice []int = make([]int,4,10) //Data type, len, cap capacity, the array corresponding to a slice created by make is invisible, and the data can only be accessed through slice slice[0] = 100 slice[2] = 200 }
3)
func main() { var slice []string = []string{"jose","joe","jojo"} }
4) Distinction
① The difference between mode 1 and mode 2 is that mode 1 always refers to a pre-existing array as visible; In mode 2, when creating slices through make, an array will also be created. The slices are maintained at the bottom level and are invisible
5) Note:
① Slice: = arr [: 3] / / the default is 0-3 (excluding 3), and [0:] the default is 0-len(arr)
② Slicing can continue slicing
slice2 := slice[0:1]
③ Append element
var slice1 []int = []int{100,200,300}
Slice2 = append (slice1400500600) / / here, append creates a new memory, but slice1 does not change
slice3 = append(slice3,slice2...)
④ Copy of slice
copy(pare1,pare2) are both slice types. They are spatially independent and do not interfere with each other
⑤ string and slice
(1) The value of string array is immutable, but it can be modified by converting string to [] byte slice first and converting it to string array
str := "hello" arr1 := []byte(str) arr1[0] = z str = string(arr1) //Although this method can change the string array value, it is not allowed if there is Chinese in the string //If string has Chinese arr2 := []rune(str) arr2[0] = "cover" str = string(arr2)
2.10.4 traversal of slices
package main import "fmt" func main() { //Regular for loop traversal var arr [5]int = [...]int{1,2,3,4,5} slice := arr[1:4] for i:= 1; i < len(slice); i++{ fmt.Println("slice[%v]=%v", i, slice[i]) } //Traversal using the for range method for i, v:= range slice { fmt.Println(i," ",v) } }
2.11 map
2.11.1 basic grammar
var variable name map [key] ValueType
//Example: var a map[string]string //var a map[string]map[string]string
Note: the declaration will not allocate memory. make is required for initialization, and can be assigned and used only after allocation
package main import "fmt" func main() { //Mode 1 var a map[string]string a = make(map[string]string,10) //make allocate space a["no1"] = "joke" a["no2"] = "sandy" fmt.Println(a) //Mode II b := make(map[string]string) b["no1"] = "hehe" fmt.Println(b) //Mode III c = map[string][string]{ "no1" : "wj", "no2" : "wjj" } setStu := make(map[string]map[string]string) setStu["stu1"] = make(map[string]string,3) setStu["stu1"]["name"] = "tome" setStu["stu1"]["sex"] = "man" setStu["stu1"]["age"] = "16" fmt.Println(setStu) fmt.Println(setStu["stu1"]) fmt.Println(setStu["stu1"]["name"]) //The key of map cannot be repeated. If it is repeated, the last one shall prevail //The map is disordered }
2.11.2 addition, deletion, modification and query of map
package main import "fmt" func main() { var a map[string]string a = make(map[string]string,10) a["no1"] = "joke" a["no2"] = "sandy" fmt.Println(a) //change //key already exists a["no1"] = "wj" fmt.Println(a) //delete //When the specified key does not exist, it is neither deleted nor reported as an error //If you want to delete all key s at once, you can delete them one by one, or use map = make (...) to make a new space, so that the original space becomes garbage and is recycled by gc - "a = make(map[string]string) delete(a,"no1") //lookup val,ok := a["no1"] if ok{ fmt.Println("Found it") }else{ fmt.Println("No") } }
2.11.3 traversal of map
package main import "fmt" func main() { var a map[string]string a = make(map[string]string,10) a["no1"] = "joke" a["no2"] = "sandy" a["no3"] = "bj" fmt.Println(a) for i,v := range a { fmt.Printf("i=%v v=%v\n",i,v) } setStu := make(map[string]map[string]string) setStu["stu1"] = make(map[string]string,3) setStu["stu1"]["name"] = "tome" setStu["stu1"]["sex"] = "man" setStu["stu1"]["age"] = "16" for k1, v1 := range setStu { fmt.Println("k1=",k1) for k2, v2 := range v1 { fmt.Printf("\t k2=%v v2=%v",k2,v2) } fmt.Println() } }
2.11.4 map slice
package main import "fmt" func main() { var monster = []map[string]string monster = make(map[string]string, 2) if monster[0] == nil { monster[0] = make(map[string]string, 2) moster[0]["name"] = ["greeny "] moster[0]["age"] = ["600"] } if monster[1] == nil { monster[0] = make(map[string]string, 2) moster[0]["name"] = ["li Qingfeng"] moster[0]["age"] = ["700"] } //Dynamic increase newMonster := map[string]string{ "name" : "Lao Liu", "age" : "600", } monster = append(monster,newMonster) }
2.11.5 sorting
package main import ( "fmt" "sort" ) func main() { map1 := make(map[int]int,10) map1[1] = 13 map1[7] = 12 map1[6] = 14 map1[3] = 122 map1[2] = 1111 //First put the key of the map into the slice //Sort slices //Traverse the slice, and then output the map value according to the key var key []int for k,_ := range map1 { keys = append(keys,k) } sort.Ins(keys) fmt.Println(keys) for _, k := range keys{ fmt.Println(map1[k]) } }
2.11.6 use details
1) Map is a reference type. A function accepts a map. After modification, the value of the original map will also be changed
2) After the capacity of the map is reached, adding elements to the map will automatically expand the capacity without panic, which can grow dynamically
3) The value of a map also often uses the struct type
2.12 struct structure
2.12.1 quick start
package main import "fmt" //The structure name is public in uppercase and private in lowercase //If the pointer, slice and map are declared in the structure, the zero value is nil, and make is required to allocate space type Cat struct { Name string Age int } func main() { var cat1 Cat cat1.Name = "blank" cat1.Age = 16 var c4 Cat = Cat{"fadsf" , 16} //Create a pointer var c2 *Cat = new Cat) //Normally, it is written as (* c2). Name = "fadsf" c2.Name = "dsfads" //The compiler automatically switches to * c2 at the bottom fmt.Println(*c3) var c3 *Cat = &Cat{} //var c3 *Cat = &Cat{"fadsf" , 16} c3.Name = "fadsdaf" //The compiler automatically switches to * c2 at the bottom fmt.Println(*c3) }
2.12.2 use details
1) The attribute memory in the structure is distributed continuously (the address of the pointer is continuous, but the space pointed to is not necessarily continuous)
2) When two structures are converted to each other, their types and member variables should be the same
3) The structure is redefined by type (equivalent to taking an alias). golang considers it a new data type and can be forcibly converted
stu = Studnet(stu1)
2.12.3 method
1) Method declaration and invocation
type A struct { Num int } func (a A)test() { fmt.Println(a.Num) }
🥰 Func (A) test() {} indicates that there is A play method for structure A, which is called test
🥰 (a) the test method is bound to type A
give an example:
package main import "fmt" type Person struct { Name string } func (p Person) test() { fmt.Println("test() name",p.Name) } func main() { var p Person p.Name = "zhangsna" p.test() //The test() method can only be called by a Person object (&p).test()//The test function will also be called, and P will also be copied in the test function, that is, p.test() = (& P). Test(). If you change the value with & P. test(), but the external P remains unchanged /*If there is func (p *Person) test(){ fmt.Println("test() name",p.Name) } You can change the value of main function p But p.test() & still works. Test() */ }
😴
func (a A)test() { fmt.Println(a.Num) } //Where A can be A structure or other data types //To call this method, you need a variable of the corresponding data type
2.12.4 factory mode
Note: the initial letter of the declared structure in the current package is lowercase, and other packages are required. For example, if an instance of this package is created in the main package, the factory mode needs to be introduced.
example:
package main import ( "fmt" "go_code/factory/model" ) func main() { var stu = model.NewStudent("wj",88) fmt.Println(stu) }
package model:
package model type student struct { Name string Age int } //Because the student is lowercase, you can only use factory mode if you want to use it in other packages func NewStudent(n string, s int) *student{ return &student{ //Returns a pointer, that is, this space can be used Name : n, Age : s, } }
🔔 Similarly, if there are lowercase member variables in the structure, you also need to provide a method
example:
package model type student struct { Name string age int } func (s *student) Getage() int { //How to get lowercase variables return s.age }
2.13 object oriented
2.13.1 quick start
package main import( "fmt" ) type Account struct { AccountNo string Pwd string Balance float64 } //deposit func (account *Account) Deposite(money float64, pwd string) { if pwd != account.Pwd { fmt.Println("The password you entered is incorrect~~") return } if money <= 0|| money >= account.Balance { fmt.Println("The deposit amount you entered is incorrect~~") return } account.Balance -= money fmt.Println("withdraw money ok~~") } func (account *Account) Query(pwd string) { if pwd != account.Pwd { fmt.Println("Password error~~~") } fmt.Println("Account balance:",account.Balance) } func main() { account := Account{ AccountNo : "sadfasd", Balance : 1000.6, Pwd : "12345", } account.Query("12345") }
2.13.2 packaging
1) Hide details
2) The data can be verified to ensure safety and rationality
3) Encapsulates the initial lowercase of the attribute variable in the structure
4) Through the method, the package realizes encapsulation
5) Assign a value to the attribute judgment through an capitalized Set method
func (var Structure class name) Setxxx(){ }
6) Get its properties through an uppercase get method
func (var Structure class name) Getxxx(){ }
7) There is no special emphasis on encapsulation in Golang
✨
Quick case
package model import( "fmt" ) type person struct { Name string //Exposed property Name sex string //To use the Set and Get methods age int } func NewPerson(name string) *person { //Factory functions can be used in other packages, which is equivalent to constructors return &person{ Name = name, } } func (p *person) SetAge(age int){ if age > 0&&age < 150 { p.age = age }else{ fmt.Println("Wrong age range") } } func(p *person) GetAge() int{ return p.age }
main package
package main import ( "fmt" "go_code/chapter09/model" ) func main() { p := model.person("smith") p.SetAge(18) fmt.Println(p.Name,"age = " , p.GetAge) }
2.13.3 succession
1) Basic grammar
type Goods struct { Name string Price int } type Book struct { Goods // Here is the nested anonymous structure Goods Writer string }
2) Quick start cases
package main import( "fmt" ) type Student struct { Name string Age int Score int } func(stu *Student) ShowInfo(){ fmt.Println(stu.Name,stu.Age,stu.Score) } func (stu *Student) SetScore(score int) { stu.Score = score } type Pupil struct{ Student //Embedded Student anonymous struct name } func (p *Pupil) testing() { fmt.Println("Methods of primary school students") } type Graduate struct { Student //Embedded Student anonymous struct name } func (p *Graduate) testing() { fmt.Println("Methods for College Students") } func main() { pupil := &Pupil{} pupil.Student.Age = 8 pupil.testing() }
3) Attention
① Structures can use all fields and methods of nested anonymous structures, that is, fields and methods with uppercase and lowercase letters can be used
②
//b. A.name = "FASD" = = b.name, provided that there is no name variable in B
③ A structure can be embedded into multiple anonymous structures. If there are the same method name or attribute, you need to specify the anonymous structure to distinguish
④ If a struct is nested with a well-known structure, this pattern is a combination. When accessing the fields or methods of the combined structure, you need to bring the structure name
type D struct{ Name string } type B struct{ d D } func main() { var b B b.d.Name =" sdf" //You must bring the anonymous structure name here }
⑤ After nesting a structure, you can specify the value of each anonymous structure field when creating a structure variable
type D struct{ Name string } type H struct{ Sex string } type B struct{ D H } func main() { var b B b = B{ D{ Name : "fads", }, H{ Sex : "fasd", }, } }
type D struct{ Name string } type H struct{ Sex string } type B struct{ *D *H } func main() { var b B b = B{ &D{ Name : "fads", }, &H{ Sex : "fasd", }, } fmt.Println(*b.D,*b.H) }
3) Multiple inheritance
type D struct{ Name string } type H struct{ Sex string } type B struct{ //multiple inheritance D H } func main() { var b B b = B{ D{ Name : "fads", }, H{ Sex : "fasd", }, } }
✨ In order to ensure the simplicity of the code, it is recommended not to use multiple inheritance
2.13.4 interface
1) Basic grammar
type Usb interface{ //Interface definition //Declare two methods Start() Stop() } type Phone struct { } type Camera struct{ } func (p Phone) Start() { fmt.Println("work.....") } func (p Phone) Stop() { fmt.Println("over.....") } func (c Camera) Start() { fmt.Println("work.....") } func (c Camera) Stop() { fmt.Println("over.....") } func Computer struct { } //Receive a variable of Usb interface type func (c Computer) Working (usb Usb){ usb.Start() usb.Stop() } func main() { computer := Computer{} phone := Phone{} camera := Camera{} computer.Working(phone) }
2) The interface in Golang does not need to be explicitly implemented. As long as a variable contains all the methods in the interface type, the variable implements the interface. Therefore, there is no keyword such as implementation in Golang
3) Interface considerations and details
package main import( "fmt" ) type AInterface interface{ Say() } type Stu struct { Name string } //① func (stu Stu) Say() { fmt.Println("stu Say()") } //② type interger int func (i integer) Say() { fmt.Println("integer Say i =",i) } //③ type BInterface interface{ Hello() } type Moster struct{ } func(m Monster) Hello() { fmt.Println("hello...") } func(m Monster) Say() { fmt.Println("say hello...") } func main(){ //① The interface itself cannot create an instance, but it can point to a variable of a custom type that implements the interface var stu Stu //var a AInterface = stu this is an error var a AInterface = stu //√ a.Say() //② As long as it is a custom data type, you can implement the interface, not just the structure type var i integer = 20 var b AInterface = i b.Say() //③ A custom type can implement multiple interfaces var monster Monster var a2 AInterface = monster var b2 BInterface = monster a2.Say() b2.Hello() }
🤖 You cannot have any variables in a Golang interface
👽 An interface (such as interface A) can inherit multiple individual interfaces (such as interfaces B and C). To implement interface A, you must also implement the methods of interfaces B and C
package main import( "fmt" ) type AInterface interface{ Say() } type BInterface interface{ Hello() } type CInterface interface{ AInterface BInterface test() } type Stu struct { } func (stu Stu)Say(){ } func (stu Stu)Hello(){ } func (stu Stu)test(){ } func main() { var stu Stu var c CInterface = stu a.test() }
👹 interface is a reference type. If it is not initialized, nil is not
👾 Empty interface interface {}, you can assign any variable to the interface
4) Classic case: sorting slices
package main import( "fmt" "math/rand" "sort" //Call the interface in sort ) //Declare Hero structure type Hero struct{ Name string Age int } //Declare a Hero struct slice type HeroSlice []Hero //As follows: implement the Inerface interface func (hs HeroSlice) Len()int{ return len(hs) } //The Less method is to determine what criteria you use to sort //1. Sort by Hero's age from small to large func (hs HeroSlice) Less(i, j int) bool { return hs[i].Age < hs[j].Age //In ascending order, if it returns true, Swap will be called to sort } func (hs HeroSlice) Swap(i, j int) { temp := hs[i] hs[i] = hs[j] hs[j] = temp } func main() { var heroes HeroSlice for i := 0; i < 10; i++{ hero := Hero{ Name : fmt.Sprintf("hero~%d",rand.Intn(100)), Age : rand.Intn(100), } heroes = append(heroes,hero) } for _,v := range heroes{ fmt.Println(v) } //After sorting fmt.Println("After sorting..") sort.Sort(heroes) for _,v := range heroes{ fmt.Println(v) } }
2.13.5 differences between inheritance and structure
1) Interfaces can be used as a complement to inheritance
2) The value of inheritance lies in the reusability and maintainability of code
3) The value of an interface is to design specifications (Methods) so that other custom types can implement it
2.13.6 polymorphism
①
1) Polymorphic parameters
As in the example in the interface, usb can receive both phone variables and camera variables
2) Polymorphic array
package main import( "fmt" ) type Usb interface{ //Interface definition //Declare two methods Start() Stop() } type Phone struct { Name string } type Camera struct{ Name string } func (p Phone) Start() { fmt.Println("mobile phone work.....") } func (p Phone) Stop() { fmt.Println("mobile phone over.....") } func (c Camera) Start() { fmt.Println("camera work.....") } func (c Camera) Stop() { fmt.Println("camera over.....") } func main() { //Define a Usb interface array that can store the structure variables of Phone and camera //Here is the polymorphic array var usbArr [3]Usb usbArr[0] = Phone{"millet"} usbArr[1] = Phone{"Huawei"} usbArr[2] = Camera{"Sony"} for i := 0; i < len(usbArr); i++{ usbArr[i].Start() usbArr[i].Stop() } fmt.Println(usbArr) } //result /* Mobile work Phone over Mobile work Phone over Camera work Camera over [{Xiaomi} {Huawei} {Sony}] */
② Type assertion
//Example 1 package main import( "fmt" ) type Point struct{ x int y int } func main() { var a interface{} var point Point = Point{1,2} a = point //true var b Point // b = a is the wrong writing b =a.(Point) //Convert a and judge whether a does not Point to a variable of Point. If yes, it will be converted to Point type. On the contrary, the compiler will report an error fmt.Println(b) //Type assertion 2 var x interface{} var b2 float64 = 1.1 x = b2 //Check for errors if y, ok := x.(float32); ok{ fmt.Println("success") fmt.Println("y= ", y) }else { fmt.Println("fail") } fmt.Println("Continue execution......") }
Example 2
[the external chain image transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the image and upload it directly (img-qqjk3thn-1635348855477) (C: \ users \ administrator \ appdata \ roaming \ typora \ user images \ image-20211025222002348. PNG)]
2.14 document operation
2.14.1 basic introduction
1) Stream: the path of data between the data source (file) and the program (memory)
Input stream: the path of data from data source (file) to program (memory)
Output stream: the path of data from program (memory) to data source (file)
2) os.File encapsulates all File related operations. "os" is a package and File is a structure
For example: func Open and func Close use
package main import ( "fmt" "os" ) func main(){ //Open file //File is called a file object //File is called file pointer //File is called file handle file, err := os.Open("d:/test.txt") //If there is no error, you need to have this file in the corresponding location if err != nil { fmt.Println("open file err=",err) } fmt.Println("file=",file) //Close file err = file.Close() if err != nil { fmt.Println("close file err=",err) } }
2.14.2 reading files
1) Read the file content and display it on the terminal (with buffer)
package main import ( "fmt" "os" "bufio" "io" ) func main(){ //Open file file, err := os.Open("d:/test.txt") if err != nil { fmt.Println("open file err=",err) } defer file.Close() //Close the file handle in time, otherwise there will be a memory leak //Create a * Reader with buffer /* const { defaultBufSize = 4096 //The default buffer is 4096 } */ reader := bufio.NewReader(file) //Loop to read the contents of the file for{ str, err := reader.ReadString('\n') //It ends when you read a "\ n". str stores the content and err stores the error information if err == io.EOF{ //Indicates the end of the file break } fmt.Print(str) } fmt.Println("End of reading file~~~~") }
2) One time opening (small file, inefficient if large file)
package main import ( "fmt" "io/ioutil" ) func main(){ file := "d:/test.txt" content, err := ioutil.ReadFile(file) //content is [] byte if err != nil { fmt.Printf("read file err=%v",err) } fmt.Println(string(content)) }
2.14.3 create files and write contents
1) Basic introduction
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
Note: os.OpenFile is a method to open a file at one time. It will open a file with a specified name using the specified options and mode.
Second parameter: file open mode (can be combined)
The third parameter: permission control
2) Case
//Constants package const ( O_RDONLY int = syscall.O_RDONLY // Open file in read-only mode O_WRONLY int = syscall.O_WRONLY // Open file in write only mode O_RDWR int = syscall.O_RDWR // Open file in read-write mode O_APPEND int = syscall.O_APPEND // Append data to the end of the file when writing O_CREATE int = syscall.O_CREAT // If it does not exist, a new file is created O_EXCL int = syscall.O_EXCL // For use with O_CREATE, the file must not exist O_SYNC int = syscall.O_SYNC // Open file for synchronizing I/O O_TRUNC int = syscall.O_TRUNC // If possible, empty the file when opening )
① / / create a new file and write 5 sentences of "hello world"
package main import ( "fmt" "bufio" "os" ) func main() { //1. Open the file filePath := "d:/abc.txt" file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_CREATE, 0666) if err != nil { fmt.Printf("open file err=%v\n",err) return } //Close the file handle in time defer file.Close() //Ready to write str := "hello,world\n" //When writing, use * Writer with cache writer := bufio.NewWriter(file) //Returns a writer for i := 0; i < 5; i++{ writer.WriteString(str) } //Because the writer is cached, when calling the WriterString method, the content is written to the cache first. //Therefore, call the Flush method to write the buffered data to the file!!!! writer.Flush() }
② / / open a file and overwrite the original contents of the file with 5 sentences "BLA"
package main import ( "fmt" "bufio" "os" ) func main() { //1. Open the file filePath := "d:/abc.txt" file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_TRUNC, 0666) //os.O_TRUNC opens the file and empties the contents if err != nil { fmt.Printf("open file err=%v\n",err) return } //Close the file handle in time defer file.Close() //Ready to write str := "blablablabla\n" //When writing, use * Writer with cache writer := bufio.NewWriter(file) //Returns a writer for i := 0; i < 5; i++{ writer.WriteString(str) } //Because the writer is cached, when calling the WriterString method, the content is written to the cache first. //Therefore, the Flush method is called to actually write the buffered data to the file writer.Flush() }
③ / / add "ABC, hahaha"
package main import ( "fmt" "bufio" "os" ) func main() { //1. Open the file filePath := "d:/abc.txt" file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_APPEND, 0666)//os.O_APPEND appends data to the end of the file during write operations if err != nil { fmt.Printf("open file err=%v\n",err) return } //Close the file handle in time defer file.Close() //Ready to write str := "ABC,Ha ha ha\n" //When writing, use * Writer with cache writer := bufio.NewWriter(file) //Returns a writer for i := 0; i < 5; i++{ writer.WriteString(str) } //Because the writer is cached, when calling the WriterString method, the content is written to the cache first. //Therefore, the Flush method is called to actually write the buffered data to the file writer.Flush() }
④ / / open an existing file and read out and display the original content on the terminal
package main import ( "fmt" "bufio" "os" "io" ) func main() { //1. Open the file filePath := "d:/abc.txt" file, err := os.OpenFile(filePath, os.O_RDONLY | os.O_APPEND, 0666)// os.O_RDONLY opens the file in read-only mode, and os.O_APPEND appends the data to the end of the file during write operation if err != nil { fmt.Printf("open file err=%v\n",err) return } //Close the file handle in time defer file.Close() //First read the contents of the original file and display it on the terminal reader := bufio.NewReader(file) for { str, err := reader.ReadString('\n') if err == io.EOF{ break } fmt.Print(str) } //Ready to write str := "ABC,wj\n" //When writing, use * Writer with cache writer := bufio.NewWriter(file) //Returns a writer for i := 0; i < 5; i++{ writer.WriteString(str) } //Because the writer is cached, when calling the WriterString method, the content is written to the cache first. //Therefore, the Flush method is called to actually write the buffered data to the file writer.Flush() }
2.14.4 copying documents
package main import ( "fmt" "io/ioutil" ) func main() { //1. Read the contents of abc.txt file //2. Write the read content to kkk.txt file1Path := "d:/abc.txt" file2Path := "d:/kkk.txt" data, err := ioutil.ReadFile(file1Path) if err != nil { //Description there is an error reading the file fmt.Println("read file err=%v", err) return } err := ioutil.WriteFile(file2Path, data, 0666) if err != nil{ fmt.Printf("write file error = ", err) } }
2) Copy files (pictures / movies / mp3)
package main import ( "fmt" "bufio" "os" "io" ) //Write a function to receive the path of two files func CopyFile(dstFileName string, srcFileName string)(written int64, err error){ srcfile, err := os.Open(srcFileName) if err != nil { fmt.Printf("open file err = %v\n", err) } //Get the Reader through srcfile reader := bufio.NewReader(srcfile) defer srcfile.Close() //Open desFileName dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666) if err != nil { fmt.Printf("open file err=%v\n", err) return } //Get the Writer through dstFile writer := bufio.NewWriter(dstFile) defer dstFile.Close() return io.Copy(writer, reader)//Copy function in io package } func main() { srcFile := "d:/test/picture.png" dstFile := "d:/abc.png" CopyFile(dstFile, srcFile) }
2.14.5 statistics of different types of characters
package main import ( "fmt" "bufio" "os" "io" ) type CharCount struct { ChCount int //Record English letters NumCount int //Number of recorded numbers SpaceCount int //Record the number of spaces OtherCount int //Record the number of other characters } func main() { //Open a file and create a Reader //Without reading a line, count how many English, numbers, spaces and other characters there are in the changed line //Then save the results to a structure fileName := "d:/abc.txt" file, err := os.Open(fileName) if err != nil { fmt.Printf("err = %v\n", err) return } defer file.Close() //Define a CharCount instance var count CharCount //Create a Reader reader := bufio.NewReader(file) //Start looping reading the contents of fileName for { str, err := reader.ReadString('\n') if err == io.EOF{ break } } //Traverse str for statistics for _, v = range str { fmt.Println(str) } }
2.14.5 how many English, numbers, spaces and other characters are there in the statistical document
package main import ( "fmt" "bufio" "os" "io" ) type CharCount struct { ChCount int //Record English letters NumCount int //Number of recorded numbers SpaceCount int //Record the number of spaces OtherCount int //Record the number of other characters } func main() { //Open a file and create a Reader //Without reading a line, count how many English, numbers, spaces and other characters there are in the changed line //Then save the results to a structure fileName := "d:/abc.txt" file, err := os.Open(fileName) if err != nil { fmt.Printf("err = %v\n", err) return } defer file.Close() //Define a CharCount instance var count CharCount //Create a Reader reader := bufio.NewReader(file) //Start looping reading the contents of fileName for { str, err := reader.ReadString('\n') if err == io.EOF{ //Exit at the end of the file break } //Traverse str for statistics for _, v := range str { switch { //Instead of v to match, it is treated as an if branch structure statement case v >= 'a' && v <= 'z': fallthrough //Penetration, which forces the execution of the next line of statements case v >= 'A' && v <= 'Z': count.ChCount++ case v == ' ' || v == '\t': count.SpaceCount++ case v >= '0' && v <= '9': count.NumCount++ default : count.OtherCount++ } } } //Number of output statistics fmt.Printf("The number of characters is=%v The number of numbers is=%v The number of spaces is=%v The number of other characters is=%v", count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount) }
2.14.6 flag package to parse command line parameters
package main import ( "fmt" "flag" ) func main () { var user string var pwd string var host string var port int //User is the parameter value after - u entered in the user command line flag.StringVar(&user,"u","","The user name is empty by default") flag.StringVar(&pwd,"pwd","","Password, blank by default") flag.StringVar(&host,"host","localhost","Host name, empty by default") flag.IntVar(&port,"port",3306,"Port number, 3306 by default") //transformation flag.Parse() //Output results fmt.Printf("user=%v pwd=%v host=%v port=%v",user,pwd,host,port) }
Terminal: D:\Go code \ SRC \ go_ code\chapter12> go build -o test.exe test.go
D:\Go code \ SRC \ go_ code\chapter12> test.exe -u root -pwd 132465 -host
127.0.0.5 -port 8080
2.15 test whether the function is executed correctly
//cal_test file package main import( _"fmt" "testing" //Introducing the testing framework in go ) //Write a test case to test whether addUpper is correct func TestAddUpper(t *testing.T) { //call res := addUpper(10) if res != 55 { t.Fatalf("AddUpper(10) Execution error, expected value=%v actual value=%v\n", 55, res) } //If correct, output the log t.Logf("AddUpper(10) Correct execution....") }
//Tested file package main //A function under test func addUpper(n int) int{ res := 0 for i := 1; i <= n - 1; i++ { res += i } return res }
result:
[the external chain image transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the image and upload it directly (img-ykka4x5d-1635348855479) (C: \ users \ administrator \ appdata \ roaming \ typora \ user images \ image-20211027233258247. PNG)]
Schematic diagram of function execution:
[the external chain image transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the image and upload it directly (img-0av1jaxl-1635348855481) (C: \ users \ administrator \ appdata \ roaming \ typora \ typora user images \ image-20211027232937740. PNG)]
matters needing attention:
[the external chain image transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the image and upload it directly (img-8ovme5ya-1635348855483) (C: \ users \ administrator \ appdata \ roaming \ typora \ user images \ image-20211027233031706. PNG)]
Count int / / record the number of spaces
OtherCount int / / record the number of other characters
}
func main() {
//Open a file and create a Reader
//Without reading a line, count how many English, numbers, spaces and other characters there are in the changed line
//Then save the results to a structure
fileName := "d:/abc.txt"
file, err := os.Open(fileName)
if err != nil {
fmt.Printf("err = %v\n", err)
return
}
defer file.Close()
//Define a CharCount instance
var count CharCount
//Create a Reader
reader := bufio.NewReader(file)
//Start looping reading the contents of fileName for { str, err := reader.ReadString('\n') if err == io.EOF{ //Exit at the end of the file break } //Traverse str for statistics for _, v := range str { switch { //Instead of v to match, it is treated as an if branch structure statement case v >= 'a' && v <= 'z': fallthrough //Penetration, which forces the execution of the next line of statements case v >= 'A' && v <= 'Z': count.ChCount++ case v == ' ' || v == '\t': count.SpaceCount++ case v >= '0' && v <= '9': count.NumCount++ default : count.OtherCount++ } } } //Number of output statistics fmt.Printf("The number of characters is=%v The number of numbers is=%v The number of spaces is=%v The number of other characters is=%v", count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
}
### 2.14.6 flag package to parse command line parameters ```go package main import ( "fmt" "flag" ) func main () { var user string var pwd string var host string var port int //User is the parameter value after - u entered in the user command line flag.StringVar(&user,"u","","The user name is empty by default") flag.StringVar(&pwd,"pwd","","Password, blank by default") flag.StringVar(&host,"host","localhost","Host name, empty by default") flag.IntVar(&port,"port",3306,"Port number, 3306 by default") //transformation flag.Parse() //Output results fmt.Printf("user=%v pwd=%v host=%v port=%v",user,pwd,host,port) }
Terminal: D:\Go code \ SRC \ go_ code\chapter12> go build -o test.exe test.go
D:\Go code \ SRC \ go_ code\chapter12> test.exe -u root -pwd 132465 -host
127.0.0.5 -port 8080
2.15 test whether the function is executed correctly
//cal_test file package main import( _"fmt" "testing" //Introducing the testing framework in go ) //Write a test case to test whether addUpper is correct func TestAddUpper(t *testing.T) { //call res := addUpper(10) if res != 55 { t.Fatalf("AddUpper(10) Execution error, expected value=%v actual value=%v\n", 55, res) } //If correct, output the log t.Logf("AddUpper(10) Correct execution....") }
//Tested file package main //A function under test func addUpper(n int) int{ res := 0 for i := 1; i <= n - 1; i++ { res += i } return res }
result:
Schematic diagram of function execution:
matters needing attention: