GO第二天学习

GO指针

区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针

指针在Go语言中可以被拆分为两个核心概念：
类型指针 允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
切片 由指向起始元素的原始指针、元素数量和容量组成。

受益于这样的约束和拆分，Go语言的指针类型变量即拥有指针高效访问的特点，又不会发生指针偏移，从而避免了非法修改关键性数据的问题。同时，垃圾回收也比较容易对不会发生偏移的指针进行检索和回收。

切片比原始指针具备更强大的特性，而且更为安全。切片在发生越界时，运行时会报出宕机，并打出堆栈，而原始指针只会崩溃。

func modify1(x int) {
	x = 100
}
func modify2(x *int) {
	*x = 100
}
func main() {
	a := 10
	modify1(a)
	fmt.Println(a) // 10
	modify2(&a)
	fmt.Println(a) // 100
}

new和make函数

func new(Type) *Type
返回一个指针类型，所以可以用 new来分配内存并且创建指针

var str *string
str = new(string)
*str = "helloworld"
fmt.Println(*str)

func make(t Type, size ...IntegerType) Type
给一个数据类型，开辟多大空间，最后返回该数据类型

func main() {
	var b map[string]int
	b = make(map[string]int, 10)
	b["张三"] = 100
	fmt.Println(b)
}

new与make的区别
都可以用来做内存分配
make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身
new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针

结构体

Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念
Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性

type person struct {
	name string
	city string
	age  int8
}
func main() {
	var p1 person
	p1.name = "张三"
	p1.city = "北京"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)
	//p1={张三 北京 18}
	fmt.Printf("p1=%+v\n", p1)
	//p1={name:张三 city:北京 age:18}
	fmt.Printf("p1=%#v\n", p1)
	//p1=main.person{name:"张三", city:"北京", age:18}
}
 %v  只输出值
 %+v 输出对应键值
 %#v 输出结构体名{对应键值}

匿名结构体
就不是 type 定义了，而是 var

func main() {
    var user struct{Name string; Age int}
    user.Name = "小王子"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

还可以 new 函数来创建指针类型的结构体，得到的是结构体的地址

src := new(person)
src.name = "aaa"
src.city = "bbb"
src.age = 15
fmt.Printf("%+v", src)

结构体匿名字段

type Person struct {
	string
	int
}
//main.Person{string:"北京", int:18}

并不是没有字段名，而是默认把类型名当做字段名
构造函数

Go语言没有构造函数的功能，但是我们可以使用结构体初始化的过程来模拟实现构造函数

type person struct {
	name string
	city string
	age  int8
}
func newperson(name string, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}
func main() {
	src := newperson("张三", "北京", 18)
	fmt.Printf("%+v", src)
	//&{name:张三 city:北京 age:18}
}

父子关系的结构体的构造和初始化——模拟父级构造调用

type Cat struct {
    Color string
    Name  string
}
type BlackCat struct {
    Cat  
    // 嵌入Cat, 类似于派生，实例化时，BlackCat 中的 Cat 也会一并被实例化。
}
// “构造基类”
func NewCat(name string) *Cat {
    return &Cat{
        Name: name,
    }
}
// “构造子类”
func NewBlackCat(color string) *BlackCat {
    cat := &BlackCat{}
    cat.Color = color
    return cat
}

方法的接收者

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数){}

func (self Person) age_1(age int8) {
	self.age = age
}
func (self *Person) age_2(age int8) {
	self.age = age
}
func main() {
	p1 := NewPerson("张三", 18)
	p1.age_1(10)
	fmt.Printf("%+v", p1)
	p1.age_2(100)
	fmt.Printf("%+v", p1)
}

p1 是person 结构体类型，所以可以调用 Dream函数
age_1 中是值类型的接收者，无法修改变量本身的值
age_2 中是指针类型的接收者，所以是可以修改值的

注意
结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）

结构体标签 Tag

Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。
Tag在结构体字段的后方定义，由一对反引号包裹起来

type Student struct {
	ID     int    `json:"id"` //通过指定tag实现json序列化该字段时的key
	Gender string //json序列化是默认使用字段名作为key
	name   string //私有不能被json包访问
}
func main() {
	s1 := Student{
		ID:     1,
		Gender: "男",
		name:   "张三",
	}
	data, _ := json.Marshal(s1)
	fmt.Printf("json str:%s\n", data)
	//json str:{"id":1,"Gender":"男"}
}

