第四章 Go语言开发应用

忘是亡心i 2023-06-02 13:56 19阅读 0赞

## 一、接口 ##

#### 　　定义 ####

接口定义了一个对象的行为规范，制定以规范并不实现，具体的对象需要实现规范的细节

//接口定义
    type 接口名 interface {    //定义一个接口
        Talk()
        Eat() int    //返回int型
        Run()
    }

#### 　　接口的实现 ####

一个对象只要包含接口中的方法，那么就是实现了这个接口，接口类型的变量可以保存具体类型的实例

type Animal interface{
        Talk()
        Eat()
        Name() string
    }
    type Dog struct{
    }
    func (d Dog) Talk(){
        fmt.Println("汪汪")
    }
    func (d Dog) Eat(){
        fmt.Println("吃骨头")
    }
    func (d Dog) Name() string{
        fmt.Println("旺财")
        return "旺财"
    }
    func test(){
        var b Dog
        var a Animal
        a = b
        a.Name()
        a,Eat()
        a.Talk()
    }

#### 　　接口调用sort排序 ####

type Student struct {
        Name string
        Id   string
        Age  int
    }
    type StudentArray []Student
    func (p StudentArray) Len() int {
        return len(p)
    }
    func (p StudentArray) Less(i, j int) bool {
        return p[i].Name > p[j].Name
    }
    func (p StudentArray) Swap(i,j int) {
        p[i],p[j] = p[j],p[i]
    }
    func test(){
        var stus StudentArray
        for i := 0;i<10;i++{
            stu := Student{
                Name : fmt.Sprintf("stu%d",rand.Intn(100)),
                Id : fmt.Sprintf("110%d",rand.Intn()),
                Age : randIntn(100),
            }
            stus = append(stus,stu)
        }
        for _,v := range stus{
            fmt.Println(v)
        }
        fmt.Println("\n\n")
        sort.Sort(stus)
        for _,v := range stus{
            fmt.Println(v)
        }
    }

#### 　　空接口 ####

空接口没有定义任何方法，所以任何类型都能实现空接口

