go语言学习(9)--package

包管理

我用过的语言,比如java,python都是按包来区分命名空间的
go里也是一样

1import (
2    "golearn/lesson8/tree"
3    "fmt"
4    "golearn/lesson8/queue"
5)

这里fmt就是go里的标准库的包
前面说到过,go里常量不推荐大写,为什么,因为,go里首字母大写代表public
我们来看一下上一章的二叉树,如果要把中序遍历扩展一下成后序遍历,怎么做呢
首先得改造一下,首字母都大写

 1package tree
 2
 3import "fmt"
 4
 5type Node struct {
 6    Value       int
 7    Left, Right *Node
 8}
 9
10func (node Node) Print() {
11    fmt.Println(node.Value)
12}
13
14func CreateNode(value int) *Node {
15    // go 里不需要关心变量是在堆上创建还是栈上创建的
16    return &Node{Value: value}
17}
18
19func (node *Node) SetValue(value int) {
20    node.Value = value
21}
22
23func (node *Node) Traverse() {
24    if node == nil {
25        return
26    }
27    // 其他语言需要判断 null,go 不用
28    node.Left.Traverse()
29    node.Print()
30    node.Right.Traverse()
31}

这是之前的代码,现在把方法名和变量名全都首字母大写

idea 里装上UpperLowerCapitalize插件后
Alt+P // to uppercase
Alt+L // to lowercase
Alt+C // 首字母大写

把 tree.go这个文件移到tree这个文件夹下,因为一个文件夹下只能有一个包名, MyTreeNode是 main包

这里有个小插曲,我本来这个包叫 lesson8(package),发现引入后怎么都是报错,才发现,包名不能带括号

之前的中序遍历是这样的

 1func main() {
 2    var root tree.Node
 3    root = tree.Node{Value: 3}           // root->3
 4    root.Left = &tree.Node{}             // left->0
 5    root.Right = &tree.Node{5, nil, nil} // right->5
 6    root.Right.Left = new(tree.Node)     // right->left->0
 7    root.Left.Right = tree.CreateNode(2) // left->right->2
 8    root.Right.Left.SetValue(4)
 9    // 0->2->3->4->5
10    root.Traverse()
11}

来体验一下go的面向接口编程

 1type MyTreeNode struct {
 2    node *tree.Node
 3}
 4
 5// 后序遍历
 6func (myNode *MyTreeNode) postOrder() {
 7    if myNode == nil || myNode.node == nil {
 8        return
 9    }
10    left := MyTreeNode{myNode.node.Left}
11    right := MyTreeNode{myNode.node.Right}
12    left.postOrder()
13    right.postOrder()
14    myNode.node.Print()
15}

沿用之前的结构体,定义一个新的结构体MyTreeNode
然后给MyTreeNode增加一个方法
func (结构体指针) 方法名([参数])[返回值]
后序遍历就是左右中,如上面的代码
来验证一下

1fmt.Println("后序遍历")
2myRoot := MyTreeNode{&root}
3myRoot.postOrder()
4// 2 0 4 5 3

扩展

我想把之前的数组的 push 和 pop 封装一下
和二叉树一样,单独放在一个包里

 1package queue
 2
 3type Queue []int
 4
 5func (q *Queue) Push(v int) {
 6    *q = append(*q, v)
 7
 8}
 9
10func (q *Queue) Pop() int {
11    head := (*q)[0]
12    *q = (*q)[1:]
13    return head
14}
15
16func (q *Queue) IsEmpty() bool {
17    if len(*q) == 0 {
18        return true
19    } else {
20        return false
21    }
22}

 1package main
 2
 3import (
 4    "golearn/lesson8/tree"
 5    "fmt"
 6    "golearn/lesson8/queue"
 7)
 8
 9func  main(){
10    s := queue.Queue{1, 3, 5, 7, 9}
11    s.Push(11)
12    fmt.Println(s)
13    for !s.IsEmpty() {
14        s.Pop()
15        fmt.Println(s)
16    }
17
18}

总结

• 要想让其他包能访问你的包,变量和方法首字母大写,代表public

上述代码均已上传至 github, 欢迎 star
https://github.com/yejunyu/golearn