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