Golang語法的踩坑總結（持續更新中）

*本來這篇是想寫docker的基本操作總結的。。。想想還是寫這個吧。。。→_→*

變量聲明使用 := 方式時，左值必須是未聲明的，否則會出現編譯錯誤

//.\main.go:8:4: no new variables on left side of :=
package main

import "fmt"

func main() {
    var a int = 10
    var b int = 20
    b := 30

    fmt.Print(a, b)
}

變量聲明瞭，就必須要使用，否則會出現編譯錯誤

//.\main.go:7:6: b declared and not used
package main

import "fmt"

func main() {
    var a int = 10
    var b int = 20

    fmt.Print(a)
}

const修飾符的作用範圍爲同時修飾的所有常量

//.\main.go:7:4: cannot assign to a
//.\main.go:8:4: cannot assign to b
package main

import "fmt"

func main() {
    const a, b int = 10, 20
    a = 10
    b = 20

    fmt.Print(a, b)
}

++自增和- -自減運算符類比C語言，相當於前置的自增和自減，而且go語言中不區分前置或後置

//.\main.go:9:2: syntax error: unexpected ++, expecting }
package main

import "fmt"

func main(){
    var a int = 10
    var b int = 20

    ++a
    b++

    fmt.Print(a, b)
}

不能使用++自增或- -自減運算符初始化變量和對變量賦值

//.\main.go:7:15: syntax error: unexpected ++ at end of statement
//.\main.go:10:7: syntax error: unexpected ++ at end of statement
package main

import "fmt"

func main(){
    var a int = 10
    var b int = a++

    var c int = 20
    c = a++

    fmt.Print(a, b, c)
}

if…else 語句中的 else 必須和 if 的 ’ } ’ 在同一行，否則編譯錯誤

//.\main.go:11:2: syntax error: unexpected else, expecting }
package main

import "fmt"

func main() {
    var a int = 30

    if a < 20 {
        fmt.Print("a<20")
    } 
    else {
        fmt.Print("a>=20")
    }
}

switch 中的 case和default分支不用添加break

//代碼運行成功
package main

import "fmt"

func main() {
    var a int = 10

    switch a {
    case 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    case 10:
        fmt.Println("10")
    default:
        fmt.Println("unknow")
    }
}

switch 中也可以不用添加表達式

//代碼運行成功
package main

import "fmt"

func main() {
    var a int = 10

    switch {
    case a == 1:
        fmt.Println("1")
    case a == 2:
        fmt.Println("2")
    case a == 10:
        fmt.Println("10")
    default:
        fmt.Println("unknow")
    }
}

switch的case分支的常量表達式可以同時測試多個值


//代碼運行成功
package main

import "fmt"

func main() {
    var a int = 10

    switch {
    case a == 1, a == 2:
        fmt.Println("1 or 2")
    case a == 10, a == 20:
        fmt.Println("10 or 20")
    case a == 100, a == 200:
        fmt.Println("100 or 200")
    default:
        fmt.Println("unknow")
    }
}

switch 語句還可以被用於 type-switch 來判斷某個 interface 變量中實際存儲的變量類型

package main

import "fmt"

func main() {
    var x interface{}

    switch i := x.(type) {
    case nil:
        fmt.Printf("%T", i)
    case int:
        fmt.Printf("int")
    case float64:
        fmt.Printf("float64")
    case func(int) float64:
        fmt.Printf("func(int)")
    case bool, string:
        fmt.Printf("bool or string")
    default:
        fmt.Printf("unknow")
    }
}

select 語句。。這個現在還沒看懂。。先MARK
```
Learning...
```

for循環語句range格式，遍歷數組

//i爲下標
//x爲元素的值
//0 1
//1 2
//2 3
//3 4
//4 5
package main

import "fmt"

func main() {
    var number = [5]int{1, 2, 3, 4, 5}
    for i, x := range number {
        fmt.Println(i, x)
    }
}

for循環語句和C語言中的while循環語句比較

//0 1 2 3 4 5 6 7 8 9
package main

import "fmt"

func main() {
    var a int = 0
    for a < 10 {
        fmt.Printf("%d ", a)
        a++
    }
}

for循環語句和C語言中的for循環語句比較

