Go初探 (3) – 基础语句

1111 字

6 分钟

Go初探 (3) – 基础语句

2020-10-30

开发

Go

基础语句#

条件语句#

if#

if条件语句与Java基本一致，基础语法为

1
if 表达式 {
2
    //你的代码
3
}

例如

1
package main
2
import "fmt"
3

4
func main(){
5
    a := 10
6
    if a > 0 {
7
        fmt.Print("123")
8
    }
9
}

你也许已经知道了，表达式可以不需要括号。推测下去，go的if分支条件语句还有如下写法

1
//if...else...
2
if 表达式 {
3
    //你的代码
4
} else {
5
    //你的代码
6
}
7

8
//if...else if...
9
if 表达式 {
10
    //你的代码
11
} else if 表达式 {
12
    //你的代码
13
}
14

15
//嵌套if
16
if 表达式 {
17
    if 表达式 {
18
        //你的代码
19
    } else {
20
        //你的代码
21
    }
22
}

switch#

与Java不同，go语言里switch的case分支自带break属性，默认在满足条件的情况下，不会执行接下来的分支。

1
switch 表达式 {
2
    case val1:
3
        //你的代码
4
    case val2:
5
        //你的代码
6
    default:
7
        //你的代码
8
}

当然，与Java不同的是，你还可以这么干

1
switch {
2
    case val1 == val2:
3
        //你的代码
4
    case val3 == val4:
5
        //你的代码
6
    default:
7
        //你的代码
8
}

case后可填入条件表达式。当第一处运行为真时，退出分支。当然了，如果你想在满足条件时，执行接下来剩下的分支，你需要在分支后添加fallthrough

1
switch {
2
    case val1 == val2:
3
        fallthrough
4
        //你的代码case val3 == val4:
5
        fallthrough
6
        //你的代码
7
    default:
8
        //你的代码
9
}

fallthrough在执行剩下的分支时，不会判断剩下分支的表达式是否为真，就如Java中的case分支不加上break。

type-switch#

除此之外，switch语句还可以判断某个接口的类型。如果你还没学到接口，这里可以跳过。

1
package main
2

3
import "fmt"
4

5
type MyInterface interface{
6
    call() int32
7
}
8

9
type MyStruct struct {
10
    name string
11
}
12

13
func (a *MyStruct) call() int32{
14
    return 1
15
}
16

17
func main() {
18
    var myInterface MyInterface
19
    myStruct := new(MyStruct)
20
    myInterface = myStruct
21

22
    switch i := myInterface.(type){
23
    case *MyStruct:
24
        fmt.Println("MyStruct", i)
25
    case nil:
26
        fmt.Println("nil")
27
    }
28
}

select#

select语句与switch类似。但与switch不同的是，case中的表达式必须是一个通信。如果case中没有可运行的，程序将堵塞，直到有case可以运行为止。

1
select {
2
    case 通信1:
3
        //你的代码
4
    case 通信2:
5
        //你的代码
6
    //可选
7
    //default:
8
        //你的代码
9
}

其中：

每个case必须是一个通信
如果有多个case可运行，go将公平地随机选取一个case运行
如果没有case可运行
- 如果没有defalut分支，程序将堵塞
- 如果有，将运行default分支
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略

循环语句#

for#

for循环有3种形式

1
for 初始值; 条件; 赋值表达式 {} //Java中的for(初始值; 条件; 赋值表达式){}
2
for 条件 {} //Java中的while(条件){}
3
for {} //Java中的while(true){}

也可以用range格式，相当于Java的foreach。for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。

1
for key, value := oldMap {
2
    newMap[key] = value
3
}

例如：

1
numbers := []int32{100, 200, 300}
2
for i, value := numbers {
3
    fmt.Printf("%d: %d\n", i, value)
4
}

除此之外，与Java类似，循环分支包括以下几种循环控制语句。

break#

break可以跳出for循环。相同的，你可以使用标签来跳出指定的分支。

continue#

continue可以跳过当前循环，执行下一个循环。

goto#

emmm…这个还是别用了吧

函数#

函数定义：

1
func 函数名 (参数) [返回类型] {
2
   函数体
3
}

例如：

1
func add (a int, b int) int {
2
    return a + b
3
}

调用：

1
func main(){
2
    var b int
3
    b = add(1, 2)//调用函数
4
    fmt.Print(b)
5
}

当然，函数可以有多个返回值

1
func swap (a, b int) int{
2
    return b, a
3
}
4

5
func main(){
6
    a, b := swap(3, 4)
7
    fmt.Printf("%d %d", a, b)
8
}

除此之外，你还可以以指针作为参数传递

1
func print(str *string){
2
    *str += "123"
3
}
4

5
func main(){
6
    str := "456"
7
    print(&str)
8
    fmt.Println(str)
9
}

闭包#

Go 语言支持匿名函数，可作为闭包。匿名函数是一个“内联”语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。例如：

1
func get(i int) func() int{
2
    i++
3
    return func() int {
4
        i += 2
5
        return i
6
    }
7
}
8

9
func main(){
10
    var a int
11
    a := get(2)
12
    fmt.Print(a())
13
}

方法#

go语言中，函数也可变为方法。方法的定义如下

1
func (对象名 对象方法) 方法名(参数) [返回类型]{
2
    方法体
3
}

即，这个对象拥有了这个方法。

1
type Dog struct{
2

3
}
4

5
func (dog *Dog) bark(){
6
    fmt.Print("I'm barking!")
7
}
8

9
func main(){
10
    dog := new(Dog)
11
    dog.bark();
12
}