一、引用其他包中的方法

代码结构，main.go在工程根目录下，tool.go在tool目录下，目录结构如下：
main.go
tool
|__ tool.go
other
|__ othertools.go

代码文件如下：
tool.go代码：

package tool

func Add(l int, r int) int {
    return l + r
}

othertools.go代码
注意：此代码在other目录下，代码文件名是othertools.go，包名是othertool

package othertool

import (
    "fmt"
    "../tool" //引入tool包
)

func Sub(l int, r int) int {
    fmt.Println("in Sub", tool.Add(3,4)) // 调用tool包中的方法
    return l - r
}

main.go代码：

package main

import (
    "fmt"
    "./tool"
    "./other"
)
// 引用时输入的是目录名
func main(){
    fmt.Println("main",tool.Add(1,2))
    fmt.Println("main",othertool.Sub(3,2)) // othertool为包名
}

总结：

引入其他包时，引用的是目录名，同时要注意文件相对路径的关系
调用其他包的方法时，需要用packagename.function格式，如main.go中调用othertool.Sub
代码输出如下：

go_test]$ go run main.go 
main 3
in Sub 7
main 1

二、json序列号与反序列化

json序列化是将对象转换称字符串，反序列化是将字符串转换称对象，下面利用系统自带的json包

import (
    "fmt"
    "encoding/json"
)

定义两个结构体，学科与学生，学生对象上包含学科列表，可以存放各科目的成绩，结构体定义如下：

type Subject struct{
	Name string `json:"subname"`
	Score int `json:"score"`
}

type Student struct {
	Name string `json:"name"`
	Age int `json:"age"`
	SubList []Subject `json:"sublist"`
}

序列化与反序列化的代码如下：

    // 定义两个学科
	var sub1 Subject
	sub1.Name = "math"
	sub1.Score = 90
	
	var sub2 Subject
	sub2.Name = "history"
	sub2.Score = 95

	// 定义学生
    var stu Student
	stu.Name = "wang"
	stu.Age = 20
	stu.SubList = make([]Subject, 0)
	stu.SubList = append(stu.SubList, sub1)
	stu.SubList = append(stu.SubList, sub2)
	
	// 序列化
	json_str, err := json.Marshal(stu)
	if err != nil {
		fmt.Println(err)
		return
	}
	
	fmt.Printf("Marshal: %s\n",json_str)
	
	// 反序列化
	var stu2 Student
	err2 := json.Unmarshal(json_str, &stu2)
	if err2 != nil {
		fmt.Println(err2)
		return
	}
	
	fmt.Println("Unmarshal:", stu2)
    
    // 打印学生的成绩
	fmt.Println("print stu2.SubList")
	for i, item := range stu2.SubList {
		fmt.Printf("  %d: %s, %d\n",i, item.Name, item.Score)
	}

执行结果：

wang@wang:~/codes/go$ go run test.go 
Marshal: {"name":"wang","age":20,"sublist":[{"subname":"math","score":90},{"subname":"history","score":95}]}
Unmarshal: {wang 20 [{math 90} {history 95}]}
print stu2.SubList
  0: math, 90
  1: history, 95

利用以上方法，进行反序列化时，需要定义相应的结构体，接收反序列化的结果。如果json字符串格式特别复杂，又不想定义结构体，可以使用下面的方法来解析

var json_str string = `{"name":"wang","age":20,"sublist":[{"subname":"math","score":90},{"subname":"history","score":95}]}`

var dat map[string]interface{}
err := json.Unmarshal([]byte(json_str), &dat)

if (nil != err){
    fmt.Println(err)
    return
}

// 打印姓名和年龄
fmt.Printf("Name:%s\n", dat["name"])
fmt.Printf("Age:%g\n", dat["age"])

// 获取学科数量
list_count := len(dat["sublist"].([]interface {}))

// 打印各科的成绩
for i := 0; i < list_count; i++ {
    sub := (dat["sublist"].([]interface {}))[i].(map[string]interface {})
    fmt.Printf("    sublist: %d, %s, %g\n",i, sub["subname"], sub["score"])
}

执行结果如下：

wang@wang:~/codes/go$ go run test.go 
Name:wang
Age:20
    sublist: 0, math, 90
    sublist: 1, history, 95

GO语言随笔

目录

一、引用其他包中的方法

二、json序列号与反序列化

猜你喜欢