GO学习

阅读数:0次 2022-09-04

1. 变量申明

1.1 声明变量，默认值是0

1 2	var a int fmt.Print("type of a = %T\n", a) // 查看类型

1.2 通过值自动匹配当前的变量数据类型

1 2	var b = 100 fmt.Print("type of b = %T\n", b) // 查看类型

1.3 省去var(常用)

1 2	c := 100 fmt.Print("type of c = %T\n", c) // 查看类型

1.4 多行多变量声明

var (
	vv int = 100
  jj bool = true
)

2. 常量声明

2.1 const

1	const length int = 10 // 只读属性，不可以修改

2.2 iota(计算常量行数)

从0开始算，iota只能配合const()使用

const (
  BEIJING = 10*iota // 0
  SHNAGHAI // 10 
  NANJING // 20
)

3. 返回值

3.1 单返回值

func foo1(a string, b string) int {
  return 123
}
// main
a := fool('123','123')

3.2 匿名多返回值

func foo2(a string, b string) (int, int){
  return 12, 23
}
// main
a1, a2 := foo2('12', '23')

3.3 形参名多返回值

func foo3(a string, b string) (r1 int, r2 int){
  r1 = 1000
  r2 = 2000
  return
}
// main
r1, r2 := foo3('123', '23')

4. 函数

4.1 导包

import (
	"fmt"
  "aa/do"
  meth "aa/meth" // 别名
)

4.2 init构造函数

1
2
3

func init(){
  fmt.Print("123")
}

5. defer

defer用于函数体运行完前执行的代码 === final

相当于压栈，先入栈的defer后出，后入先出

func main(){
  defer fmt.Print("end1")
  defer fmt.Print("end2")
  
  fmt.Print("ccc")
  fmt.Print("ddd")
}
// 结果
"ccc"
"ddd"
"end2" // 于最后执行
"end1" // 于最后执行

6. 切片(数组)

silce是引用传递所以修改时会修改原属组的数据属性

6.1 demo

1
2
3

myArray := []int{1,2,3,4,5}
fmt.Print("%T", myArray)
// 类型 []int

6.2 遍历

1
2
3

for index, value := range myArray{
  fmt.Print("value:", value)
}

6.3 四种声明方式

6.3.1 声明且初始化

声明slice是一个切片，并且初始化

1 2	slice := []int{1, 2, 3} fmt.Print("len=%d,slice=%v", len(slice), slice)

6.3.2 声明但不初始化

声明slice是一个切片，但是不初始化，就没有空间，所以需要使用make方法动态开辟空间

1 2	var slice []int slice = make([]int, 3)

6.3.2 简写声明和分配空间(常用)

1	slice := make([]int, 3)

6.4 追加元素

make()方法中加入两个参数，一个是初始化空间，一个是cap扩容空间(即每次扩容都按cap位自动扩容)

1
2
3

var numbers = make([]int, 3, 5)
fmt.Print("len=%d,cap=%d,slice=%v", len(numbers), cap(numbers), numbers)
// len =3, cap=5, slice = [0,0,0]

cap位提供自动扩容的机制，用于追加元素

numbers = append(numbers, 1)
// len =4, cap=5, slice = [0,0,0,1]
numbers = append(numbers, 2)
// len =5, cap=5, slice = [0,0,0,1,2]
// 超过容量就会自动扩容一次，所以cap位是扩容大小
numbers = append(numbers, 3)
// len =6, cap=10, slice = [0,0,0,1,2,3]

默认情况下，不单独设置cap位，就是cap=length

var numbers = make([]int, 3)
fmt.Print("len=%d,cap=%d,slice=%v", len(numbers), cap(numbers), numbers)
// len =3, cap=3, slice = [0,0,0]
// 扩容一次后cap=6

6.5 切片截取

与python很像，通过下标截取

s := []int{1,2,3}
// [0,2)
s1 := s[0:2]
fmt.Print(s1)
// [1, 2]

7. map

7.1 声明

7.1.1 声明map类型

声明map的key是string，value是string

var myMap1 map[string]string
//            key     value
// 这样依旧无法使用
myMap1 = make(map[string]string, 10)
// 开辟10个key value

7.1.1 声明map类型并提供空间(常用)

提供一个默认的空间大小

1 2	myMap1 := make(map[string]string) myMap['name'] = 'java'

7.2 使用

7.2.1 遍历

1
2
3

for key, value := range cityMap{
  fmt.Print("key:", key, "value:", value)
}

