golang逻辑语句

一、if-else语句

1、基本语句

if condition {  
}

/*
如果 condition 为真，则执行大括号之间的代码，不同于其他语言，golang 里的大括号是必要的，即使在大括号之间只有一条语句
*/

2、if 语句还有可选的 else if 和 else 部分

if condition {  
} else if condition {
} else {
}

3、if-else 语句之间可以有任意数量的 else if，条件判断顺序是从上到下，如果 if 或 else if 条件判断的结果为真，则执行相应的代码块，如果没有条件为真，则 else 代码块被执行

// 检测一个数字是奇数还是偶数

package main

import (  
    "fmt"
)

func main() {  
    num := 10
    if num % 2 == 0 { 
        fmt.Println("the number is even") 
    }  else {
        fmt.Println("the number is odd")
    }
}

/*
if num％2 == 0 语句检测 num 取 2 的余数是否为零， 
如果是为零则打印输出 “the number is even”，如果不为零则打印输出 “the number is odd”
本程序输出的是 the number is even
*/

4、if 还有另外一种形式，它包含一个 statement 可选语句部分，该组件在条件判断之前运行

if statement; condition {  
}

// 检测一个数字是奇数还是偶数

package main

import (  
    "fmt"
)

func main() {  
    if num := 10; num % 2 == 0 { 
        fmt.Println(num,"is even") 
    }  else {
        fmt.Println(num,"is odd")
    }
}

/*
在上面的程序中，num 在 if 语句中进行初始化，num 只能从 if 和 else 中访问
也就是说 num 的范围仅限于 if else 代码块，如果试图从其他外部的 if 或者 else 访问 num，编译器会不通过
*/

5、使用 else if

package main

import (  
    "fmt"
)

func main() {  
    num := 99
    if num <= 50 {
        fmt.Println("number is less than or equal to 50")
    } else if num >= 51 && num <= 100 {
        fmt.Println("number is between 51 and 100")
    } else {
        fmt.Println("number is greater than 100")
    }

}

/*
在上面的程序中，如果 else if num >= 51 && num <= 100 为真，程序将输出 number is between 51 and 100
*/

6、else 语句应该在 if 语句的右大括号之后的同一行中，如果不是，编译器会不通过，因为golang的分号是自动插入的，会指定在右大括号之后插入一个分号，如果这是该行的最终标记，因此，在if语句后面的右大括号之后会自动插入一个分号，分号插入之后，由于 if{…} else {…} 是一个单独的语句，它的中间不应该出现分号。因此，需要将 else 语句放置在右大括号之后处于同一行中

二、for

1、循环语句是用来重复执行某一段代码的，for 是 golang 唯一的循环语句，golang 语言中并没有其他语言比如 C 语言中的 while 和 do while 循环

2、基本语法

for initialisation; condition; post {  
}

3、初始化语句只执行一次，循环初始化后，将检查循环条件，如果条件的计算结果为 true ，则大括号内的循环体将执行，接着执行 post 语句，post 语句将在每次成功循环迭代后执行，在执行 post 语句后，条件将被再次检查，如果为 true，则循环将继续执行，否则 for 循环将终止(这是典型的 for 循环三个表达式，第一个为初始化表达式或赋值语句；第二个为循环条件判定表达式；第三个为循环变量修正表达式，即此处的 post)，这三个组成部分，即初始化，条件和 post 都是可选的

4、示例

// 用 for 循环写一个打印出从 1 到 10 的程序

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        fmt.Printf(" %d",i)
    }
}

/*
在上面的程序中，i 变量被初始化为 1，条件语句会检查 i 是否小于 10，如果条件成立，i 就会被打印出来，否则循环就会终止
循环语句会在每一次循环完成后自增 1，一旦 i 变得比 10 要大，循环中止
上面的程序会打印出 1 2 3 4 5 6 7 8 9 10 
在 for 循环中声明的变量只能在循环体内访问，因此 i 不能够在循环体外访问
*/

5、break：break 语句用于在完成正常执行之前突然终止 for 循环，之后程序将会在 for 循环下一行代码开始执行

// 写一个从 1 打印到 5 并且使用 break 跳出循环的程序

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i > 5 {
            break 
        }
        fmt.Printf("%d ", i)
    }
    fmt.Printf("\nline after for loop")
}

/*
在上面的程序中，在循环过程中 i 的值会被判断，如果 i 的值大于 5 然后 break 语句就会执行，循环就会被终止
打印语句会在 for 循环结束后执行，上面程序会输出为 
1 2 3 4 5  
line after for loop
*/

6、continue：continue 语句用来跳出 for 循环中当前循环，在 continue 语句后的所有的 for 循环语句都不会在本次循环中执行，循环体会在一下次循环中继续执行

// 写一个打印出 1 到 10 并且使用 continue 的程序

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Printf("%d ", i)
    }
}

/*
在上面的程序中，这行代码 if i%2==0 会判断 i 除以 2 的余数是不是 0，
如果是 0，这个数字就是偶数然后执行 continue 语句，从而控制程序进入下一个循环
因此在 continue 后面的打印语句不会被调用而程序会进入一下个循环
上面程序会输出 1 3 5 7 9
*/

7、示例

// 打印出从 0 到 10 所有的偶数

package main

import (  
    "fmt"
)

func main() {  
    i := 0
    for ;i <= 10; { 
        fmt.Printf("%d ", i)
        i += 2
    }
}

/*
正如已经知道的那样，for 循环的三部分，初始化语句、条件语句、post 语句都是可选的
在上面的程序中，初始化语句和 post 语句都被省略了
i 在 for 循环外被初始化成了 0，只要 i<=10 循环就会被执行，在循环中，i 以 2 的增量自增
上面的程序会输出 0 2 4 6 8 10
*/

