一、下载GO

go安装文件以及源代码 Downloads - The Go Programming Language
下载对应平台的二进制文件以及安装
环境变量
GOROOT： go的安装目录
GOPATH： src 存放源代码
pkg 存放依赖包
bin 存放可执行文件
其他常用变量： GOOS GOARCH GOPROXY
GOPROXY建议使用： export GOPROXY=goproxy.cn

二、GO语言一些基本命令

build: 编译包和依赖
clean: 移除对象文件
doc: 显示包或者符号的文档
env: 打印go的环境信息
bug: 启动错误报告
fix: 运行go tool fix
fmt: 运行gofmt进行格式化
generate: 从processing source生成go文件
get: 下载并安装包和依赖
install: 编译并安装包和依赖
list: 列出包
run: 编译并运行go程序
test: 运行测试
tool: 运行go提供的工具
version: 显示go的版本
vet: 运行go tool vet
mod: module maintenance 三、 Go语言的基本控制结构

1. If

if condition1 {
        // do something
} else if condition2 { 
        // do something else 
} else {
        // catch-all or default
}
if v:= x; v < 0 {
        // do something
}

2. Switch

switch var1 {
        case val1:
        case var2:
                fallthrough
        case val3:
                f()
        default:
                ...
}

3. for

for i := 0; i < 100; i++ {
        sum += 1
} 
for ; sum < 100; {
        sum += 10
}
for {
        if condition {
                break
        }
        // do something
}

三、Go语言的数据结构

1. 变量和常量

const identifier type
var identifier type

2. 类型转换

var i int = 1
var f float64 = float64(i) 或者 f := float64(i)

3.Make 和 New

New是返回指针的地址
Make则为返回第一个元素，可预设内存空间，避免未来的内存拷贝

四、Go语言函数

1. Go语言传参方式

// method 1
fmt.Println("os args is:", os.Args)
//method 2
name := flag.String("name", "sen", "input you english name")
flag.Parse()

2. Init函数

Init函数会在包初始化的时候运行
当多个依赖引用统一的项目，且被引用项目的初始化在init中完成，并且不可重复运行时，会导致启动错误

var myVariable int = 0
func init() {
    myVariable = 1
}

3. 传递变长参数

func append(slice []Type, elems ...Type) []Type

4. 回调函数

func Callback(x int, f func(int, int)) {
    f(x, x)
}

5. 方法接口

方法：作用在接受者上的函数
func (recv receiver_type) method(parameter_list) (return_value_list)

package main
 
import "fmt"
 
type Human struct {
	first, last string
}
 
func (h *Human) getName() string {
	return h.first + " " + h.last
}
 
type IF interface {
	getName() string
}
 
type Car struct {
	first1, last1 string
}
 
func (c Car) getName() string {
	return c.first1 + " " + c.last1
}
 
func main() {
	interfaces := []IF{}
	h := new(Human)
	h.first = "ri"
	h.last = "bbon"
 
	c := new(Car)
	c.first1 = "car"
	c.last1 = "car1"
	interfaces = append(interfaces, h)
	interfaces = append(interfaces, c)
	for _, it := range interfaces {
		fmt.Println(it.getName())
	}
 
	g := Human{}
	g.first = "aa"
	g.last = "cc"
	fmt.Println(g.getName())
 
	c = new(Car)
	c.first1 = "ri"
	c.last1 = "bbon"
	fmt.Println(c.getName())
}

6. 反射机制

TypeOf 返回被检查对象的类型
ValueOf返回被检查对象的值

package main
 
import (
	"fmt"
	"reflect"
)
 
type T struct {
	A string
	b string
}
 
func (t T) GetString() string {
	return t.A + "-----"
}
 
func main() {
	my_map := make(map[string] string, 10)
	my_map["a"] = "b"
	t := reflect.TypeOf(my_map)
	v := reflect.ValueOf(my_map)
	fmt.Println(t, v, v.NumMethod())
 
	my_struct := T{A: "11", b: "cc"}
	fmt.Println(reflect.TypeOf(my_struct))
	v = reflect.ValueOf(my_struct)
	fmt.Println(v.NumMethod(), v.NumField(), 
		v.Method(0).Call(nil), v.Field(0), 
		v.Field(1))
}

7. Go语言中的面向对象编程

可见性控制
- public - 常量、变量、类型、接口、结构、函数等的名称大写
- private - 非大写的只能包內使用
继承
- 通过组合实现，内嵌一个或者多个struct
多态
- 通过接口实现，通过接口定义方法集，编写多套实现

8. Json编解码

Marshal: 从struct --> string
Unmarshal: 从string --> struct

package main
 
import (
	"encoding/json"
	"fmt"
	"reflect"
)
 
type Human struct {
	Name string
	Age int
}
 
func StringToStruct(humanStr string) Human  {
	h := Human{}
	err := json.Unmarshal([]byte(humanStr), &h)
	if err != nil {
		fmt.Println(err)
	}
	return h
}
 
func structToString(h Human) string {
	h.Age = 30000
	h.Name = "ribbon"
	updateBytes, err := json.Marshal(h)
	if err != nil {
		fmt.Println(err)
	}
 
	return string(updateBytes)
}
 
func main() {
	h := Human{}
	s := structToString(h)
	fmt.Println(s)
	
	human := StringToStruct(s)
	fmt.Println(reflect.ValueOf(human))
}

Json包使用map[string]interface{} 和 []interface{} 类型保存任意对象

package main
 
import (
	"encoding/json"
	"fmt"
)
 
type Human struct {
	Name string
	Age int
}
 
func structToString(h Human) string {
	h.Age = 30000
	h.Name = "ribbon"
	updateBytes, err := json.Marshal(h)
	if err != nil {
		fmt.Println(err)
	}
 
	return string(updateBytes)
}
 
func main() {
	h := Human{}
	s := structToString(h)
	fmt.Println(s)
 
	var obj interface{}
	err := json.Unmarshal([]byte(s), &obj)
	if err != nil {
		return
	}
	objMap, _ := obj.(map[string]interface{})
	for key, value := range objMap {
		switch value.(type) {
		case string:
			fmt.Printf("%s: %s ", key, value)
		case int:
			fmt.Printf("%s: %d ", key, value)
		default:
			fmt.Printf("%s: %v ", key, value)
		}
	}
 
	var obj1 map[string] interface{}
	err = json.Unmarshal([]byte(s), &obj1)
	if err != nil {
		return
	}
	for key, value := range obj1 {
		switch value.(type) {
		case string:
			fmt.Printf("%s: %s ", key, value)
		case int:
			fmt.Printf("%s: %d ", key, value)
		default:
			fmt.Printf("%s: %v ", key, value)
		}
	}
}

9. 错误处理

Go没有内置的exception机制，只提供error接口供定义错误

type error interface {
        Error() string

}

可以通过error.New or fmt.Errorf创建新的error，通常应用程序对error的处理大部分是判断error是否为nil

10. defer Panic recover

defer这个相当于python java的finally
panic：可以再系统出现不可恢复错误的时候主动调用panic， panic会使当前线程直接crash
recover: 函数从panic或者错误场景中恢复

defer func() {
	if err := recover(); err != nil {
			fmt.Println(err)
	}
} ()
panic("\njson is error\n")

GO语言基础入门 | 青训营笔记