45min快速掌握Golang(一)

一、Golang 如何定义变量

在 golang 里面，定义变量用 var keyword

格式 var variable_name vairable_type

1
2


var x string
var x string = "Hello Golang"

也可以省略定义变量类型

1

x := "Hello Golang" // var x string = "Hello Golang"

变量类型：

bool 、string
(u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr
Byte, rune(字符型) 类似 char 类型
Float32, float64, complex64, complex128 复数

强制类型转换

var c int = math.Sqrt(a*a + b*b) 错误的

var c int = int(math.Sqrt(float64(a*a + b*b)))正确的

二、常量的定义

可以不需要类型

1

const fliename = "abc.txt"

枚举类型
1. 普通枚举类型

1
2
3
4
5


    const (
        python = 0
        c = 1
        c ++ = 2
    )

自增枚举类型

1
2
3
4
5


   const (
   	python = iota
   	c
   	c++
   )

三、条件语句

If 语句

if 条件括号可以省略

1
2
3
4
5
6
7
8


// 请省略括号
if (a > 3 && a < 4) {
	...
}
// 优雅
if a > 3 && a < 4 {

}

if 条件语句里面可以赋值， 变量的作用域仅在 if-else 语句里面，这样做显得更加优雅

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


func div(a, b int) (result int, err error) {
	if b == 0 {
		return 0, fmt.Errorf("not allow div 0")
	}
	return a / b, nil
}

func main() {
	// result 变量是块作用域
	if result, err := div(3, 0); err != nil {
		fmt.Printf(err.Error())
	} else {
		fmt.Println(result)
	}
}

3.1 switch -case

Golang 相对于其他 Java、C/C++ 每个 case 后面增加 break 而言，做了更加优雅的处理，就是再每个 case 语句会默认自动 break，要显示去掉 break 的操作，则可以使用 fallthrough

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


func testFallThrough(v int) {
	switch v {
	case 100:
		fmt.Println(100)
	case 60:
		fmt.Println(60)
		fallthrough
	case 0:
		fmt.Println(0)
		fallthrough
	default:
		fmt.Println("default")
	}
}

func main() {
	testFallThrough(100)
	// 100
	testFallThrough(60)
	// 60 0 default
}

switch 不跟随表达式，隐喻switch true 这样的写法就类似于 if-elif-else 的写法

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


func grade2Level(grade int) string {
    var level string
    switch { //switch true
    case grade >= 80:
        level = "very good" // default break
    case grade >= 60:
        level = "good" // default break
    case grade >= 0:
        level = "bad"
    }
    return level
}

func main() {
    fmt.Println(grade2Level(70)) // "good"
}

四、循环语句 for：

4.1 For 省略括号

1
2
3
4


// for(count := 0; count <= 10; count++) {省略括号
for count := 0; count <= 10; count++ {
    fmt.Println("My counter is at", count)
}

4.2 优雅的死循环

1
2
3


for {
    fmt.Println("haha")
}

五、函数

5.1 返回值类型写在最后面

先定义函数本身，在定义返回类型

1
2
3
4


// func multi(a, b int) (int) 括号可以省略 {
func multi(a, b int) int {
    return a * b
}

5.2 可返回多个类型值

1
2
3
4
5
6


func div(a, b int) (int error) {
    if b == 0 {
        return 0, fmt.Errorf("not allow div 0")
    }
    return a / b, nil
}

5.3 函数一等公民

可以作为参数，也可以赋值

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


func add1(a, b int) int {
    return a + b
}

func multi(a, b int) int {
    return a * b
}

// 函数作为参数
func operate(f func(a, b int) int, a, b int) int {
    return f(a, b)
}

func main() {
    add2 := add1 // 函数可以赋值变量
    // lambda 函数  nice
    add3 := func(a, b int) int {
        return a + b
    }
    fmt.Println(add2(2, 3))
    fmt.Println(add3(2, 3))
    fmt.Println(operate(multi, 3, 2))
}

5.4 闭包特性

函数可以内嵌函数, lambda 函数

返回自定义函数，当前实现的是哇，跟 python 的生成器一样拽

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


func makeEvenGenerator() func() uint {
	i := uint(0)
	return func() (ret uint) {
		ret = i
		i += 2
		return
	}
}

func main() {
    // lambda 函数  nice
    add3 := func(a, b int) int {
        return a + b
    }
    fmt.Println(add3(2, 3))

    nextEven := makeEvenGenerator()
	fmt.Println(nextEven()) // 0
	fmt.Println(nextEven()) // 2
	fmt.Println(nextEven()) // 4
}