//0 1 2 3 4 5 6 7 8 9
package main

import "fmt"

func main() {
    var a int = 0
    for a = 0; a < 10; a++ {
        fmt.Printf("%d ", a)
    }
}

函數的結構與C語言中的函數結構有很大不同，函數調用相似

//10 10
//true
package main

import "fmt"

func fun(num1 *int, num2 *int) bool {
    fmt.Println(*num1, *num2)
    if *num1 == *num2 {
        return true
    } else {
        return false
    }
}

func main() {
    var a int = 10
    var b int = 10

    var flag bool = fun(&a, &b)
    fmt.Print(flag)
}

函數可以同時返回多個值

//hello world
package main

import "fmt"

func fun(str1 string, str2 string) (string, string) {
    return str2, str1
}

func main() {
    str1, str2 := fun("world", "hello")
    fmt.Println(str1, str2)
}

函數可以作爲值使用，神奇~

//-1
package main

import "fmt"

func main() {
    tmp := func(x int) int {
        return -x
    }
    fmt.Print(tmp(1))
}

函數支持匿名函數，可作爲閉包。匿名函數是一個”內聯”語句或表達式。匿名函數的優越性在於可以直接使用函數內的變量，不必申明。

//1 2 3
package main

import "fmt"

func first() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

func main() {
    tmp := first()
    fmt.Println(tmp(), tmp(), tmp())
}

函數也可以成爲自定義類型的一個方法

//10 abc
package main

import "fmt"

//自定義類型
type student struct {
    num  int
    name string
}

//方法getNum
func (stu student) getNum() int {
    return stu.num
}

//方法getName
func (stu student) getName() string {
    return stu.name
}

func main() {
    var st student
    st.num = 10
    st.name = "abc"
    //對象調用其方法
    fmt.Println(st.getNum(), st.getName())
}

數組的聲明、初始化、賦值、訪問

//[0 0 0 0 0 0 0 0 0 0]
//100 1 2 3 4 5 6 7 8 9 [100 1 2 3 4 5 6 7 8 9]
package main

import "fmt"

func main() {
    var arr [10]int
    var number = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    number[0] = 100

    fmt.Println(arr)
    var i int = 0
    for i = 0; i < 10; i++ {
        fmt.Printf("%d ", number[i])
    }

    fmt.Println(number)
}

二維數組的初始化

//[[1 2 3] [4 5 6] [7 8 9]]
package main

import "fmt"

func main() {
    var number = [3][3]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}}
    fmt.Println(number)
}

函數參數爲數組，必須同時顯示的寫出數組元素個數或同時隱藏數組的元素個數

//0 1 2 3 4 5 6 7 8 9 10
package main

import "fmt"

func getNum(number []int) int {
    var i int = 0
    for i = 0; i < 10; i++ {
        fmt.Printf("%d ", number[i])
    }
    return len(number)
}

func main() {
    var number = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    num := getNum(number)
    fmt.Println(num)
}

//0 1 2 3 4 5 6 7 8 9 10
package main

import "fmt"

func getNum(number [10]int) int {
    var i int = 0
    for i = 0; i < 10; i++ {
        fmt.Printf("%d ", number[i])
    }
    return len(number)
}

func main() {
    var number = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    num := getNum(number)
    fmt.Println(num)
}

指針數組的初始化和使用

//0 1 2 3 4 5 6 7 8 9 
package main

import "fmt"

func main() {
    var number = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    var num [10]*int

    for i := 0; i < 10; i++ {
        num[i] = &number[i]
    }

    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", *num[i])
    }
}

二級指針的初始化和使用

//10 10 10
package main

import "fmt"

func main() {
    var i int = 10
    var ptr1 *int = &i
    var ptr2 **int = &ptr1

    fmt.Printf("%d %d %d", i, *ptr1, **ptr2)
}

結構體的定義和初始化方式，注意結構體變量和結構體指針變量訪問結構體成員時只有 . 一種方式，此處和C語言的結構體語法不同

//111
//zhangsan
//man
//20
//111
//zhangsan
//man
//20
package main

import "fmt"

type studentInfo struct {
    id   int
    name string
    sex  string
    age  int
}

