GO语言学习之语句块的实现

目录

• 顺序语句
• 流程图：
• 示例：
• 分支语句
• if 分支语句
• switch分支语句
• 循环语句
• 经典for循环：
• while风格的for循环：
• 无限循环：

顺序语句，顾名思义就是每条语句依次执行。

package main

import "fmt"

func main() {
    var a int = 10
    var b int = 20

    sum := a + b
    fmt.Printf("a + b = %d", sum);
}

在这个例子中，变量 a和 b依次被声明和初始化，然后执行加法运算并将结果赋值给 sum，最后打印输出结果。这些语句按照它们在代码中出现的顺序依次执行。

if – else语句：用于根据条件执行不同的代码块。

流程图：

示例：

package main

import "fmt"

func main() {
    condition := []bool {true, false}

    if condition[0] {
        fmt.Println("condition[0] is true")
    } else {
        fmt.Println("condition[0] is false")
    }

    if condition[1] {
        fmt.Println("condition[1] is true")
    } else {
        fmt.Println("condition[1] is false")
    }
}

if – else if – else链：用于处理多个互斥条件。

流程图：

示例：

package main

import "fmt"

func main() {
    condition := []int {1, 2, 3}

    fmt.Println("condition[3] = ", condition)
    if condition[0] == 1 {
        fmt.Println("condition[0] == 1")
    } else if condition[0] == 2 {
        fmt.Println("condition[0] == 2")
    } else {
        fmt.Println("condition[0] not equal 1 or 2")
    }

    if condition[1] == 1 {
        fmt.Println("condition[1] == 1")
    } else if condition[1] == 2 {
        fmt.Println("condition[1] == 2")
    } else {
        fmt.Println("condition[1] not equal 1 or 2")
    }

    if condition[2] == 1 {
        fmt.Println("condition[2] == 1")
    } else if condition[2] == 2 {
        fmt.Println("condition[2] == 2")
    } else {
        fmt.Println("condition[2] not equal 1 or 2")
    }
}

switch - case 语句：是一种更简洁的多分支选择结构，根据表达式的值来选择执行哪个 case 分支。

    1. switch 可以用在其他类型上，case 后的数值必须和switch作用的变量类型一致
    2. case 是无序的
    3. case后的数值是唯一的， 
    4. default语句是可选的
    5. case分支默认不需要加 break直接退出
    6. 如果想继续执行需要加上fallthrough
    7. 可以省略switch 后面的变量，相当于每个分支是：true 则执行对应的语句块
    8. break 可以用在switch 中， 也可以使用在for 循环语句中
    9. break 用于强制结束case语句，从而结束switch分支
    10. 遇到 fallthrough 无需匹配后续分支，继续执行

流程图：

示例：

package main

import "fmt"

const (
    MONDAY    = 1,
    TUESDAY   = 2,
    WEDNESDAY = 3,
    THURSDAY  = 4,
    FRIDAY    = 5,
    SATURDAY  = 6,
    SUNDAY    = 7,
)

func check_week_days(day int)
{
    switch day {
    case MONDAY:
        fmt.Println("Monday")
    case TUESDAY:
        fmt.Println("Tuesday")
    case WEDNESDAY:
        fmt.Println("Wednesday")
    case THURSDAY:
        fmt.Println("Thursday")
    case FRIDAY:
        fmt.Println("Friday")
    case SATURDAY:
        fmt.Println("Saturday")
    case SUNDAY:
        fmt.Println("Sunday")
    default:
        fmt.Printf("Error day value %dn", day)
    }
}

func main() {
    days := []{ MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY, 100 }

    for i := 0; i < len(days); i++ {
        fmt.Println("input day is : ", days[i])
        check_week_days(days[i])
    }
}

package main

import "fmt"

func check_month(year int, month int) {
	day := 0
	switch month {
	case 1, 3, 5, 7, 8, 10, 12:
		day = 31
	case 4, 6, 9, 11:
		day = 30
	case 2:
		if year%400 == 0 || year%4 == 0 && year%100 != 0 {
			day = 29
		} else {
			day = 28
		}
	default:
		fmt.Println("input month outof range, month is ", month)
		return
	}
	fmt.Println(month, "月有 ", day, "天")
}

