go语言与开发

go基础

go build  -o main *.go

package main
import (
	"fmt"
	"time"
)
func max(num1, num2 int) int {
	var res int
	if(num1 > num2){
		res = num1
	} else {
		res = num2
	}
	return res
}
type books struct {
	title string
	author string
	bookId int
	time time.Time
}
// 定义一个 DivideError 结构
type DivideError struct {
	dividee int
	divider int
}
// 实现 `error` 接口
func (de *DivideError) Error() string {
	strFormat := `
    Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0
`
	return fmt.Sprintf(strFormat, de.dividee)
}

// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
	if varDivider == 0 {
		dData := DivideError{
			dividee: varDividee,
			divider: varDivider,
		}
		errorMsg = dData.Error()
		return
	} else {
		return varDividee / varDivider, ""
	}

}

func main() {
	// 正常情况
	if result, errorMsg := Divide(100, 10); errorMsg == "" {
		fmt.Println("100/10 = ", result)
	}
	// 当除数为零的时候会返回错误信息
	if _, errorMsg := Divide(100, 0); errorMsg != "" {
		fmt.Println("errorMsg is: ", errorMsg)
	}
	// 结构体
	var book books
	book.title = "hello"
	book.author = "xxx"
	book.bookId = 12
	book.time = time.Now()
	fmt.Print(&book)

	fmt.Print("\n",book.time.Format("2006年1月2日 15:04:05"))
	var t = time.Now().UTC()
	fmt.Print("\n",t)
	fmt.Println("\nHello, World!")
	var n [10]int
	var i int

	for i = 0; i < 10; i++{
		n[i] = i * i
	}
	//var i,j int
	//for j = 0; j < 10; j++{
	//	fmt.Print(n[j] , "\n")
	//}

	//slice
	numbers0 := []int{0,1,2,3,4,5,6,7,8}
	numbers0 = append(numbers0, 0,1)
	fmt.Printf("%v\n",numbers0)
	
	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		fmt.Printf("%s -> %s\n", k, v)
	}
	capital, ok := kvs [ "a" ] /*如果确定是真实的,则存在,否则不存在 */
	/*fmt.Println(capital) */
	/*fmt.Println(ok) */
	if (ok) {
		fmt.Println("a是", capital)
	} else {
		fmt.Println("a不存在")
	}
	
	var numbers = make([]int,3,5)
	fmt.Printf("len=%d cap=%d slice=%v\n",len(numbers),cap(numbers),numbers )
    
	//函数
	var a int = 100;
	var b int = 200;
	var ret int
	ret = max(a,b)
	fmt.Print(ret)
}

go基础（类型，指针，数组，列表，字典，切片，结构体）

//类型转换
	var e uint16 = math.MaxInt8 + 1
	fmt.Println(e)
	fmt.Printf("%v\n",e)
	var e1 = uint8(e)
	fmt.Println(e1)
	fmt.Printf("%v\n",e1)

	str := "hello world"
	strPtr := &str
	fmt.Printf("%T,%v,%b",strPtr,strPtr,*strPtr)
	data := 1111
	fmt.Printf("\n%b",data)

	//指针
	str0 := new(string)
	*str0 = "sdsd"
	fmt.Printf(*str0)
	if(data == 1111){
		fmt.Printf("right\n")
	}
	//数组
	classMate := new([3]string)
	classMate[0] = "12"
	classMate[1] = "23"
	classMate[2] = "34"

	for k,v := range classMate{
		fmt.Println(k,v," ")
	}

	fmt.Println(*classMate)

	//列表
	tmpList := list.New()
	for i :=1; i<10; i++{
		tmpList.PushBack(i)
	}

	//字典（go语言提供的映射关系容器，内部通过散列表实现）
	classMap0 := map[int]string{
		12 : "sdsd",
		23 : "ssaf",
		78 : "sdsd",
	}
	for k,v := range classMap0{
		fmt.Println(k, v, " ")
	}

	classMap := make(map[int] string)
	classMap[21] = "sas"
	classMap[233] = "1qwa"

	fmt.Printf("id %v is %v \n",21,classMap[21])

	//切片
	sli := make([]int,2,4)
	fmt.Printf("len:%v\n",len(sli))
	fmt.Println(len(sli))

	ex := []int{1,2,3}
	fmt.Println(ex)
	fmt.Println(len(ex))
	fmt.Println(cap(ex))

	//结构体
	type books struct {
		title string
		author string
		bookId int
		time time.Time
	}
	//实例化方式
	var b1 books
	b1.bookId = 2
	
	b2 := new(books)
	b2.bookId = 3
	
	b3 := &books{}
	b3.bookId = 4
	
	b4 := books{
		title: "sd",
		author: "sd",
		bookId: 5,
		time: time.Now(),		
	}
	fmt.Println(b4.bookId)

	b5 := &books{
		 "sd",
		"sd",
		 5,
		time.Now(),
	}
	fmt.Println(b5.bookId)