Go导包

import (
    f "fmt"
    o "os"
	_ "encoding/json"
)
可以自定义别名，也可以只加载这个包，加载这个包中的资源初始化，init 函数将被执行且仅执行一遍

Go语言中不允许引入包却不在代码中使用这个包，如果引入了未使用的包则会触发编译错误

init 函数初始化

func init(){}

不接收任何参数也没有任何返回值，代码中也不能主动调用它
一个包的初始化过程是按照代码中引入的顺序来进行的，所有在该包中声明的 init 函数都将被串行调用并且仅调用执行一次。
每一个包初始化的时候都是先执行依赖的包中声明的init函数再执行当前包中声明的 init 函数。确保在程序的main函数开始执行时所有的依赖包都已初始化完成。

Go接口

type 接口名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
}

接口类型变量

假设Dog 和Cat 类型均实现了Sayer 接口，此时一个Sayer类型的变量就能够接收Cat和Dog类型的变量

var x Sayer // 声明一个Sayer类型的变量x
a := Cat{}  // 声明一个Cat类型变量a
b := Dog{}  // 声明一个Dog类型变量b
x = a       // 可以把Cat类型变量直接赋值给x
x.Say()     // 喵喵喵
x = b       // 可以把Dog类型变量直接赋值给x
x.Say()     // 汪汪汪

同一个类型实现不同的接口互相不影响使用
一个接口的所有方法，也不一定需要由一个类型完全实现
接口的方法可以通过在类型中嵌入其他类型或者结构体来实现

// WashingMachine 洗衣机
type WashingMachine interface {
	wash()
	dry()
}
// 甩干器
type dryer struct{}

// 实现WashingMachine接口的dry()方法
func (d dryer) dry() {
	fmt.Println("甩一甩")
}
// 海尔洗衣机
type haier struct {
	dryer //嵌入甩干器
}
// 实现WashingMachine接口的wash()方法
func (h haier) wash() {
	fmt.Println("洗刷刷")
}

接口和接口可以相互嵌套，接口和结构体也可以嵌套

空接口

空接口是指没有定义任何方法的接口类型
因此任何类型都可以视为实现了空接口
所以空接口类型的变量可以存储任意类型的值

var x interface{}
x = "张三"
fmt.Printf("%T", x)

空接口可以作为函数的参数，接收任意类型的参数
空接口可以作为map 的值，接收任意类型的值

接口值

接口类型的值可以是任意一个实现了该接口的类型值
所以接口值除了需要记录具体值之外，还需要记录这个值属于的类型
也就是说接口值由“类型”和“值”组成，这两部分会根据存入值的不同而发生变化，我们称之为接口的动态类型和动态值

类型断言

x.(T)
意思是 x 可能是 T类型的
返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值
若为true则表示断言成功，为false则表示断言失败。

var n Mover = &Dog{Name: "旺财"}
v, ok := n.(*Dog)
if ok {
	fmt.Println("类型断言成功")
	// 变量v是*Dog类型
} else {
	fmt.Println("类型断言失败")
}

Error接口

Go 语言中的错误处理与其他语言不太一样，它把错误当成一种值来处理
更强调判断错误、处理错误，不支持其他语言中使用try/catch捕获异常的方式。

当一个函数或方法需要返回错误时，通常是把错误作为最后一个返回值。例如标准库 os 中打开文件的函数。

//Go 语言中使用一个名为 error 接口来表示错误类型。
type error interface {
    Error() string
}


func Open(name string) (*File, error) {
	return OpenFile(name, O_RDONLY, 0)
}
if err != nil {
	fmt.Println("打开文件失败,err:", err)
	return
}

由于 error 是一个接口类型，默认零值为nil。
所以我们通常将调用函数返回的错误与nil进行比较，以此来判断函数是否返回错误。

自定义错误

// errors 包提供的New函数创建一个错误。
func New(text string) error


func queryById(id int64) (*Info, error) {
	if id <= 0 {
		return nil, errors.New("无效的id")
	}
}