Go物件導向篇

本節重點

1）GO安裝路徑為為GOROOT  如何設定GOPATH  在PATH中新增GOPATH/bin目錄

2）GOPATH目錄（這裏為/home/admin/go）下有三個資料夾bin  pkg  src但是一般是src是我自己建立，其餘不是

如果非要建立這幾個資料夾，比如建立了pkg就涉及到IDEA中go run 時候可能go install會被拒絕寫入由我自己建立的pkg

3）IDEA工程儲存路徑（這裏為 /home/admin/go/src/learngo）我自己注意：最好下次儲存為 /home/admin/go/src/ycx/learngo

4）無法直接獲取golang的包因此使用工作gopm（獲取時候採用go get命令 但是一定要記得安裝了git）

5）IDEA中執行某個程式時候如果報錯（請自行檢視是否到該包目錄下go install了，如果沒有會報錯關於linux_amd64的）

6）GPATH下：go build來編譯  go install產生pkg檔案和可執行檔案  go run直接編譯執行

GOPATH

[[email protected] ~]$ cd /opt/go
[[email protected] go]$ pwd
/opt/go
[[email protected] go]$ echo $GOPATH
/home/admin/go
[[email protected] go]$ gedit /etc/profile

GOPATH

重點關注：GOPATH以及設定PATH關於GOPATH的

go get

在配置的GOPATH目錄下執行命令：go get -v github.com/gpmgo/gopm

注意1：如果不能執行請檢視自己是否安裝了 git 。

注意：如果出現錯誤提示如下（請將src目錄下的github.com資料夾刪除使用命令為：rm -rf  資料夾名字

安裝gopm完畢檢視目錄下一些檔案：（此時說明gopm安裝完畢，可以通過檢視gopm的help來執行了）

[[email protected] go]# gopm help

[[email protected] go]# gopm help get

使用gopm：

使用一下命令第一次不會出現一下問題

開啟IDEA可以檢視GOPATH已經出現：

執行go build命令來build需要的goimports將其裝在bin目錄下面去

注:這裏它會做兩件事情（第一件：將IDEA裡的import兩個空行 第二件：是在golang.org 的x目錄下多很多東西）

使用示例

我們可以來使用一下：使用intsets.Sparse{}   下面是tree的總程式碼

注意：執行程式treeentry.go執行程式出錯:（這是由於自己認為建立了pkg，如果不是則不會報這個錯誤）

解決辦法：

tree

目錄結構：

package main

import (
    "fmt"

    "learngo/tree"

    "golang.org/x/tools/container/intsets"
)

type myTreeNode struct {
    node *tree.Node
}

func (myNode *myTreeNode) postOrder() {
    if myNode == nil || myNode.node == nil {
        return
    }

    left := myTreeNode{myNode.node.Left}
    right := myTreeNode{myNode.node.Right}

    left.postOrder()
    right.postOrder()
    myNode.node.Print()
}

func testSparse() {
    s := intsets.Sparse{}

    s.Insert(1)
    s.Insert(1000)
    s.Insert(1000000)
    fmt.Println(s.Has(1000))
    fmt.Println(s.Has(10000000))
}

func main() {
    var root tree.Node

    root = tree.Node{Value: 3}
    root.Left = &tree.Node{}
    root.Right = &tree.Node{5, nil, nil}
    root.Right.Left = new(tree.Node)
    root.Left.Right = tree.CreateNode(2)
    root.Right.Left.SetValue(4)

    fmt.Print("In-order traversal: ")
    root.Traverse()

    fmt.Print("My own post-order traversal: ")
    myRoot := myTreeNode{&root}
    myRoot.postOrder()
    fmt.Println()

    nodeCount := 0
    root.TraverseFunc(func(node *tree.Node) {
        nodeCount++
    })
    fmt.Println("Node count:", nodeCount)

    c := root.TraverseWithChannel()
    maxNodeValue := 0
    for node := range c {
        if node.Value > maxNodeValue {
            maxNodeValue = node.Value
        }
    }
    fmt.Println("Max node value:", maxNodeValue)

    testSparse()
}

entry.go

package tree

import "fmt"

type Node struct {
    Value       int
    Left, Right *Node
}

func (node Node) Print() {
    fmt.Print(node.Value, " ")
}

func (node *Node) SetValue(value int) {
    if node == nil {
        fmt.Println("Setting Value to nil " +
            "node. Ignored.")
        return
    }
    node.Value = value
}

func CreateNode(value int) *Node {
    return &Node{Value: value}
}

node.go

package tree

import "fmt"

func (node *Node) Traverse() {
    node.TraverseFunc(func(n *Node) {
        n.Print()
    })
    fmt.Println()
}

func (node *Node) TraverseFunc(f func(*Node)) {
    if node == nil {
        return
    }

    node.Left.TraverseFunc(f)
    f(node)
    node.Right.TraverseFunc(f)
}

func (node *Node) TraverseWithChannel() chan *Node {
    out := make(chan *Node)
    go func() {
        node.TraverseFunc(func(node *Node) {
            out <- node
        })
        close(out)
    }()
    return out
}

traversal.go

輸出是：

In-order traversal: 0 2 3 4 5 
My own post-order traversal: 2 0 4 5 3 
Node count: 5
Max node value: 5
true
false

Process finished with exit code 0

queue

先做準備工作

程式碼結構如下：

package main

import (
    "fmt"
    "learngo/queue"
)

func main() {
    q := queue.Queue{1}

    q.Push(2)
    q.Push(3)
    fmt.Println(q.Pop())
    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())
    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())
}

main.go

package queue

// A FIFO queue.
type Queue []int

// Pushes the element into the queue.
//         e.g. q.Push(123)
func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

// Pops element from head.
func (q *Queue) Pop() int {
    head := (*q)[0]
    *q = (*q)[1:]
    return head
}

// Returns if the queue is empty or not.
func (q *Queue) IsEmpty() bool {
    return len(*q) == 0
}

queue.go

輸出是：

1
2
false
3
true

Process finished with exit code 0

package queue

import "fmt"

func ExampleQueue_Pop() {
    q := Queue{1}
    q.Push(2)
    q.Push(3)
    fmt.Println(q.Pop())
    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())

    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())

    // Output:
    // 1
    // 2
    // false
    // 3
    // true
}

queue_test.go

執行是：