func getInfo(stu studentInfo) {
    fmt.Println(stu.id)
    fmt.Println(stu.name)
    fmt.Println(stu.sex)
    fmt.Println(stu.age)
}

func getInfoByPtr(stuPtr *studentInfo) {
    fmt.Println(stuPtr.id)
    fmt.Println(stuPtr.name)
    fmt.Println(stuPtr.sex)
    fmt.Println(stuPtr.age)
}

func main() {

    var stu studentInfo
    stu.id = 111
    stu.name = "zhangsan"
    stu.sex = "man"
    stu.age = 20
    getInfo(stu)
    var stuPtr *studentInfo = &stu
    getInfoByPtr(stuPtr)
}

切片（Slice），長度不固定，可以理解爲動態數組。Slice有兩個屬性：length即當前元素的容量大小，capacity即可以最大容納元素的容量大小。Slice的定義如下

//make([]T, length, capacity)
//len = 0 cap = 0, slice = []
//len = 10 cap = 10, slice = [0 0 0 0 0 0 0 0 0 0]
//len = 10 cap = 10, slice = [0 0 0 0 0 0 0 0 0 0]
//len = 5 cap = 10, slice = [0 0 0 0 0]
package main

import "fmt"

func printSlice(slice []int) {
    fmt.Printf("len = %d cap = %d, slice = %v\n", len(slice), cap(slice), slice)
}

func main() {
    var slice1 []int
    printSlice(slice1)

    var slice2 = make([]int, 10)
    printSlice(slice2)

    var slice3 = make([]int, 10, 10)
    printSlice(slice3)

    slice4 := make([]int, 5, 10)
    printSlice(slice4)
}

Slice的初始化如下：startIndex代表起始下標，endIndex代表終止下標，但在初始化時的實際範圍是startIndex~endIndex-1。
缺省endIndex表示一直到最後一個元素，缺省startIndex表示從第一個元素開始。
當startIndex不是從arr[0]開始時，會將新切片的cap值改變爲：原cap的值減startIndex。

//s := arr[startIndex:endIndex] 
//len = 10 cap = 10, slice = [0 1 2 3 4 5 6 7 8 9]
//len = 10 cap = 10, slice = [0 1 2 3 4 5 6 7 8 9]
//len = 10 cap = 10, slice = [0 1 2 3 4 5 6 7 8 9]
//len = 2 cap = 9, slice = [1 2]
//len = 9 cap = 9, slice = [1 2 3 4 5 6 7 8 9]
//len = 3 cap = 10, slice = [0 1 2]
//len = 2 cap = 8, slice = [2 3]
package main

import "fmt"

func printSlice(slice []int) {
    fmt.Printf("len = %d cap = %d, slice = %v\n", len(slice), cap(slice), slice)
}

func main() {
    var slice1 = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    printSlice(slice1)

    slice2 := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    printSlice(slice2)

    //數組arr
    var arr = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    slice3 := arr[:]
    printSlice(slice3)

    slice4 := arr[1:3]
    printSlice(slice4)

    slice5 := arr[1:]
    printSlice(slice5)

    slice6 := arr[:3]
    printSlice(slice6)

    slice7 := slice5[1:3]
    printSlice(slice7)
}

未初始化的切片Slice默認爲nil，len爲0，cap爲0

//len = 0, cap = 0, slice = []
//slice is nil
package main

import "fmt"

func printSlice(slice []int) {
    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(slice), cap(slice), slice)
}

func main() {
    var slice []int
    printSlice(slice)

    if slice == nil {
        fmt.Printf("slice is nil\n")
    }
}

Slice切片的append()追加和copy()拷貝。
當切片長度len等於切片容量cap時，再append()追加數據，此時切片cap容量增長，且默認擴容2倍。

//len = 0, cap = 0, slice = []
//len = 1, cap = 1, slice = [0]
//len = 2, cap = 2, slice = [0 1]
//len = 5, cap = 6, slice = [0 1 2 3 4]
//len = 5, cap = 12, slice = [0 1 2 3 4]
package main

import "fmt"

func printSlice(slice []int) {
    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(slice), cap(slice), slice)
}

