【Golang学习笔记】02

要点

- 部分运算符

- 控制语句

- 函数

部分运算符

byte运算

const (
a byte = 1 << iota
b
c
d
)

x := a | b | c
y := a | b | d

fmt.Printf("%4b &^ %04b = %04b", x, y, x &^ y)  // 111 &^ 1011 = 0100
// %nb, n代表占n位，0用空格代替， %0nb，0用0代替

后缀运算

前缀++ - - 被移除了， 后缀 ++ - - 只能作为语句 不能在放入表达式了

q := 1
//w:= q++       q++是语句不是表达式，此行编译不通过
q++
w:= &q
*w++
fmt.Println(q)   // 3

控制语句

if else

if 语句; bool{}else{}

//
if x:=6;x > 5 {
fmt.Println(x)  // 这么赋值的话作用域只在if语句范围内
} else if x < 7{
fmt.Println(x)
}

for

循环只有for， while dowhile被移除了

for i:=0; i < 10; i++ {
fmt.Println(i)
if i > 5 {
break
}
}

使用range做循环

循环时使用range i代表序号， s代表value

DataArray := [5]int{10,20,30,40,50}
for i,s := range DataArray {  //    for i := range DataArray { 也可以使用占位符或者省略s
fmt.Println(i,s, &i, &s)
}

/*
0 10 0xc0420500d0 0xc0420500d8
1 20 0xc0420500d0 0xc0420500d8
2 30 0xc0420500d0 0xc0420500d8
3 40 0xc0420500d0 0xc0420500d8
4 50 0xc0420500d0 0xc0420500d8
i和s的地址始终一样，说明循环时用的时同一块内存空间
*/

goto

q := 0
here:
q++
if q < 3 {
goto here
}
fmt.Println(q)    // 3

switch case

不需要break; 执行完当前case后就会自动跳出

choice := 2
switch choice {
case 1:
fmt.Println(1)
case 2:
fallthrough         //关键字 直接执行下一个case
case 3:
fmt.Println(3)
case 4,5,6:
fmt.Println(4)
default:
fmt.Println("default")
}
// 3

函数

不需要前置声明

func main() {
test()
}

func test()  {
fmt.Println("不需要前置声明")
}

匿名函数

a := func() {fmt.Println("匿名函数")}
a()
// 或者
func() {fmt.Println("匿名函数")}()

函数赋值,必须是同一类型的函数

func test1(){
fmt.Println("test1")
}

func test2(){
fmt.Println("函数赋值")
}

func main() {
b := test1
c := test2
b = c
b()       // 函数赋值
}

go的escape analysis

func test3() *int{
a := 1                      // 在函数内创建，应该是申请的栈内存，但是因为外部有引用所以逃逸到了堆上(go的escape analysis)
fmt.Println(a, &a)
return &a
}

func main() {
d := test3()
fmt.Println(*d, d)
}

//1 0xc042050090
//1 0xc042050090
//内存地址完全一样，所以说明外部得到的就是在函数内申请的内存空间。

带多返回值的函数

func Divide(a int, b int) (int, error) {
if (b == 0) {
return 0, errors.New("Can't Divide 0")
}
return a/b,nil
}

func main() {
w, err := Divide(2, 0)// err也可以用_占位符代替
fmt.Println(w, err)
}

不定长参数

// 不定长参数函数   参数名 ... 数据类型
func VariableLength(a ... int)  {
fmt.Printf("%T, %v \n", a, a)
}

func main() {
q := []int{1,2,3,4,5,6}
VariableLength(q...)    // 无敌的省略号
}

将函数作为参数传递

// 将函数作为参数传过去
func test(q int, w string,f func(a int,s string)(int, string))  {
f(q, w)
}

func n1(a int, s string)(int, string){
fmt.Println(a, s)
return  a,s
}

func main() {
test(1,"abc0", n1)
}

延迟调用

func main() {
// 延迟调用 关键字 defer
defer fmt.Println("a001")
defer fmt.Println("a002")
fmt.Println("a003")
fmt.Println("a004")
}

/*
a003
a004
a002
a001 先defer的排在最后
*/

错误处理

panic recover

func main() {
// 错误处理
defer func() {
if err := recover(); err != nil {
fmt.Println("recover", err)  // 恢复中断的程序 可以用作释放资源之类的操作
}
}()

panic("here panic")     // 中断程序
fmt.Println("after panic")//这句不会执行
}