Go: Go语言基础知识

Location src/learngo
GOROOT 安装位置
Proxy https://goproxy.cn,direct

package main

import (
        "fmt"
)

//函数外定义变量
//外面定义时不用 :=
//作用域：包内部的变量
// var aa = 33
// var ss = "kkk"
// var bb = true
var (
        aa = 33
        ss = "kkk"
        bb = true
)


func variableZeroValue() {
        var a int
        var s string
        fmt.Printf("%d, %q\n", a, s)
}

func variableInitialValue() {
        var a, b int = 3, 5
        var s string = "abc"
        fmt.Println(a, b, s)
}

func variableTypeDeduction() {
        // 不规定类型可以写在一行自动判断
        var a, b, c, s = 3, 5, true, "def"
        fmt.Println(a, b, c, s)
}

func variableShorter() {
        //使用 := 效果和上面是一样的，更加简单。只在第一次使用时用:=
        a, b, c, s := 3, 5, true, "def"
        fmt.Println(a, b, c, s)
}

func main() {
        fmt.Println("hh")
        variableZeroValue()
        variableInitialValue()
        variableTypeDeduction()
        variableShorter()
        fmt.Println(aa,ss,bb)
}

#执行
PS D:\project\goproject\src\test> go run main.go
hh
0, ""
3 5 abc
3 5 true def
3 5 true def
33 kkk true

func funcName(a, b int, op string) int {
//function body
}
函数名在前，类型在后

package main

import "fmt"

func eval(a, b int, op string) int {
    switch op {
    case "+":
        return a + b
    case "-":
        return a - b
    case "*":
        return a * b
    case "/":
        return a / b
    default:
        panic("unsupported operation:" + op)
    }
}

func main() {
    fmt.Println(eval(3, 4, "*"))
}

// 带余除法 13 / 3 = 4 ... 1
func div(a, b int) (int, int) {
    return a / b, a % b
}

func apply(op func(int, int) int, a, b int) int {
    fmt.Printf("Calling funciton %s with args"+
        "(%d, %d)", runtime.FuncForPC(reflect.ValueOf(op).Pointer()).Name(),
        a, b)
    return op(a, b)
}

func apply(op func(int, int) int, a, b int) int {
    //利用反射确认op函数是调用哪个函数
    p := reflect.ValueOf(op).Pointer() // 获得函数的指针
    opName := runtime.FuncForPC(p).Name()
    fmt.Printf("Calling funciton %s with args"+
        "(%d, %d)\n", opName, a, b)

    return op(a, b)
}

func pow(a, b int) int {
    return int(math.Pow(float64(a), float64(b)))
}

func main() {
    fmt.Println(apply(pow, 3, 4)) // 结果：Calling funciton main.pow with args(3, 4)81
}

//pow另外定义一个函数很吃力，这里直接写main里，写成匿名函数。即闭包
func main() {
    fmt.Println(apply(
        func(a int, b int) int {
            return int(math.Pow(float64(a), float64(b)))
        }, 3, 4)) // 结果：Calling funciton main.main.func1 with args(3, 4)81
}

func sum(numbers ...int) int {
    s := 0
    for i := range numbers {
        s += numbers[i]
    }
    return s
}

func main() {
    fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}

void pass_by_val(int a) { //值传递
    a++;
}

void pass_by_ref(int& a) { //引用传递
    a++;
}

int main() {
    int a = 3;

    pass_by_val(a);
    printf("After pass_by_val: %d\n", a);

    pass_by_ref(a);
    printf("After pass_by_ref: %d\n", a);
}

//结果
After pass_by_val: 3
After pass_by_ref: 4

func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    a, b := 3, 4
    swap(&a, &b)
    fmt.Println(a, b)  //4 3
}

func swap(a, b int) (int, int) {
    return b, a // 把交换的结果返回出去
}

func main() {
    a, b := 3, 4
    a, b = swap(a, b)  // a, b 去接函数的返回值
    fmt.Println(a, b)  // 4 3
}

func printArray(arr [5]int) {
    arr[0] = 100
}

func printArrayPtr(arr *[5]int) {
    arr[0] = 100 // 可以不用写(*arr)
}

func main() {
    // 定义数组
    var arr1 [5]int
    arr2 := [3]int{1, 3, 5}
    arr3 := [...]int{2, 4, 6, 8, 10} // 编译器数有几个int
    var grid [4][5]int  // 4行5列数组


    printArray(arr1)
    printArray(arr3)
    // printArray(arr2) //报错 arr2和[5]int是不同的类型

    // 数组指针的方法
    printArrayPtr(&arr1)
    printArrayPtr(&arr3)

    fmt.Println("arr1, arr3")
    fmt.Println(arr1, arr3)  // [100 0 0 0 0] [100 4 6 8 10]
}

func updateSlice(s []int) {
    s[0] = 100
}