func main() {
    var slice []int
    printSlice(slice)

    //此時cap默認擴容2倍
    slice = append(slice, 0)
    printSlice(slice)

    //此時cap默認擴容2倍
    slice = append(slice, 1)
    printSlice(slice)

    //此時cap擴容規則出現變化，同時append追加多個數據時，cap會擴容到向上最近的偶數數值，以減少cap容量的浪費
    slice = append(slice, 2, 3, 4)
    printSlice(slice)

    slice2 := make([]int, len(slice), cap(slice)*2)
    copy(slice2, slice)
    printSlice(slice2)
}

Slice切片的append()並沒有改變參數中的原切片，而是改變了接受返回值的切片

//[1 2 8 4]
//[1 2 8 4]
//[1 2 8 4]
//[1 2 9 4 5]
package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4} //a slice with a len and cap of 4
    other := original
    other[2] = 8
    fmt.Println(original)
    fmt.Println(other)

    other = append(original, 5)
    other[2] = 9
    fmt.Println(original)
    fmt.Println(other)
}

range（範圍）用來循環迭代array（數組）、slice（切片）、channel（通道）、map（集合）

//slice
package main

import "fmt"

func main(){
    nums := []int{1, 2, 3}
    sum := 0
    for _, num := range nums{
        sum += num
    }
    fmt.Print(sum)
}

//slice
package main

import "fmt"

func main(){
    kvs := map[string]string{"1": "one", "2": "two"}

    for k, v := range kvs{
        fmt.Printf("%s -> %s\n", k, v)
    }
}

map是無序的鍵值對集合，delete函數刪除map中的元素

package main

import "fmt"

func main(){
    //定義map集合
    var studentName map[int]string
    //初始化創建集合
    studentName = make(map[int]string)

    studentName[0] = "zhangsan"
    studentName[1] = "lisi"
    studentName[2] = "wangwu"
    //由於map是hash表實現的，所以每次的迭代結果不確定
    for ID := range studentName{
        fmt.Printf("%d -> %s\n", ID, studentName[ID])
    }
    //刪除key爲0的元素
    delete(studentName, 0)
    fmt.Println("delete", 0)

    for ID := range studentName{
        fmt.Printf("%d -> %s\n", ID, studentName[ID])
    }
}

interface接口，和JAVA中的接口相似

package main

import (
    "fmt"
)

type Action interface{
    sleep()
    eat()
}

type Human struct{

}

func(hum Human) sleep(){
    fmt.Println("human sleeping")
}

func(hum Human) eat(){
    fmt.Println("human eating")
}

type Dog struct{

}

func(dog Dog) sleep(){
    fmt.Println("dog sleeping")
}

func(dog Dog) eat(){
    fmt.Println("dog eating")
}

func main(){

    var action Action

    action = new(Human)
    action.sleep()

    action = new(Dog)
    action.eat()
}

錯誤處理

package main

import (
    "fmt"
)

// 定義一個 DivideError 結構
type DivideError struct {
    dividee int
    divider int
}

// 實現 `error` 接口
func (de *DivideError) Error() string {
    strFormat := `
    Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0
`
    return fmt.Sprintf(strFormat, de.dividee)
}

// 定義 `int` 類型除法運算的函數
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
    if varDivider == 0 {
        dData := DivideError{
            dividee: varDividee,
            divider: varDivider,
        }
        errorMsg = dData.Error()
        return
        } else {
        return varDividee / varDivider, "no error"
    }
}

func main() {

    // 正常情況
    result, errorMsg := Divide(100, 10)

    if errorMsg == "no error" {
        fmt.Println("100/10 = ", result, errorMsg)
    }
    // 當被除數爲零的時候會返回錯誤信息
    result, errorMsg = Divide(100, 0)

    if errorMsg != "no error" {
        fmt.Println("errorMsg is: ", result, errorMsg)
    }
}

Golang語法的踩坑總結（持續更新中）

公司剛入職了一名 Java 中級開發，短短 4 行代碼居然湊齊了 3 個 bug！我哭了~~

公衆號5月C#/.NET熱文一覽

git 下載大陸鏡像地址

劍指Offer——（43）左旋轉字符串

劍指Offer——（41）和爲S的兩個數字

Nginx中的驚羣現象解決方法

我爲什麼要搬離CSDN Blog？

劍指Offer——（35）數組中的逆序對

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結