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语法的踩坑总结（持续更新中）

猜你喜欢