func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:]
    fmt.Println("s1 =", s1) // s1 = [2 3 4 5 6 7]
    s2 := arr[:]
    fmt.Println("s2 =", s2) // s2 = [0 1 2 3 4 5 6 7]

    fmt.Println("After updateSlice(s1)")
    updateSlice(s1)
    fmt.Println(s1) // [100 3 4 5 6 7]
    fmt.Println(arr) //[0 1 100 3 4 5 6 7]

    fmt.Println("After updateSlice(s2)")
    updateSlice(s2)
    fmt.Println(s2) // [100 1 100 3 4 5 6 7]
    fmt.Println(arr) // [100 1 100 3 4 5 6 7]
}

#在go语言中一般不直接使用数组，而是用切片
printArrayPtr(&arr1) 可改成  printArrayPtr(arr1[:])
printArrayPtr(arr *[5]int) 可改成 printArrayPtr(arr *[5]int)

s := arr[2:6]
s = s[:3]
s = s[1:]
s = arr[:]

arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]

arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
s3 := append(s2, 10)
s4 := append(s3, 11)
s5 := append(s4, 12)

package main

import "fmt"

func updateSlice(s []int) {
    s[0] = 100
}

func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    fmt.Println("arr[2:6] =", arr[2:6]) // arr[2:6] = [2 3 4 5]
    fmt.Println("arr[:6] =", arr[:6])   // arr[:6] = [0 1 2 3 4 5]
    s1 := arr[2:]
    fmt.Println("s1 =", s1) // arr[2:] = [2 3 4 5 6 7]
    s2 := arr[:]
    fmt.Println("s2 =", s2) // arr[:] = [0 1 2 3 4 5 6 7]

    //验证slice是底层array的一个视图
    fmt.Println("After updateSlice(s1)")
    updateSlice(s1)
    fmt.Println(s1)  // [100 3 4 5 6 7]
    fmt.Println(arr) //[0 1 100 3 4 5 6 7]

    fmt.Println("After updateSlice(s2)")
    updateSlice(s2)
    fmt.Println(s2)  // [100 1 100 3 4 5 6 7]
    fmt.Println(arr) // [100 1 100 3 4 5 6 7]

    fmt.Println("Reslice")
    fmt.Println(s2) // [100 1 100 3 4 5 6 7]
    s2 = s2[:5]
    fmt.Println(s2) // [100 1 100 3 4]
    s2 = s2[2:]
    fmt.Println(s2) // [100 3 4]
    s2 = arr[:]
    fmt.Println(s2) // [100 1 100 3 4 5 6 7]

    fmt.Println("Extending slice")
    arr[0], arr[2] = 0, 2
    s1 = arr[2:6]             // [2 3 4 5]
    s2 = s1[3:5]              // 取的是[s1[3], s1[4]] ，可s1[4]不在s1里面，直接取s1[4]是取不出的
    fmt.Println("arr =", arr) // arr = [0 1 2 3 4 5 6 7]
    fmt.Printf("s1=%v, len(s1)=%d, cap(s1)=%d\n",
        s1, len(s1), cap(s1)) // s1=[2 3 4 5], len(s1)=4, cap(s1)=6
    fmt.Printf("s2=%v, len(s2)=%d, cap(s2)=%d\n",
        s2, len(s2), cap(s2)) // s2=[5 6], len(s2)=2, cap(s2)=3

    // 向Slice添加元素
    s3 := append(s2, 10)
    s4 := append(s3, 11)
    s5 := append(s4, 12)
    fmt.Println("s3, s4, s5=", s3, s4, s5) // s3, s4, s5= [5 6 10] [5 6 10 11] [5 6 10 11 12]
    // s4 and s5 no longer view arr
    fmt.Println("arr =", arr) // arr = [0 1 2 3 4 5 6 10]
    // s4, s5是新的array，把arr拷贝过去，新arr长度会设置的更长些
}

m := map[string]string {
    "name": "abc",
    "course": "golang",
}

func main() {
    m := map[string]string{
        "name":   "abc",
        "course": "golang",
    }

    m2 := make(map[string]int)  // m2 == empty map

    var m3 map[string]int // m3 == nil

    fmt.Println(m, m2, m3) // map[course:golang name:abc] map[] map[]
    // m3 == nil, m2 == empty map  go语言的nil是可以参与运算的

    fmt.Println("Getting values")
    courseName:= m["course"]
    fmt.Println(courseName)
    sssName, ok := m["sss"]
    fmt.Println(sssName, ok) // key不存在时返回空串，zero value, 判断key是否存在，返回false,true
    if sssName, ok := m["sss"]; ok {
        fmt.Println(sssName, ok)
    } else {
        fmt.Println("Key does not exist") // Key does not exist
    }

    fmt.Println("Deleting values")
    name, ok := m["name"]
    fmt.Println(name, ok) // abc true
    delete(m, "name")
    name, ok = m["name"]
    fmt.Println(name, ok) //  false
}

fmt.Println("Traversing map")
for k, v := range m { // for k:= range m { 还可以 for _, v := range m {
    fmt.Println(k, v)
}
//key在map中是无序的

