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")
}
}