Go Grammar memo

hair 收录于 Notes

2022-02-09 约 901 字预计阅读 2 分钟

基中基

uint、unit32、unit64

都是无符号整形，在32位系统中uint和uint32相同，在64位系统中uint和uint64位相同

断言

通过断言实现类型转换

形如A.(T)

其中A只能为interface{}, T可以是string, int, struct等类型.

1
2
3
4
5
6
7
8


func echoString(content interface{}) {
    result, err := content.(string)  //通过断言实现类型转换
    if err != nil {  // 断言失败
        fmt.Println(err .Error())  // 输出失败原因
        return
    }
    fmt.Println(result)
}

运算符

“« “left shift operator

1
2
3
4
5
6
7


	pow := make([]int, 10)
	for i := range pow {
		pow[i] = 1 << uint(i) // == 2**i
		a := 1 << uint(i)
		fmt.Printf("%b \n",a)
// 结果
// 1 10 100 ...

1的二进制数0001，把有效值1向左移unit(i)位，正数左边第一位补0，负数补1，等于2的unit(i)次方

“»“right shift operator

1
2
3
4
5
6
7


	p := make([]int, 6)
	for i := range p{
		a := 7 >> uint(i)
		fmt.Printf("%b \n",a)
	}
// result
// 111 11 1 0 0 ...

7的二进制数0111，把有效值111向右移unit(i)位，正数左边第一位补0，负数补1，等于除以2的unit(i)次方

切片

[]string

1
2
3


strs := []string{"123","dsfg"}
strs[0][0] // =="1"
strs[0][0:0] // ==""

语法糖

…

用法：

可以接受任意个数但相同类型的参数。
slice可以被打散进行传递。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


func test1(args ...string) { //可以接受任意个string参数
	for _, v:= range args{
		fmt.Println(v)
	}
}

func main(){

	var strss0 = []string{
		"qwr",
		"234",
	}
	var strss1 = []string{
		"q",
	}
	strss := append(strss0,strss1...)// strss2的元素被打散一个个append进strss
	fmt.Println(strss)
	test1(strss...) //切片被打散传入
}
/* 结果：
[qwr 234 q]
qwr
234
q
*/

标准库

fmt

int转binary

1
2
3


var a uint
a = 66
fmt.Printf("%b \n", a)

log

log.Fatal

打印输出内容
退出应用程序
defer函数不会执行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
    "log"
)

func foo() {
    defer func () { log.Print("3333")} ()
    log.Fatal("4444")
}
func main() {
    log.Print("1111")
    defer func () { log.Print("2222")} ()
    foo()
    log.Print("9999")
}

运行结果：

1
2


2018/08/20 17:48:44 1111
2018/08/20 17:48:44 4444

panic

函数立刻停止执行 (注意是函数本身，不是应用程序停止)
defer函数被执行
返回给调用者(caller)
调用者函数假装也收到了一个panic函数，从而 4.1 立即停止执行当前函数 4.2 它defer函数被执行 4.3 返回给它的调用者(caller)
…(递归重复上述步骤，直到最上层函数) 应用程序停止。
panic的行为

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main
import (
    "log"
)

func foo() {
    defer func () { log.Print("3333")} ()
    panic("4444")
}
func main() {
    log.Print("1111")
    defer func () { log.Print("2222")} ()
    foo()
    log.Print("9999")
}