package main

import "fmt"

func lengthOfNonRepeatingSubStr(s string) int {
        lastOccurred := make(map[byte]int) // 每个字母最后出现的位置
        start := 0                         // 当前找到的最长不含有字符的子串开始
        maxLength := 0                     // 重复子串的最大长度
        // 遍历字符串
        for i, ch := range []byte(s) {

                if lastI, ok := lastOccurred[ch]; ok && lastI >= start { // lastOccurred[ch]可能是不存在的它的值是0，0参与下面的运算是不对的
                        start = lastOccurred[ch] + 1
                }

                if i-start+1 > maxLength { // 更新maxLength
                        maxLength = i - start + 1
                }

                lastOccurred[ch] = i
        }

        return maxLength
}

func main() {
        fmt.Println(
                lengthOfNonRepeatingSubStr("abcabcbb")) // 3
        fmt.Println(
                lengthOfNonRepeatingSubStr("bbbb")) // 1

}

type TreeNode struct {
    Left, Right *TreeNode
    value int
}

root := treeNode{value: 3}
root.Left = &treeNode{}
root.Right = &treeNode{nil, nil, 5}
root.Right.Left = new(treeNode)

package main

import "fmt"

type treeNode struct {

    value       int
    left, right *treeNode
}

func creatNode(value int) *treeNode {
    return &treeNode{value: value}
}

func main() {
    // 结构体的创建
    var root treeNode //{0 <nil> <nil>}

    root = treeNode{value: 3}
    root.left = &treeNode{}
    root.right = &treeNode{5, nil, nil}
    root.right.left = new(treeNode) // root.right后也可以用"."点号，
    root.left.right = creatNode(2) // 利用自定义工厂函数构造结构

    nodes := []treeNode { // 在slice中可以省略treeNode字写法
        {value: 3},
        {},
        {6, nil, &root},
    }
    fmt.Println(nodes) // [{3 <nil> <nil>} {0 <nil> <nil>} {6 <nil> 0xc000004078}]
}

func (node TreeNode) print() {
    fmt.Print(node.value)
}

└─tree
    │  traversal.go // tree包，需要外部引用的方法、变量就大写
    │  tree.go      // tree包
    │
    └─entry          // main包目录
            entry.go // 引用tree包函数，引用tree.TreeNode不用重复包名，结构体可改为Node，tree.Node引用就好

# entry.go内容
package main

import "test/tree"

func main() {
    // 结构体的创建
    var root tree.Node //{0 <nil> <nil>}

    root = tree.Node{Value: 3}
    root.Left = &tree.Node{}
    root.Right = &tree.Node{5, nil, nil}
    root.Right.Left = new(tree.Node) // root.right后也可以用"."点号，
    root.Left.Right = tree.CreatNode(2)  // 利用自定义工厂函数构造结构
    // 结构方法的使用
    root.Print()                // 3 其中print是个函数，它不是无参的，它有个接收者root
    root.Right.Left.SetValue(4) // setValue函数会把接收者root.right.left的地址做参数传递过去

    root.Traverse()
}

package queue

type Queue []int // 定义别名，扩展已有类型

func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

func (q *Queue) Pop() int {
    head := (*q)[0]
    *q = (*q)[1:]
    return head
}

func (q *Queue) IsEmpty() bool {
    return len(*q) == 0
}

#main包
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())
}

import (
    "fmt"
    "test/tree"
)

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()
}

myRoot := myTreeNode{&root}

package main

import (
    "fmt"
    "test/tree"
)

type myTreeNode struct {
    // node *tree.Node
    *tree.Node // Embedding 内嵌类型，可以把node字段省掉。好处是这个是个语法堂能省下代码量，看起来简洁些
    // 默认的名字是tree.后面点出的东西。这里是Node
    // 相当于把tree.Node的成员变量全都拉出来，铺在myTreeNode的结构里。
    // 里面的变量和方法都能直接"."点出来使用
}


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

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

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

// 重载函数
func (myNode *myTreeNode) Traverse() {
    fmt.Println("This method is shadowed")
}

func main() {
    root := myTreeNode{&tree.Node{Value: 3}} // 直接把tree.Node中的变量和方法都能拉上来
    root.Left = &tree.Node{}
    root.Right = &tree.Node{5, nil, nil}
    root.Right.Left = new(tree.Node)
    root.Left.Right = tree.CreatNode(2)
    root.Right.Left.SetValue(4)

    fmt.Print("In-order traversal: ")
    root.Traverse() // 重载了函数
    root.Node.Traverse() // 使用原始遍历

    fmt.Print("\nMy own post-order traversal: ")
    root.postOrder()
    fmt.Println()

    //子类赋值给基类是通过接口实现的，不是通过类的继承来实现的
    var baseRoot *tree.Node
    baseRoot := &root // 报错
}

export GO111MODULE=off
export GOPATH=~/tmp/goproject

export GO111MODULE=off
export GOPATH=~/tmp/goproject