7.2.2 删除

1	delete(cityMap,"China")

7.2.3 修改

1	cityMap['USA'] = "aaa"

7.2.4 新增

1	cityMap['China'] = 'ggg'

8. struct

8.1 结构体定义

type Book struct{
  title string
  auth string
}
func setTitle(book *Book){
  book.auth = "aaa"
}
var book1 Book // 声明
book1.title = "bbb"
book1.auth = "ccc"
// {bbb ccc}
setTitle(&book1)
// {aaa ccc}

8.2 类

type Student struct{
  id int
  name string
}
func (this *Student) getId() int {
  return this.id
}
func (this *Student) getName() string{
  return this.name
}
func (this *Student) setName(name string){
  this.name = name
}
func (this *Student) setId(id string){
  this.id = id
}

//main
student := Student{}
student.setId(1)

8.3 继承

// 父类
type Human struct{
  id int
  name string
}

// 子类
type Student struct{
  Human
  age int
}
// main
s:= Student{Human{1, "zhangsan"}, 8}

8.4 接口

type AnimalIF interface{
  Eat()
  GetColor() string
  GetType() string
}
// 猫
typr Cat struct{
  color string
}
// 实现接口的所有方法
// ...不写了
// main
// 不好用的方法一
var animal AnimalIF
animal = &Cat{"Green"}
animal.GetColor() // Green
// 方法二
func showAnimal(animal AnimalIF){
  animal.GetColor()
}
cat := Cat{"Green"}
showAnimal(&cat)

8.5 万能数据类型/断言

func myFunc(arg interface{}){
  // 可以接收任何形式的参数
  // 区分数据类型,用“类型断言”的机制
  value, ok := arg.(string)
  value, ok := arg.(int)
}

9.反射

9.1 pair

pair是用于确定这个对象的实例是什么，在心中可以确认运行顺序

// b: pair<type:Book, value:book{}地址>
b := &Book{}
// r: pair<type:Book, value:book{}地址>
var r Reader = b

9.2 反射demo

func reflectNum(arg interface{}){
  fmt.Print("type:", reflect.TypeOf(arg)) // float64
  fmt.Print("value:", reflect.ValueOf(arg)) // 1.2345
}

// main
var num float64 = 1.2345
reflectNum(num)

9.3 获取复杂类型属性和方法

type User struct{
  id int
  name string
}
func (this *User) GetId() int {
  return this.id
}

// reflect
func DoReflectFieldAndMethod(arg interface{}) {
  // 获取传入的type
  argType := reflect.TypeOf(arg)
  // 获取传入的value
  argValue := reflect.ValueOf(arg)
  
  /**
  * 1. 获取interface的reflect.Type，通过Type得到NumFiled，进行遍历
  * 2. 得到每个filed数据类型
  * 3. 通过filed有一个Interface()方法得到对应的value
  */
  for i := 0; i < argType.NumField(); i++ {
    filed := argType.Field(i)
    value := argType.Field(i).Interface()
    fmt.Print(filed.Name, filed.Type, value)
  }
  
  for i := 0; i < argType.NumMethod(); i++ {
    m := argType.Method(i)
    fmt.Print(m.Name, m.Type)
  }
}

func main() {
  user := User{1, "zhansgan"}
  DoReflectFiledAndMethod(user)
}

9.4 反射解析结构体tag

// 结构体tag是跟在属性后面的标签
type User struct{
  id int `info:"id" doc:""`
  name string `info:"name"`
}
func findTag(str interface{}) {
  t := reflect.TypeOf(str).Elem()
  for i:= 0; i< t.NumField(); i++ {
    tagInfo := t.Field(i).Tag.Get("info")
    fmt.Print("info:", taginfo)
  }
}
func main() {
  user := User
  findTag(&user)
}

10. JSON

type Movie struct {
  Title string `json:"title"`
  Year int `json:"year"`
  Price int `json:"rmb"`
  Actors []string `json:actors`
}

func main() {
  movie := Movie{"喜剧之王", 2000, 10, []string{"zz","xx"}}
	// 编码
  jsonStr, err = json.Marshal(movie)
  if err != nil {
    fmt.Print("json marshal error", err)
    return
  }
  fmt.Print(jsonStr)
  // 解码
  myMovie := Movie{}
  err = json.Unmarshal(jsonStr, &muMovie)
  if err != nil {
    fmt.Print("json unmarshal error", err)
    return
  } 
  fmt.Print(myMovie)
}