Go基础笔记

1. 新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）
2. 否则 (cap <= 2 * old.cap) ：
   1. 旧切片的长度小于1024，则最终容量 (newcap) 就是旧容量 (old.cap) 的两倍
   2. 旧切片长度大于等于1024：
      1. 最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，直到最终容量（newcap）大于等于新申请的容量
      2. 如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）

切片截取

左闭右开区间 [startIndex:endIndex]

mySlice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
	fmt.Println("origin\t", mySlice)
	fmt.Println("[:3]\t", mySlice[:3])		// [0, 3)
	fmt.Println("[1:4]\t", mySlice[1:4])	// [1, 4)
	fmt.Println("[2:]\t", mySlice[2:])		// [2, len(mySlice))
	fmt.Println("[:]\t\t", mySlice[:])		// [0, len(mySlice))

注意：截取的切片底层是一致的，看起来就像浅拷贝一样

切片复制

copy(destSlice, srcSlice []T)

func main() {
	// copy()复制切片
	a := []int{1, 2, 3, 4, 5}
	b := make([]int, 5, 5)
	copy(b, a)     //使用copy()函数将切片a中的元素复制到切片b
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(b) //[1 2 3 4 5]
	b[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(b) //[1000 2 3 4 5]
}

切片元素删除

要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)

func main() {
	// 从切片中删除元素
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要删除索引为2的元素
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]
}

映射--map

map声明方式

• 方式一：声明空map，使用前需要make分配数据空间

  //声明myMap1是一种map类型 key是string， value是string
  var myMap1 map[string]string
  if myMap1 == nil {
      fmt.Println("myMap1 是一个空map")
  }
  
  //在使用map前， 需要先用make给map分配数据空间
  myMap1 = make(map[string]string, 2)
  
  myMap1["one"] = "java"
  myMap1["two"] = "c++"
  myMap1["three"] = "python"
  
  fmt.Println(myMap1)
  

• 方式二：声明并使用make

  myMap2 := make(map[int]string)
  
  myMap2[1] = "java"
  myMap2[2] = "c++"
  myMap2[3] = "python"
  
  fmt.Println(myMap2)
  

• 方式三：不用make，直接创建并初始化

  myMap3 := map[string]string{
      "one":   "php",
      "two":   "c++",
      "three": "python",
  }
  fmt.Println(myMap3)
  

map使用

• map 底层使用哈希，Go 采用的是数组 + 链地址法解决哈希冲突

• 删除元素

  delete(myMap, key)
  

• map做为形参，使用引用传递

OOP

struct

结构体作为参数，使用值传递

//声明一种行的数据类型 myint，是int的一个别名
type myint int

//定义一个结构体
type Book struct {
	title string
	auth  string
}

func changeBook(book Book) {
	//传递一个book的副本
	book.auth = "Jake"
}

func changeBook2(book *Book) {
	//指针传递
	book.auth = "Jake"
}

class

封装

• 如果类名首字母大写，表示其他包也能够访问
• 如果说类的属性首字母大写, 表示该属性是对外能够访问的，否则的话只能够类的内部访问
• 方法首字母大写，其他包也能访问

//如果类名首字母大写，表示其他包也能够访问
type Hero struct {
	//如果说类的属性首字母大写, 表示该属性是对外能够访问的，否则的话只能够类的内部访问
	Name  string
	Ad    int
	level int
}

func (obj *Hero) GetName() string {
	return obj.Name
}

func (obj *Hero) SetName(newName string) {
	obj.Name = newName
}

继承

package main

import "fmt"

type Human struct {
	name string
	sex  string
}

func (obj *Human) Eat() {
	fmt.Println("Human.Eat()...")
}
func (obj *Human) Walk() {
	fmt.Println("Human.Walk()...")
}

//=================
type SuperMan struct {
	Human // SuperMan 类继承了 Human 类的方法
	level int
}

//重定义父类的方法Eat()
func (obj *SuperMan) Eat() {
	fmt.Println("SuperMan.Eat()...")
}
//子类的新方法
func (obj *SuperMan) Fly() {
	fmt.Println("SuperMan.Fly()...")
}

func main() {
	h := Human{"Jake", "male"}
	h.Eat()
	h.Walk()

	fmt.Println("----------------")
	//定义一个子类对象
	//s := SuperMan{Human{"Jake", "male"}, 666}
	var s SuperMan
	s.name = "Jake"
	s.sex = "male"
	s.level = 666

	s.Walk() //父类的方法
	s.Eat()  //子类的方法
	s.Fly()  //子类的方法

}

多态

通过接口实现，接口本质是一个指针。

package main

import "fmt"

// 本质是一个指针
type AnimalIF interface {
	Sleep()
	GetColor() string // 获取动物的颜色
	GetType() string  // 获取动物的种类
}

// 具体的类
type Cat struct {
	color string // 猫的颜色
}
func (obj *Cat) Sleep() {
	fmt.Println("Cat is Sleep")
}
func (obj *Cat) GetColor() string {
	return obj.color
}
func (obj *Cat) GetType() string {
	return "Cat"
}

// 具体的类
type Dog struct {
	color string
}
func (obj *Dog) Sleep() {
	fmt.Println("Dog is Sleep")
}
func (obj *Dog) GetColor() string {
	return obj.color
}
func (obj *Dog) GetType() string {
	return "Dog"
}

func showAnimal(animal AnimalIF) {
	animal.Sleep() // 多态
	fmt.Printf("color = %s, kind = %s\n", animal.GetColor(), animal.GetType())
}

func main() {

	var animal AnimalIF // 接口的数据类型， 父类指针
	animal = &Cat{"Green"}
	animal.Sleep() // 调用的就是Cat的Sleep()方法, 多态的现象

	animal = &Dog{"Yellow"}
	animal.Sleep() // 调用Dog的Sleep方法，多态的现象

	cat := Cat{"Green"}
	dog := Dog{"Yellow"}

	showAnimal(&cat)
	showAnimal(&dog)
}

空接口 interface{} 是万能数据类型。interface{} 改如何区分此时引用的底层数据类型到底是什么？“类型断言” 的机制

package main

import "fmt"

// interface{} 是万能数据类型
func myFunc(arg interface{}) {
	// interface{} 改如何区分 此时引用的底层数据类型到底是什么？
	// 给 interface{} 提供 “类型断言” 的机制
	value, ok := arg.(string) // 判断是否是 string 类型
	if !ok {
		fmt.Printf("arg is not string type, type is %T\n", arg)
	} else {
		fmt.Println("arg is string type, value = ", value)
	}
}

func main() {
	myFunc(3.14)
	myFunc("abc")
}

反射

变量结构

var a string
// pair
a = "abcd"
// pair
var allType interface{}
//pair
allType = a

reflect包

reflect包文档：http://docscn.studygolang.com/pkg/reflect/

func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value
func (v Value) NumField() int
func (v Value) Field(i int) Value

func DoFiledAndMethod(input interface{}) {
	//获取input的type
	inputType := reflect.TypeOf(input)
	fmt.Println("inputType is :", inputType.Name())

	//获取input的value
	inputValue := reflect.ValueOf(input)
	fmt.Println("inputValue is:", inputValue)

	//通过type 获取里面的字段
	//1. 获取interface的reflect.Type，通过Type得到NumField ,进行遍历
	//2. 得到每个field，数据类型
	//3. 通过filed有一个Interface()方法等到 对应的value
	for i := 0; i 

type resume struct {
	Name string `info:"name" doc:"名字"`
	Sex  string `info:"sex"`
}

func findTag(str interface{}) {
	t := reflect.TypeOf(str).Elem()

	for i := 0; i