go语言 3 程序的流程控制

2018-01-12 21:16:53来源:cnblogs.com作者:北京记忆人点击

分享

程序的流程控制主要包括三种不同的结构,分别是顺序结构、选择结构和循环结构。

  1.  顺序结构最为简单,程序执行时,按照语句的顺序自上而下依次执行。
  2. 选择结构是根据条件表达式的结果选择执行某些语句。
  3. 循环结构是重复执行执行某些语句。

3.1 选择结构

3.1.1 if语句的语法:

// 1

if condition {

    ...

}

// 2

if condition {

    ...

else {

    ...

}

// 3

if condition {

    ...

else if condition {

    ...

}

// 4

if condition {

    ...

else if condition {

    ...

else {

    ...

}

注意事项:

  1. 不需要使用括号()将条件包含起来。
  2. 无论语句体内有几条语句,花括号{}都必须存在。
  3. 左花括号{必须与if或else同处一行,否则有编译器错误
  4. else必须和上一个语句体结束的右花括号}同处一行,否则有编译错误
  5. 在if之后可以添加变量初始化语句,但需要使用分号;间隔

惯用法:if 语句条件前面可以前置一条初始化语句,而go语言中的函数可以返回多个值,有很多函数第二个返回值是 error 类型,示例如下:

if v, err := func(); err == nil {

  //逻辑语句

}

四种不同if结构的案例如下:

package main

 

import "fmt"

 

func main() {

 

    fmt.Println("请输入您的成绩(0~100)")

    var grade int

    fmt.Scanln(&grade)

    // 1 错误判断

    if (grade < 0) || (grade > 100) {

        fmt.Println("您输入的成绩有误!")

        return

    }

    // 2 判断是否及格

    if grade >= 60 {

        fmt.Println("及格")

    } else {

        fmt.Println("不及格")

    }

    // 3 打印等级

    if (grade >= 90) && (grade <= 100) {

        fmt.Println("A")

    } else if (grade >= 80) && (grade < 90) {

        fmt.Println("B")

    } else if (grade >= 70) && (grade < 80) {

        fmt.Println("C")

    } else if (grade >= 0) && (grade < 70) {

        fmt.Println("D")

    }

 

    // 4 比较两个数值的大小

    fmt.Println("请输入两个整数:")

    var a, b int

    fmt.Scanln(&a, &b)

    if a > b {

        fmt.Println(a, "大于", b)

    } else if a < b {

        fmt.Println(a, "小于", b)

    } else {

        fmt.Println(a, "等于", b)

    }

}

3.1.2 switch语句

switch语句的语法:

switch condition {

case v0:

    ...

case v1:

    ...

case v2:

    ...

case v3:

    ...

case v4, v5, v6:

    ...

default:

    ...

}

注意事项:

1.左花括号{必须与switch同处一行。

2.case后可以使用常量,还可以使用变量。

package main

 

import "fmt"

 

func main() {

    condition := 0

    caseValue := 0

 

    switch condition {

    case caseValue:

        fmt.Println("0")

    case 1:

        fmt.Println("1")

    default:

        fmt.Println("Default")

    }

}

注意事项:

  1. 单个case后可以出现多个结果选项。
  2. 不需要用break来明确退出一个case。
  3. 只有在case中明确添加fallthrough关键字,才会继续执行下一个case。

package main

 

import "fmt"

 

func main() {

    condition := 1

 

    switch condition {

    case 0:

        fmt.Println("0")

    case 1:

        fmt.Println("1")

        fallthrough

    default:

        fmt.Println("Default")

    }

}

可不设定switch后的条件表达式,在此种情况下整个switch结构与if...else...的逻辑等同。

package main

 

import "fmt"

 

func main() {

    num := 1

 

    switch {

    case 0 <= num && num <= 3:

        fmt.Println("0-3")

    case 4 <= num && num <= 6:

        fmt.Println("4-6")

    case 7 <= num && num <= 9:

        fmt.Println("7-9")

    }

}

例子:根据输入的年份月份计算月份的天数?

package main

 

import "fmt"

 

func main() {

 

    fmt.Println("请输入年份月份:")

    var month int

    var year int

    fmt.Scanln(&year, &month)

    switch month {

    case 1, 3, 5, 7, 8, 10, 12:

        fmt.Println("31天")

    case 4, 6, 9, 11:

        fmt.Println("30天")

    case 2:

        if (year%4 == 0 && year%100 != 0) || (year%400 == 0) {

            fmt.Println("29天")

        } else {

            fmt.Println("28天")

        }

    default:

        fmt.Println("输入的月份有误!")

    }

}

 

3.2 循环结构

接下来,我们来看循环结构,在其它编程语言中,循环结构一般至少包括for、while和do while语句三种,但是在Go语言中,循环结构只有for语句,没有while和do while语句。因为for语句经过变体是可以完全替代其它语句的,这也体现了Go语言的简洁性。

3.2.1 for语句

for语句的语法如下:

// 普通循环

for 初始化表达式; 条件表达式; 步进表达式 {

    循环体语句

}

 

首先执行初始化表达式,然后执行条件表达式,如果条件表达式的结果为真,执行循环体语句和步进表达式。然后再回到条件表达式进行判断,周而复始的重复执行。如果条件表达式的结果为假,直接跳出for循环,意味这整个for循环结束。

 

 普通for循环的流程图:

我们看一个for循环的例子,求1~100的数值的和。

package main

 

import "fmt"

 

func main() {

 

    //保存结果

    var sum int = 0

    // i表示1~100

    for i := 1; i <= 100; i++ {

        sum = sum + i

    }

    fmt.Println("sum:", sum)

}

省略表达式1:

package main

 

import "fmt"

 

func main() {

    var sum int = 0

    i := 1

    for ; i <= 100; i++ {

        sum = sum + i

    }

    fmt.Println("sum:", sum)

}

省略表达式2:

package main

 

import "fmt"

 

func main() {

    var sum int = 0

    i := 1

    for ; ; i++ {

        if i > 100 {

            break

        }

 

        sum = sum + i

    }

    fmt.Println("sum:", sum)

}

省略表达式3:

package main

 

import "fmt"

 

func main() {

    var sum int = 0

    i := 1

    for {

        if i > 100 {

            break

        }

        sum = sum + i

        i++

    }

    fmt.Println("sum:", sum)

}

数组循环:

// 数组循环

for i, v := range array {

    ...

}

注意事项:

1) 只支持for结构,不支持while和do-while结构。

2) 左花括号{必须与for处于同一行。

3) 不支持以逗号为间隔的多赋值语句,支持使用多元赋值的方式来初始化多个变量。这个很好判断,在一个表达式中不允许有多个赋值语句,即:=或=。

package main

 

import "fmt"

 

func main() {

    array := []int{1, 2, 3, 4, 5, 6}

    for i, j := 0, len(array)-1; i < j; i, j = i+1, j-1 {

        array[i], array[j] = array[j], array[i]

    }

    fmt.Println(array)

}

3.2.2 continue和break语句

continue语句在for循环结构中的作用是结束本次循环,即跳过循环体中下面还没有执行的语句,接着进行下一次循环。break语句在循环结构中的作用是跳出循环体,提前结束循环。

例如:打印1~10之间可以被3整除的数下:

package main

 

import "fmt"

 

func main() {

    for i := 1; i <= 10; i++ {

        if i%3 != 0 {

            continue

        }

        fmt.Println("i=", i)

    }

}

3.3 goto语句

goto语句是跳转语句,天生要和标签配合使用。可以让程序无条件的跳转到标签之处继续执行。一般的语法格式:

goto LABEL

...

...

...

LABEL:

案例如下:

package main

 

import "fmt"

import "time"

 

func main() {

    i := 0

    for {

        i++

        if i >= 10 {

            goto FINISH

 

        }

        fmt.Print(i, "  ")

        time.Sleep(1 * time.Second)

    }

FINISH:

    fmt.Println("/nFinish")

}

最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台