func test(){
        var a interface{}
        var b int = 100
        a = b
        fmt.Printlf(%T %v\n",a,a)    //int 100
        var c string = "hi"
        a = c
        fmt.Printf("%T %v\n",a,a)    //string hi
        var d map[string]int = make(map[string]int,10)
        d["abc"] = 100
        d["aaa"] = 30
        a = d
        fmt.Printf("%T %v\n",a,a)    //map[string]int map[abc:100 aaa:30]
    }
    
    func Descrtribe(a interface{}){
        fmt.Printf("type = %T %v\n",a,a)
    }
    type Student struct{
        Name string
        Sex int
    }
    func test2(){
        a := 99
        describe(a)    //type=int 99
        b := "hello"
        describe(b)    //type = string hello
        var stu Student = Student{
            Name:"user01",
            Sex:1,
        }
        describe(stu)    //type = main.Student {user01 1}
    }

#### 　　类型断言 ####

获取接口类型里面存储的具体值

//OK语句判断
    func describe(a interface{}) {
        s,ok := a.(int)
        if ok {    //使用ok语法，防止传入类型错误报错
            fmt.Println(s)
            return
        }
        str,ok := a.(string)
        if ok{
            fmt.Println(str)
            return
        }
        f,ok := a.(float32)
        if ok {
            fmt.Println(f)
            return
        }
        fmt.Println("输入错误")
        return
    }
    func test(){
        var a int = 100
        describe(a)
        var b string = "hi"
        describe(b)
    }
    
    //sitch-type语句判断
    func testSwitch(a interface{}) {
        switch v := a.(type) {
        case stirng:L
            fmt.Printf("a is string,value:%v\n",v)
        case int:
            fmt.Printf("a is int,value:%v\n", v)
        case float32:
            fmt.Printf("a is float32,value:%v\n", v)
        default:
            fmt.Println("not support type\n")
        }
    }
    func test2(){
        var a int = 100
        testSwitch(a)
        var b string = "Parallel"
        testSAwitch(b)
    }

#### 　　指针接收和值接收区别 ####

值类型实现的接口指针类型变量可以存入，指针类型实现的接口值类型变量不能存入

//同一兑现够可以实现多个接口
    type Animal interface{
        Talk()
    }
    type Bu interface{
        Bu()
    }
    type Dog struct{
    }
    func (d Dog) Talk(){
        fmt.Println("汪汪")
    }
    func (d Dog) Bu(){
        fmt.Println(*狗是哺乳动物")
    }
    func test(){
        var d Dog
        var a Animal
        a = d
        a.Talk()
        var b Bu
        b = d  
        b.Bu()
    }

#### 　　接口实现链表 ####

type LinkNode struct{
        data interface{}
        next *LinkNode
    }
    type Link struct {
        head *LinkNode
        tail *LikNode
    }
    func (p *Link) InsertHead(data interface{}) {
        node := &LinkNode{
            data : data,
            next : nil,
        }
        if p.taiil == nil && p.head == nil{
            p.tail = node
            p.head = node
            return
        }
        node.next = p.head
        p.head = node
    }
    func (p *Link) InsertTail(data interfdace{}) {
        node := &LinkNode{
            data : data,
            next : nil,
        }
        if p.tail == nil && p.head{
            p.tail = node
            p.head = node
            reutrn
        }
        p.tail.next = node
        p.tail = node
    }
    func (p *Link) Trans(){
        q := p.head
        if q != nil {
            fmt.Println(q.data)
            q = q.next
        }
    }
    func main(){
        var intLink Link
        for i := 0;i<10;i++{
            intLink.InsertHead(i)
            intLink.InsertTail(i)
        }
        intLink.Trans()
    }

接口嵌套

type Animal interface {
        Eat()
    }
    type Describle interface {
        Describled()
    }
    type AdvanceAnimal interface {
        Animal
        Describle
    }
    type Dog struct {
    }
    func (d Dog) Eat() {
        fmt.Println("狗吃屎")
    }
    func (d Dog) Describled() {
        fmt.Println("狗")
    }
    func test() {
        var d Dog
        var a AdvanceAnimal
        a = d
        a.Eat()
        a.Describled()
    }

## 二、反射 ##

#### 　　定义 ####

空接口可以存储任何类型的变量，在运行时动态的获取一个变量的类型信息和值信息就是反射

//获取类型信息：reflect.TypeOf
    import {
        "fmt"
        "reflect"
    }
    func reflect_example(a interface{}) {
        t := reflect.TypeOf(a)
        fmt.Printf("type of a is:%v\n",t)
    }
    func test(){
        var x float32 = 3.4
        reflect_example(x)
    }
    
    //获取变量的类型：Type.Kind()
    import (
        "fmt"
        "reflect"
    }
    func reflect_example(a interface{}) {
        t := reflect.TypeOf(a)
        fmt.Printf("type of a is :%v\n",t)
        k := t.Kind()
        switch k {
        case reflect.Int64:
            fmt.Println("a is int64")
        case reflect.String:
            fmt.Printf("a is string")
        }
    }
    func test() {
        var x float32 = 3.4
        reflect_example(x)
    }
    
    //获取值信息：reflect.ValueOf
    func reflect_value(a interface{}) {
        v := reflect.ValueOf(a)
        k := v.Kind()
        switch k {
        case reflect.Int64:
            fmt.Printf("a is int64,value is :%d",v.int())
        case reflect.Float64:
            fmt.Printf("a is Float64,value is:%f",v.Float())
        }
    }
    func test() {
        var x float64 = 3.4
        reflect_value(x)
    }
    
    //反射设置变量值：value.Elem().SetFloat()
    func reflect_set_value(a interface{}) {
        v := reflect.ValueOf(a)
        k := v.Kind()
        switch k {
        case reflect.Int64:
            v.SetInt(100)
            fmt.Printf("a is int64,value is :%d",v.Int())
        case reflect.Float64:
            v.SetFloat(6.8)
            fmt.Printf("a is Float64,value is:%f",v.Float())
        case reflect.Ptr:
            fmt.Printf("set a to 6.8\n")
            qv.Elem().SetFloat(6.8)    //Elem()相当于指针赋值中的*
        }
    }
    func test() {
        var x float64 =  3.4
        reflect_set_valur(&x)
        fmt.Printf("x value is %v\n",x)
    }
    /*
    注：
        var *p int = new(int)
        *p = 100    //正常指针赋值，设置的值需要和变量类型匹配
    */

#### 　　结构体反射 ####

获取和设置结构体字段的信息

//获取结构体信息
    type Student struct {
        Name string
        Sex int
        Age int
    }
    func test(){
        var s Student
        v := reflect.ValueOf(s)
        t := v.Type()
        kind := t.Kind()
        switch kind {
        case reflect.Int64:
            fmt.Printf("s is int64\n")
        case reflect.Float32:
            fmt.Println("s is Float32\n")
        case reflect.Struct:
            fmt.Printf("s is struct\n")
            fmt.Printf("field num of s is %d\n",v.NumField())    //获取结构体的参数个数用NumField()
            for i:= 0;i<v.NumField();i++ {
                field := v.Field(i)
                fmt.Printf("name:%s type:%v value:%v\n",t.Field(i).Name,field.Type(),field.Interface())
            }
        default:
            fmt.Println("default")
        }
    }
    
    //设置结构体相关字段的值
    type Student struct {
        Name stirng
        Sex int
        Age int
    }
    func test(){
        var s Student
        v := reflect.ValueOf(&s)
        v.Elem().Field(0).SetString("stu01")
        v.Elem().FieldByName("Sex").SetInt(2)
        v.Elem().FieldByName("Age").SetInt(15)
        fmt.Printf("s:%#v\n",s)
    }

#### 　　获取和调用结构体方法中的信息 ####

//获取结构体的方法信息
    type Student struct {
        Name string
        Sex int
        Age int
        Score float32
    }
    func (s *Student) SetName(name string) {
        s.Name = name
    }
    func (s *Student) Print(){
        fmt.printf("%#v\n",s)
    {
    func test(){
        var s Student
        s.SetName("xxx")
        v := reflect.ValueOf(&s)
        t := v.Type()
        fmt.Printf("struct student have %d methods\n",t.NumMethod())
        for i := 0;i<NumMethod();i++ {
            method := t.Method(i)
            fmt.Printf("struct %d method,name:%s type :%v\n",i,method.Name,method.Type)
        }
    }
    
    //调用结构体中的方法
    type Student struct {
        Name string
        Sex int
        Age int
        Score float 32
    }
    func (s *Student) SetName(name string) {
        s.Name = name
    }
    func (s *Student) Print() {
        fmt.Printf("%#v\n",s)
    }
    func test2() {
        var s Student
        s.SetName("xxx")
        v := reflect.ValueOf(&s)
        m1 := v.MethodByName("Print")
        var args []reflect.Value
        m1.Call(args)
    //调用有参数结构体的方法
        m2 := v.MethodByName("SetName")
        var args2 []reflect.Value
        name := "stu01"
        nameVal := reflect.ValueOf(name)
        args2 = append(args2,nameVal)
        m2.Call(args2)
        m1.Call(args)
    }
    
    //获取结构体中tag信息
    type Studenrr struct {
        
    　　Name string `json:"name" db:"name2"`
    　　Sex int
    　　Age int
    　　Score float32
    }
    func (s *Student) SetName(name string) {
        
    　　s.Name = name
    }
    func (s *Student) Print() {
        
    　　fmt.Printf("%#v\n",s)
    }
    func test(){
        
    　　var s Student
    　　s.SetName("xxx")
    　　v := reflect.ValueOf(&s)
    　　t := v.Type()
    　　field0 := t.Elem().Field(0)
    　　fmt.Printf("tag json=%s\n",field0.Tag.Get("json"))
    　　fmt.Printf("tag db=%s\n",field0.Tag.Get("db"))
    }

#### 　　反射总结和应用场景 ####

总结：在运行时动态获取一个变量的类型和值信息

应用场景：

1 序列化和反序列化，比如json、protobuf等各种数据协议

2 各种数据库的ORM、如果gorm、sqlx等数据库中间件

3 配置文件解析相关的库，比如yaml、ini等

## 三、文件操作 ##

#### 　　文件打开和读取 ####

定义：文件分为文本文件和二进制文件两种，存取方式有随机存取和顺序存放

//打开文件
    func main() {
        inputFile,err := os.Open("文件名")    //只读的方式打开
        if err != nil {
            fmt.Printf("open file err :%v\n",err)
            return
        }
        defer inputFile.Close()
    }
    
    //读取文件
    func main() {
        file,err := os.Open("文件名")    //只读的方式打开
        if err != nil {
            fmt.Printf("open file err:%v\n",err)
            return
        }
        defer inputFille.Close()
        var content []byte
        var buf [128]byte
        for {
            n,err := file.Read(buf[:])
            if err == io.EOF{
                break
            }
            if err  != nil {
                fmt.Println("read file:",err)
                return
            }
            content = append(content,buf[:n]...)
        }
        fmt.Println(string(content))
    }
    
    //bufio读取文件
    func test() {
        inputFile,err := os.Open("路径.文件名")    //只读的方式打开
        if err != nil {
            fmt.Printf("open file err:%v\n",err)
            return
        }
        defer inputFile.Close()
        reader := bufio.NewReader(file)
        for {
            line,err := reader.ReadString("\n")    //按行读
            if err == io.EOF{
                brea=k
            }
            if err != nil {
                fmt.Println("read file failed,err:",err)
                return
            }
            fmt.Println(line)
        }
    }    //注bufio原理：读取和写入的时候先进入缓冲区，可以提升效率，但是缓冲区无法保存，断电消失
    
    //io/ioutil读取整个文件
    func test2(){
        content,err := ioutil.ReadFile("./file.go")
        if err != nil {
            fmt.Println("read file failed,err:",err)
            return
        }
        fmt.Println(string(content))
    }
    
    //读取压缩文件
    func test3() {
        inputFile,err := os.Open("文件名.gz”)    //只读的方式打开
        if err != nil {
            fmt.Println("open file err:%v\n",err)
            return
        }
        defer inputFile.Close()
        reader,err := gzip.NewReader(file)
        if err != nil {
            fmt.Println("gzip new reader failed,err",err)
            return
        }
        var  countent []byte
        var buf [128]byte
        for {
            n,err := reader.reader.Read(buf[:])
            if err == io.EOF {
                break
            }
            if err != nil {
                fmt.Println("read file:",err)
                return 
            }
            content = append(content,buf[:n]...)
        }
        fmt.Println(string[content))
    }

#### 　　文件写入 ####

公式：os.OpenFile("文件路径.文件名",参数2,参数3)

参数2：文件打开模式：os.O\_WRONLY(只写)　　os.O\_CREATE(创建)　　os.O\_RDONLY(只读)

os.O\_RDWR(读写)　　os.O\_TRUNC(清空)　　os.O\_APPEND(追加)　　多个模式之间用逗号隔开

参数3：权限控制(windows下无效)　　r——004　　w——002　　x——001

//文件写入
    func test() {
        file,err := os.OpenFile("./test.txt",os.O_CREATE|os.O_TRUNC|os.O_WRONLY,0666)    //文件不存在则创建文件，清空文件，写文件
        if err != nil {
            fmt.Println("open file failed,err:",err)
            return
        }
        defer file.Close()
        str := "hello world"
        file.Write([]byte(str)
        file.WriteString(str)
    }
    
    //bufio方式写入文件
    func test2(){
        file,err := os.OpenFile("./test.txt",os.O_CREATE4|os.O_TRUNC|os.O_WRONLY,0666)
        if err != nil{
            fmt.Println("open file failed,err:",err)
            return
        }
        defer file.Close()
        writer := bufio.NewWriter(file)    //使用bufio写文件
        for i := 0;i < 10;i++ {    //写入10行
            writer.WriteString("hello world"),
        }
        write.Flush()    //写入的内容还在内存中，此命令让内容上传到文件中
    }
    
    //io/ioutil写到整个文件
    func test3() {
        str := "hello world"
        err := ioutil.WriteFile("./test.txt",p[byte(str),0755)
        if err != nil {
            fmt.Println("write file failed,err:',err)
            return
        }
    }

#### 　　copy和cat命令实现 ####

//文件拷贝
    func test() {
        _,err := CopyFile("target.txt","source.txt")
        if err !=nil{
            fmt.Printf("copy file failed,err:%v\n",err)
            return
        }
        fmt.Println("Copy done!")
    }
    func CopyFile(dstName,srcName string) (written int64,err error) {
        src,err := os.Open(srcName)
        if err != nil {
            fmt.Printf("Open source file %s failed,err:%v\n",srcName,err)
            return
        }
        defer src.Close()
        dst,err := os.OpenFile(dstName,os.O_WRONLY|os.CREATE,0644)
        if err != nil {
            fmt.Printf("open dest file %s failed,err:%v\n",dstName,err)
            return
        }
        defer dst.Close()
        return io.Copy(dst.src)
    }
    
    //cat命令实现
    func cat (r *bufio.Reader) {
        for {
            buf,err := r.ReadByter('\n')
            if err == io.EOF {
                break
            }
            fmt.Printf(os.Stdout,"%s",buf)
        }
    }
    func test() {
        flag.Parse()
        if flag.Narg() == 0 {
            cat(bufio.NewReader(os.Stdin))
        }
        for i := 0;i< flag.Narg();i++ {
            f,err := os.Open(flag.Arg(i))
            if err != nil {
                fmt.Fprintf(os.Srder,"%s:error reading from %s:%s\n",os.Args[0],flag.Arg(i),err.Error()
                continue
            }
            cat(bufio.NewReader(f))
        }
    }

#### 　　defer详解 ####

原理：**![1648958-20190828172630977-1828909641.png][]**

//案例
    func test() int{
        x ；= 5
        defer func() {
            x +=1
        }()
        return 5    //6
    }
    
    func test2() (x int) {
        defer func() {
            x += 1
        }()
        return 5    //6
    }
    
    func test3() (y int) {
        x := 5
        defer func() {
            x += 1
        }()
        return x    //5
    }
    
    func test4() (x int) {
        defer func(x int)    //此时传入的是x的副本
            x+=1
        }(x)
        return 5
    }

## 四、Json数据协议 ##

定义：![1648958-20190828173023914-322799389.png][]

序列化：json.Marshal(data interface\{\})

import "encoding/json"    //导入包
    //结构体
    type User struct{
        UserName    string `json:"username"`    //json数据显示为小写的tag
        NickName     string
        Age    int
        Birthday    string
        Sex    string
        Email    string
        Phone    string
    }
    func test(){
        user1 := &User{
            Username :"user01",
            NickName:"上课",
            Age:10,
            Birthday:"2008",
            Sex:"男",
            Email:"123@qq.com",
            Phone:"110",
        }
        data,err := json.Marshal(user1)
        if err != nil {
            fmt.Println("json marshal failed,err:",err)
        }
        fmt.Printf("%s\n",string(data))
    }
    
    //整型
    func testInt() {
        var age = 100
        data,err := json.Marshal(age)
        if err != nil{
            fmt.Println("json.marshal failed,err:",err)
            return
        {
        fmt.Printf("%s\n",string(data)_)
    }
    
    //map
    func testmao() {
        var m map[string]interface{}
        m = make(map[string]interface{})
        m["username"] = "user01"
        m["age"] = 18
        m["sex"] = "man"
        data,err := json.Marshal(m)
        if err != nil {
            fmt.Println("json marshal failed,err:",err)
            return
        }
        fmt.Printf("%s\n",string(data))
    }
    
    //切片
    func testSlice() {
        var m map[string] interface{}
        var s []map[string]interface{}
        m = make(map[string]interface{})
        m["username"] = "user1"
        m["age"] = 19
        m["sex"] = "man"
        s = append(s,m)
        m = make(map[string]interface{})
        m["username"] = "user02"
        m["age"] = 20
        m["sex"] = "feman"
        s = append(s,m)
        data,err := json.Marshal(s)
        if err != nil{
            fmt.Println("json marshal failed,err:"err)
            return
        }
        fmt.Printf("%S\n",string(data))
    }

反序列化：json.UnMarashal(data \[\]byte,v interface\{\})

//结构体    
    type User struct {
        UserName string `json:"username"`    //显示为小写
        NickName string
        Age int
        Birthday string
        Sex string
        Email string
        Phone string
    }
    func teststruct() (ret string，err error) {
        user1 := &User{
            UserName : "user01",
            NickName : "上课",
            Age : 10,
            Birthday : "2008",
            Sex : "男",
            Email : "123@qq.com",
            Phone : "110",
        }
        data,err := json.Marshal(user1)
        if err != nil {
            err = fmt.Error("json marshal failed,err:",err)
            return
        }
        ret = string(data)
        return
    }
    func main() {
        data,err := testStudent()
        if err != nil {
            fmt.Println("test,struct failed,",err)
            retuirn
        }
        fmt.Println(user1)
    }    
    
    //map
    func testmap() (ret string,err error) {
        var m map[string] interface{}
        m = make(map[string]interface{})
        m["username"] = "user1"
        m["age"] = 19
        m["sex"] = "man"
        data,err := json.Marshal(m)
        if err != nil {
            err = fmt.Error("json.marshal failed,err:",err)
            return
        }
        ret = string(data)
        return
    }
    func test2() {
        datas,err := testmap()
        if err != nil{
            fmt.Println("Unmarshal failed,"err")
            return
        }
        var m map[string]interface{}
        err = json.Unmarshal([]byte(data),&m)
        if err != nil{
            fmt.Println("Unmarshal failed,"err)
            return
        }
        fmt.Println(m)
    }

转载于:https://www.cnblogs.com/parallel-Y/p/11420757.html

[1648958-20190828172630977-1828909641.png]: /images/20230601/2f6b1c72fe6c4be794ba99f91ea78fa3.png
[1648958-20190828173023914-322799389.png]: /images/20230601/116b857d7fe64dc4a0524509d8ca3198.png