【Go自学版】01-基础

// 变量
var a, b, c = 8, 2.3, "hello"
var d float64;
e := 6

var A []int;
var B [10]int;
C := [10]int{1, 2, 3, 4}
for i := 0; i < len(B); i ++ {}
for _, value := range C {}
D = make([]int, 3)
// len = 4, cap = 10, 扩容方式 cap*=2
E := make([]int, 4, 10)
E = append(E, 1)
E1 := E[0:2] // 浅拷贝，公用底层
E2 := make([]int, 3) 
copy(E2, E) // 深拷贝
E1[0] = 100 // E会改变，E2不会改变

// 导包方式
import (
	new_name "package_name1"
	"package_name2"
	. "package_name3"
)

// typedef
type myint int

// map
var mp map[string]string
if mp == nil {fmt.Printf("空\n")}
mp = make(map[string]int, 10)
mp["one"] = 1
mp["two"] = 2

cMap := make(map[string]string)
cMap["one"] = "1"
cMap["two"] = "22"
delete(cMap, "one")
cMap["two"] = "2"

// 析构函数, stack
func main() {
	defer fmt.Printf("defer 1\n")
	defer fmt.Printf("defer 2\n")
}

// 函数名开头小写表示私有,大写表示公有
func funName1() {}
func FunName2(a int, b string) (int, string) {
	ans := a
	var s string = b
	return ans, s
}

// 本质是一个指针
type AnimalIF interface {
	Eat()
	Sleep()
	GetName() string
}

type Dog struct {
	name string
}

func (this *Dog) Eat() {
	fmt.Printf("Dog eat\n")
}

func (this *Dog) Sleep() {
	fmt.Printf("Dog sleep\n")
}

func (this *Dog) GetName() string {
	return this.name
}

type Cat struct {
	name string
}

func (this *Cat) Eat() {
	fmt.Printf("Cat eat\n")
}

func (this *Cat) Sleep() {
	fmt.Printf("Cat sleep\n")
}

func (this *Cat) GetName() string {
	return this.name
}

func main() {
	var animal AnimalIF
	animal = &Cat{"mike"}
	animal.Eat()
	animal.Sleep()

	dog := Dog{"jack"}
	fmt.Println(dog.GetName())
}

func testInterface(x interface{}) {
	value, f := x.(string)
	if f {
		fmt.Printf("value is %s", value)
		fmt.Printf("type is string")
	} else {
		fmt.Printf("type is not string")
	}
}

// [type, value]
type User struct {
	Id   int
	Name string
}

func (this User) Call() {
	fmt.Printf("user is called\n")
	fmt.Printf("%v\n", this)
}

func reflectVar(x interface{}) {
	xValue := reflect.ValueOf(x)
	xType := reflect.TypeOf(x)
	fmt.Println(xType, xValue)
	for i := 0; i < xType.NumField(); i++ {
		field := xType.Field(i)
		value := xValue.Field(i).Interface()
		fmt.Printf("%s: %v = %v\n", field.Name, field.Type, value)
	}
	for i := 0; i < xType.NumMethod(); i++ {
		m := xType.Method(i)
		fmt.Printf("%s: %v\n", m.Name, m.Type)
	}
}

func main() {
	user := User{11, "mike"}
	reflectVar(user)
}

package main

import "fmt"

type Attacker interface {
	Attack() error
}

type StrongAttacker struct{}

func (sa StrongAttacker) Attack() error {
	fmt.Println("Wooow, what a strong attack!!")
	return nil
}

type SuperStrongAttacker struct{}

func (sa SuperStrongAttacker) Attack() error {
	fmt.Println("OOF, what a syper strong attack!!")
	return nil
}

func DoAttack(a Attacker) error {
	return a.Attack()
}

func main() {
	DoAttack(StrongAttacker{})
	DoAttack(SuperStrongAttacker{})
}

// 标签
type User struct {
	Id   int    `info:"id" doc:"编号"`
	Name string `info:"name" doc:"姓名"`
}

func FindTag(x interface{}) {
	// 传指针 FindTag(&user)
	t := reflect.TypeOf(x).Elem()
	// 传值 FindTag(user)
	//t := reflect.TypeOf(x)

	for i := 0; i < t.NumField(); i++ {
		tagString := t.Field(i).Tag.Get("info")
		docString := t.Field(i).Tag.Get("doc")
		fmt.Println("info: ", tagString, ",", "doc: ", docString)
	}
}

// json
type Moive struct {
	// 变量开头大写且加tag才能进json
	Title  string   `json:"title"`
	Year   int      `json:"year"`
	Price  float64  `json:"price"`
	Actors []string `json:"actors"`
}

func ReadJson(movie interface{}) {
	jsonStr, err := json.Marshal(movie)
	if err != nil {
		fmt.Printf("json marshal error %v\n", err)
	} else {
		fmt.Printf("jsonStr = %s\n", jsonStr)
		newMovie := Moive{}
		err = json.Unmarshal(jsonStr, &newMovie)
		if err != nil {
			fmt.Printf("json unmarshal error %v\n", err)
		} else {
			fmt.Printf("newMoive: %v\n", newMovie)
		}
	}

}

func main() {
	user := User{11, "mike"}
	fmt.Println(user)
	FindTag(&user)

	movie := Moive{"喜剧之王", 2000, 10, []string{"周星驰", "张柏芝"}}
	ReadJson(movie)
}

命令	功能
go mod init	生成 go.mod 文件
go mod vendor	导出项目所有依赖到 vendor 目录
go mod edit	编辑 go.mod 文件
go mod download	下载 go.mod 文件中指明的所有依赖
go mod tidy	整理现有的依赖
go mod graph	查看现有的依赖结构
go mod verify	校验一个模块是否被篡改过
go mod why	查看为什么需要依赖某模块

参数	功能
GO111MODULE	是否开启 go modules 模式
GOPROXY	项目第三方依赖下载源地址
GOSUMDB	校验拉取的第三方库是否完整
GONOPROXY	设置 GOPRIVATE 即可
GONOSUMDB	设置 GOPRIVATE 即可
GOPRIVATE	当前项目根据GOPRIVATE下载(可用通配符 eg：*.exmaple.com，https://github.com/xxxx/xxx)

文件	功能
go.mod	当前项目模块名称，go版本号
.go	源代码
znet	项目直接依赖的是znet包
zinx	项目间接依赖的是zinx包
go.sum	罗列当前项目直接或间接依赖的所有模块版本，保证之后项目的以来版本不被篡改

$go.sum:h1:hash|xxx/go.modh1:hash$