8、for 循环中的分号也可以省略，这个格式的 for 循环可以看作是二选一的 for while 循环

// 打印出从 0 到 10 所有的偶数

package main

import (  
    "fmt"
)

func main() {  
    i := 0
    for i <= 10 { 
        fmt.Printf("%d ", i)
        i += 2
    }
}

9、在 for 循环中可以声明和操作多个变量

10 * 1 = 10  
11 * 2 = 22  
12 * 3 = 36  
13 * 4 = 52  
14 * 5 = 70  
15 * 6 = 90  
16 * 7 = 112  
17 * 8 = 136  
18 * 9 = 162  
19 * 10 = 190
package main

import (  
    "fmt"
)

func main() {  
    for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { 
        fmt.Printf("%d * %d = %d\n", no, i, no*i)
    }

}

/*
在上面的程序中 no 和 i 被声明然后分别被初始化为 10 和 1，在每一次循环结束后 no 和 i 都自增 1
布尔型操作符 && 被用来确保 i 小于等于 10 并且 no 小于等于 19 
*/

10、无限循环

package main

import "fmt"

func main() {  
    for {
        fmt.Println("Hello World")
    }
}

/*
本程序会一直打印Hello World不会停止
*/

三、switch

1、switch 是一个条件语句，用于将表达式的值与可能匹配的选项列表进行比较，并根据匹配情况执行相应的代码块，它可以被认为是替代多个 if else 子句的常用方式

2、示例

// 把一个手指的编号作为输入，然后输出该手指对应的名字

package main

import (
    "fmt"
)

func main() {
    finger := 4
    switch finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")

    }
}

/*
switch finger 将 finger 的值与每个 case 语句进行比较
通过从上到下对每一个值进行对比，并执行与选项值匹配的第一个逻辑
finger 值为 4，因此打印的结果是 Ring
在选项列表中，case 不允许出现重复项
*/

3、默认分支(Default Case)：当列举的情况都不匹配时，将运行默认情况

package main

import (
    "fmt"
)

func main() {
    switch finger := 8; finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")
    default: // 默认情况
        fmt.Println("incorrect finger number")
    }
}

/*
finger 的值是 8，它不符合其中任何情况，因此会打印 incorrect finger number
default 不一定只能出现在 switch 语句的最后，它可以放在 switch 语句的任何地方
以上 finger 变量的声明方式略有变化，finger 声明在了 switch 语句内，在表达式求值之前，switch 可以选择先执行一个语句
在这行 switch finger：= 8; finger 中，先声明了finger 变量，随即在表达式中使用了它，在这里，finger 变量的作用域仅限于这个 switch 内
*/

4、多表达式判断：通过用逗号分隔，可以在一个 case 中包含多个表达式

package main

import (
    "fmt"
)

func main() {
    letter := "i"
    switch letter {
    case "a", "e", "i", "o", "u":  // 一个选项多个表达式，列举了所有的元音，只要匹配该项，则将输出 vowel
        fmt.Println("vowel")
    default:
        fmt.Println("not a vowel")
    }
}

5、无表达式的 switch：在 switch 语句中，表达式是可选的，可以被省略，如果省略表达式，则表示这个 switch 语句等同于 switch true，并且每个 case 表达式都被认定为有效，相应的代码块也会被执行

package main

import (
    "fmt"
)

func main() {
    num := 75
    switch { // 表达式被省略了
    case num >= 0 && num <= 50:
        fmt.Println("num is greater than 0 and less than 50")
    case num >= 51 && num <= 100:
        fmt.Println("num is greater than 51 and less than 100")
    case num >= 101:
        fmt.Println("num is greater than 100")
    }

}

/*
switch 中缺少表达式，因此默认它为 true，true 值会和每一个 case 的求值结果进行匹配
case num >= 51 && <= 100: 为 true，所以程序输出 num is greater than 51 and less than 100
这种类型的 switch 语句可以替代多个 if else 子句
*/

6、Fallthrough 语句：在 golang 中，每执行完一个 case 后，会从 switch 语句中跳出来，不再做后续 case 的判断和执行，使用 fallthrough 语句可以在已经执行完成的 case 之后，把控制权转移到下一个 case 的执行代码中，fallthrough 语句应该是 case 子句的最后一个语句。如果它出现在了 case 语句的中间，编译器将会报错

// 检查输入的数字是否小于 50、100 或 200。例如输入 75，程序将输出75 is lesser than 100 和 75 is lesser than 200

package main

import (
    "fmt"
)

func number() int {
    num := 15 * 5 
    return num
}

func main() {

    switch num := number(); { // num is not a constant
    case num < 50:
        fmt.Printf("%d is lesser than 50\n", num)
        fallthrough
    case num < 100:
        fmt.Printf("%d is lesser than 100\n", num)
        fallthrough
    case num < 200:
        fmt.Printf("%d is lesser than 200", num)
    }

}

/*
switch 和 case 的表达式不一定是常量，它们也可以在运行过程中通过计算得到
在上面的程序中，num 被初始化为函数 number() 的返回值
程序运行到 switch 中时，会计算出 case 的值。case num < 100： 的结果为 true，所以程序输出 75 is lesser than 100
当执行到下一句 fallthrough 时，程序控制直接跳转到下一个 case 的第一个执行逻辑中，所以打印出 75 is lesser than 200
最后这个程序的输出是
75 is lesser than 100  
75 is lesser than 200
*/