函数（匿名函数和闭包，结构体接口，结构体嵌套调用）

闭包

func main() {
    b := tt(20)
	fmt.Println(b(20))
}

func tt(a int) func(b int) int{
	return func(b int) int {
		return a+b
	}
}

package main

import (
	"fmt"
	"time"
)
//回调函数
//接受string和匿名函数的参数输入，函数体内使用匿名函数对string进行处理
func proc(input string, processor func(str string)){
	processor(input)
}

//闭包 
// 匿名函数所访问的变量来自函数体外，则称此匿名函数为闭包
func counter(ini int) func() int {
	if ini < 0{
		ini =0
	}
	return func() int {
		ini ++
		return ini
	}
}


//结构体接口
type cat interface {
	catchMouse()
}

type dog interface {
	bark()
}

type catAndDog struct {
	name string
}
// cat接口
func (catdog *catAndDog) catchMouse(){
	fmt.Printf("cat! cat! %v\n",catdog.name)
}
// dog接口
func (catdog *catAndDog) bark(){
	fmt.Printf("dog! dog! %v\n",catdog.name)
}

//结构体组合嵌套
type swimming struct {
}

func (swim *swimming) swim() {
	fmt.Println("I am swimming")
}

type flying struct {
}
func (fly *flying) fly() {
	fmt.Println("I am flying")
}

type wildDuck struct {
	swimming
	flying
}
type demosticDuck struct {
	swimming
}



func main() {
	//匿名函数
	currentTime  := func(){
		fmt.Println(time.Now().Format("2006/1/2 15:04:05"))
	}
	//调用
	currentTime()

	//声明函数后，立即调用
	func (name string){
		fmt.Println(name)
	}("zhangsan")

	//回调函数（常用）
	proc("zhangsan", func(str string) {
		for _,v := range str{
			fmt.Printf("%c-",v)
		}
	})
	fmt.Println()

	//闭包：携带状态的函数，将函数内部外部连接起来，使得外部可以读取函数内部的变量,
	//不同闭包不会相互干扰
	c1 := counter(1)
	fmt.Println(c1())
	c2 := counter(10)
	fmt.Println(c2())

	//结构体接口
	catDog := &catAndDog{
		"sssssssssss",
	}

	var cat cat
	cat = catDog
	cat.catchMouse()

	var dog dog
	dog = catDog
	dog.bark()

	//结构体组合嵌套，直接引用成员
	wild := wildDuck{}
	wild.fly()
	wild.swim()

	demostic := demosticDuck{}
	demostic.swim()
}

go HTTP

 package main

 import (
  "fmt"
  "io"
  //"log"
  "net/http"
  "os"
  "strings"
  "time"
 )

 func sayHello(w http.ResponseWriter, r *http.Request)  {
  _ = r.ParseForm()
  fmt.Println(r.Form)
  fmt.Println("Path: ", r.URL.Path)
  fmt.Println("Host: ",r.Host)

  for k, v := range r.Form{
   fmt.Println("key:", k)
   fmt.Println("val: ", strings.Join(v,""))
   fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
  }
  _,_ = fmt.Fprintf(w, "hello web %s!", r.Form.Get("name"))

 }


 func main() {
   //http server
   //http.HandleFunc("/",sayHello)
   //err := http.ListenAndServe(":8080",nil)
   //if err != nil{
   // log.Fatal("ListenServer: ",err)
   //}

  // download img
  str := string("https://XXXX/IMG20201105_161203.jpg")
  //imageName0 := strings.Split(str, "/")[5] //not good
  //fmt.Println(imageName0)
  poi := strings.LastIndex(str,"/")
  imageName1 := str[poi+1 : len(str)] // good
  fmt.Println(poi)
  fmt.Println(imageName1)

  res, err := http.Get(str)
  if err != nil {
   panic(err)
  }
  f, err := os.Create(imageName1)
  if err != nil {
   panic(err)
  }
  io.Copy(f, res.Body)
 }

go工程组织

• go build 编译包，如果是main包则在当前目录生成可执行文件，其他包不会生成.a文件；
• go install 编译包，同时复制结果到$GOPATH/bin，$GOPATH/pkg等对应目录下；
• go run gofiles… 编译列出的文件，并生成可执行文件然后执行。

goland启动一个工程

①建main文件
②修改configuration
③settings -> Go Modules -> Enable Go Modules integration
④进入工程目录 go mod init example.com/m
此时目录下出现go.mod
开发代码…
⑤开发结束后，

mkdir vendor
go mod vendor
出现以下错误，需要修改GOPATH，把它移到另一个目录即可
$GOPATH/go.mod exists but should not

即可把依赖的包拷贝到vendor目录下