Go 基础 02

• 结构体排序

package main

import (
    "fmt"
    "math/rand"
    "sort"
)

type Student struct {
    Name string
    Id   string
    age  int
}

type Book struct {
    Name   string
    Author string
}

// 通过接口实现标准库中 sort 的 Sort 方法
// 定义一个 Student 类型的切片，名字叫 StudentArray
type StudentArray []Student

// 返回 Student 类型的切片长度
func (p StudentArray) Len() int {
    return len(p)
}

// 返回 Student 类型的切片 i j 位置姓名字符串比较的结果
func (p StudentArray) Less(i, j int) bool {
    // 从大到小排序
    // return p[i].Name > p[j].Name
    // 从小到大排序
    return p[i].Name < p[j].Name
}

// 交换 i j 位置
func (p StudentArray) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

func main() {
    var stus StudentArray
    // 向 StudentArray 中赋值
    for i := 0; i < 10; i++ {
        stu := Student{
            Name: fmt.Sprintf("stu%d", rand.Intn(100)),
            Id:   fmt.Sprintf("110%d", rand.Intn(100)),
            age:  rand.Intn(100),
        }
        stus = append(stus, stu)
    }
    // 遍历 StudentArray 并打印值
    for _, v := range stus {
        fmt.Println(v)
    }
    fmt.Println()
    // 排序
    sort.Sort(stus)
    // 遍历 StudentArray 并打印值
    for _, v := range stus {
        fmt.Println(v)
    }
}

• 通用链表

// link.go

package main

import (
    "fmt"
)

// 通用链表
// 链表中的一个节点
type LinkNode struct {
    // 空接口（任何类型都已经实现空接口）
    // 也就是任何类型的变量都可以赋值给空接口
    data interface{}
    // 指向后面节点的指针
    next *LinkNode
}

// 链表
type Link struct {
    // 指向头节点的指针
    head *LinkNode
    // 指向尾节点的指针
    tail *LinkNode
}

// 节点从头部插入
func (p *Link) InsertHead(data interface{}) {
    // 生成新的节点
    node := &LinkNode{
        data: data,
        next: nil,
    }

    // 当头指针和尾指针都为空时，表示此时的链表为空链表
    if nil == p.tail && nil == p.head {
        p.tail = node
        p.head = node
        return
    }

    // 新的节点的 next 要等于头节点
    node.next = p.head
    // 更新头部指针，使头部指针重新指向新的节点
    p.head = node

}

// 节点从尾部插入
func (p *Link) InsertTail(data interface{}) {
    // 生成新的节点
    node := &LinkNode{
        data: data,
        next: nil,
    }
    // 当头指针和尾指针都为空时，表示此时的链表为空链表
    if nil == p.tail && nil == p.head {
        p.tail = node
        p.head = node
        return
    }

    // 之前尾部节点的 next 指向新的节点
    p.tail.next = node
    // 更新尾部指针，指向新节点
    p.tail = node
}

// 遍历链表
func (p *Link) Trans() {
    q := p.head
    for nil != q {
        fmt.Println(q.data)
        q = q.next
    }
}

// main.go

package main

import (
    "fmt"
)

func main() {
    var headLink Link
    // 从头部插入10个节点（逆序）
    for i := 0; i < 10; i++ {
        headLink.InsertHead(fmt.Sprintf("crixus_%d", i))
    }
    headLink.Trans()
    fmt.Println()
    var tailLink Link
    // 从尾部插入10个节点（顺序）
    for i := 0; i < 10; i++ {
        tailLink.InsertTail(fmt.Sprintf("crixus_%d", i))
    }
    tailLink.Trans()
}

• 通过反射操作结构体

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

type Student struct {
    Name  string `json:"student_name"`
    Age   int
    Score float32
    Sex   string
}

func (s Student) Print() {
    fmt.Println(s)
}

func (s Student) Set(name string, age int, score float32, sex string) {
    s.Name = name
    s.Age = age
    s.Score = score
    s.Sex = sex
}

// 通过反射操作结构体
func TestStruct(a interface{}) {
    // 获取指定字段的 tag 标签
    typ := reflect.TypeOf(a)
    tag := typ.Elem().Field(0).Tag.Get("json")
    fmt.Printf("tag => %s
", tag)

    // 获取指定字段的 name 标签
    name := typ.Elem().Field(1).Name
    fmt.Printf("name => %s
", name)

    val := reflect.ValueOf(a)
    // 获取类别
    kd := val.Kind()
    // 当类别不为结构体，就不再进行分析，直接退出
    if reflect.Ptr != kd && reflect.Struct == val.Elem().Kind() {
        fmt.Println("not struct ...")
        return
    }
    // 获取结构体中字段的数量
    num := val.Elem().NumField()
    fmt.Printf("struct has %d fields
", num)

    // 修改结构体中指定字段的值
    val.Elem().Field(0).SetString("crixus")

    // 遍历结构体中字段的值
    for i := 0; i < num; i++ {
        fmt.Printf("Field %d : Kind %v : %v => %v
", i, val.Elem().Field(i).Kind(), typ.Elem().Field(i).Name, val.Elem().Field(i))
    }

    // 获取结构体中方法的数量
    numOfMethod := val.Elem().NumMethod()
    fmt.Printf("struct has %d method
", numOfMethod)

    // 调用结果体中的方法
    var params []reflect.Value
    val.Elem().Method(0).Call(params)
}

func main() {
    var a Student = Student{
        Name:  "stu01",
        Age:   18,
        Score: 92.5,
        Sex:   "female",
    }
    // 通过 json 打包结构体
    // result 是字节数组
    result, _ := json.Marshal(a)
    // 输出时，result 字节数组转字符串
    fmt.Println("Json result =>", string(result))
    TestStruct(&a)
}

• 文件拷贝

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {

    // 相对路径
    _, err := CopyFile("target.txt", "source.txt")
    if nil != err {
        fmt.Println("Copy failed ...", err)
        return
    }
    fmt.Println("Copy done ...")
}

// 文件拷贝
func CopyFile(dstName, srcName string) (written int64, err error) {
    // 读文件
    src, err := os.Open(srcName)
    if nil != err {
        return
    }
    defer src.Close()

    // 写文件
    dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
    if nil != err {
        return
    }
    defer dst.Close()

    return io.Copy(dst, src)
}

• 结构体序列化和反序列化

package main

import (
    "encoding/json"
    "fmt"
)

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: "Crixus01",
        Age:      18,
        Birthday: "2019-02-12",
        Sex:      "male",
        Email:    "280247844@qq.com",
        Phone:    "12345678901",
    }

    // json.Marshal 执行后返回字节数组
    data, err := json.Marshal(user1)
    if nil != err {
        err = fmt.Errorf("json.marshal failed, err :", err)
        return
    }
    // 字节数组转为字符串
    ret = string(data)
    return
}

// json 串反序列化为结构体
func test() {
    data, err := testStruct()
    if nil != err {
        fmt.Println("test struct failed ...")
    }
    var user1 User
    // 字符串转为字符串字节数组
    // 结构体是值类型，要更新其中字段需要传地址进去
    err = json.Unmarshal([]byte(data), &user1)
    if nil != err {
        fmt.Println("Unmarshal failed ...")
    }
    fmt.Println(user1)
}

func main() {
    // json 串反序列化为结构体
    test()
}

（  Over  ）