func main() {
	year := 1998
	month := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}

	for i := 0; i < len(month); i++ {
		fmt.Println("判断的 month is ", month[i])
		check_month(year, month[i])
	}
}

还有一种特殊的 switch case 语句，不带条件的使用方式，此时，判断分支的case 分支的 布尔值是否为 true，执行为 true的分支。但是，这里有一个有趣的地方就是，这里的每个分支检测的应该是同一个变量的布尔表达式，我用示例代码证明了，这个疑问。

正确的使用姿势：

package main

import "fmt"

func check_level(a int) {
    switch {
    case a > 100:
        fmt.Println("more than scope")
    case a > 90:
        fmt.Println("A")
    case a > 80:
        fmt.Println("B")
    case a > 70:
        fmt.Println("C")
    default:
        fmt.Println("D")
    }
}

func main() {
    a := []int {70, 81,91, 101, 2}
    for i := 0;i < len(a); i++ {
        fmt.Println("input value : ", a[i])
        check_level(a[i])
    }
}

多个变量的结果，结果不确定，你多执行几次，还不一样，这样的代码不可靠！！！！

package main

import "fmt"

func main() {
    a := 2
    b := 1
    c := 1
    switch {
    case a == 1:
        fmt.Println("case a")
    case b == 1:
        fmt.Println("case b")
    case c == 1:
        fmt.Println("case c")
    default:
        fmt.Println("a and b not equal 1")
    }
}

for循环语句： Go 语言中只有 for 这一种循环结构，但它可以实现类似其他语言中 for、while 和 do - while 循环的功能。

语法：for init; condition; post { 循环体 }

其中，init 是初始化语句，condition 是循环条件，post 是每次循环结束后执行的语句。

流程图：

示例 1：

package main

import "fmt"

func main() {
    value := []int {1,2,3,4,5,6,7,8,9,10}
    sum := 0

    for i:=0;i < len(value);i++ {
        sum += value[i]
    }
    fmt.Println("对数组 ", value, " 求和的结果是：", sum)
}

示例 2：

package main

import "fmt"

func main() {
    value := []int{1,2,3,4,5,6,7,8,9,10}
    sum := 0

    for i, v := range value {
        fmt.Println("当前索引 ", i, " 当前值 ", v)
        sum += v
    }
    fmt.Println("求数组 ", value, " 和的结果： ", sum)
}

省略 init 和 post 部分，只保留 condition，类似其他语言中的 while 循环。

流程图：

示例：

package main

import "fmt"


func main() {
    value := []int {1,2,3,4,5,6,7,8,9,10}
    sum := 0
    i := 0

    for i < len(value) {
        sum += value[i]
        i++
    }
    fmt.Println("对数组 ", value, " 求和的结果：", sum)
}

省略所有部分，即 for { }，可以通过 break 语句跳出循环。

流程图：

示例 1：

package main

import "fmt"

func main() {
    value := []int{1,2,3,4,5,6,7,8,9,10}
    sum := 0
    i := 0

    for {
        if i < len(value) {
            sum += value[i]
            fmt.Println("和 ", sum, "当前值 ", value[i])
            i++
        } else {
            break;
        }
    }
    fmt.Println("对数组 ", value, " 求和的结果：", sum)
}

示例 2：（补充goto语句的使用）

package main

import "fmt"

func main() {
    for i := 1;i < 10;i++ {
        j := 1
start:
        if (j <= i) {
            fmt.Printf("%d * %d = %d ", i, j, i * j)
            j++
            goto start;
        } else {
            fmt.Println()
        }
    }
}

到此这篇关于GO语言学习之语句块的实现的文章就介绍到这了,更多相关GO 语句块内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！ 

您可能感兴趣的文章:

• golang语言中for循环语句用法实例
• Go语言中Select语句用法实例
• Go语言流程控制之goto语句与无限循环
• go语言中if语句用法实例