Go语言入门02—条件和循环

1 条件语句

条件语句就是根据不同的条件执行不同的代码。
示意图：

1.1 if语句

if语句用于判断某个条件是否满足，当条件满足时则执行if语句块中的代码。

语法：

if 条件表达式 {
   // 当条件表达式为true时执行
}

代码示例：

package main

import "fmt"

func main() {
  score := 90
  if score >= 90 {
    fmt.Println("优秀")
  }
}

因为表达式score >= 90的结果为true，则会在控制台打印出优秀

运行结果：

1.2 if...else

在if条件语句中，如果表达式为true则会执行if语句块中的代码，在if后还可以增加else语句块，则表示当if条件为false时执行else中的代码。

语法：

if 条件表达式 {
   // 当条件表达式为true时执行
} else {
    // 当条件表达式为false时执行
}

代码示例：

package main

import "fmt"

func main() {
  score := 80
  if score >= 90 {
    fmt.Println("优秀")
  } else {
    fmt.Println("一般")
  }
}

score = 80，由于表达式score >= 90结果为false，则不会执行if中的语句块，会转而执行else中的语句块。

运行结果：

除了直接使用if...else之外，还可以在else后面继续增加if条件判断。

语法：

if 条件表达式1 {
   // 当条件表达式1为true时执行
} else if 条件表达式2 {
    // 当条件表达式2为true时执行
} else {
    // 当条件表达式1和2都不为true时执行
}

代码示例：

package main

import "fmt"

func main() {
  score := 80
  if score >= 90 {
    fmt.Println("优秀")
  } else if score >= 80 {
    fmt.Println("良好")
  } else {
    fmt.Println("一般")
  }
}

运行结果：

if...else if判断没有数量限制，可一直添加else if判断，但是在实际开发中不建议写太多，如果有特别多得条件需要判断，可使用switch进行判断

1.3 if嵌套

if嵌套表示可以在if语句块中添加if判断

语法：

if 条件表达式1 {
    if 条件表达式2 {
        // 当条件表达式2为true时执行
    } else {
        // 当条件表达式2为false时执行
    }
} else {
    // 当条件表达式1为false时执行
}

代码示例：

package main

import "fmt"

func main() {
  score := 90
  if score >= 90 {
    if score >= 95 {
      fmt.Println("非常优秀")
    } else {
      fmt.Println("优秀")
    }
  } else {
    fmt.Println("一般")
  }
}

score = 90，则第一层if判断score >= 90为true，则进入到第一层if语句块中，在第一层语句块中score >= 95为false，则执行else中的代码，最后输出为优秀。

运行结果：

if嵌套也可以无限制的嵌套，但是在实际开发中同样不建议嵌套太多层。

1.4 switch

switch语句是根据变量的值执行不同的case，在执行的过程中，会从第一个case开始判断，直到碰到一个符合条件的case为止，然后执行该case中的语句，不同于java的是不需要在每一个case中添加break语句，go语言默认情况下case后面自带break语句。

语法：

switch 变量 {
    case 变量1:
        // 当变量和变量1相等时执行
    case 变量2:
        // 当变量和变量2相等时执行
    default:
        // 当没有符合的case时执行
}

代码示例：

package main

import "fmt"

func main() {
  score := 80
  switch score {
    case 90:fmt.Println("优秀")
    case 80:fmt.Println("良好")
    case 70:fmt.Println("一般")
    default:fmt.Println("默认")
  }
}

运行结果：

switch的变量可以时任意类型，而case的变量可以是相同类型的任意值，类型不局限，但是switch和case的类型必须时相同的类型，同样case还可以为表达式。

代码示例：

package main

import "fmt"

func main() {
  score := 80
  switch {
    case score >= 90:fmt.Println("优秀")
    case score >= 80:fmt.Println("良好")
    case score >= 70:fmt.Println("一般")
    default:fmt.Println("默认")
  }
}

当case为表达式时，则switch中就不需要再写变量。

运行结果：

1.4.1 fallthrough

由于在go语言中每一个case后面都会默认加上break，所以每次匹配都执行其中的一个case，但是如果需要执行后面的case，则可以使用fallthrough，使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

代码示例：

package main

import "fmt"

func main() {
  score := 80
  switch {
    case score >= 90:
      fmt.Println("优秀")
      fallthrough
    case score >= 80:
      fmt.Println("良好")
      fallthrough
    case score >= 70:
      fmt.Println("一般")
      fallthrough
    default:fmt.Println("默认")
  }
}

由于在每个case后面都增加了fallthrough，则当case score >= 80匹配时，除了执行该case中的语句外，还会直接之后它后面的所有case，并且不会判断case是否为true。

运行结果：

2 循环

循环语句是一个编程语言中不可缺少的一部分，循环通常用来完成具有规律性的重复性的操作，例如通过循环计算1到100的累加或者累乘。

for循环是一个循环控制语句，在go语言中，for循环一共有三种方式

2.1 第一种

语法：

for init; condition; post {
    // 循环执行的语句
}

在这种循环方式中，可指定循环的次数。

init：赋值表达式，用于给控制变量赋初值

condition：条件表达式，用于控制循环

post：赋值表达式，用于给控制变量做增量或减量

循环执行步骤：

1. 通过init给控制变量赋值
2. 判断condition是否为true，如果为true则执行循环体内的代码
3. 循环体内的代码执行完之后通过post对控制变量进行增量或减量
4. 返回第2步继续判断，然后第2、3步持续循环，知道condition为false时跳出循环

代码示例：

package main

import "fmt"

func main() {
    // 计算从1到100的累加结果
  var sum int
  for i := 1; i <= 100; i++ {
    sum += i
  }
  fmt.Println("1到100累加结果为：", sum)
}

运行结果：

2.2 第二种

在第一种循环的基础上，init和post不是必须存在，可以没有init或者没有post，或者两个都没有都可以，

语法：

for condition {
  // 循环执行的语句
}

代码示例：

package main

import "fmt"

func main() {
    // 计算1到10累乘结果
  var sum int = 1
  i := 1
  for i <= 10 {
    sum *= i
    i++
  }
  fmt.Println("1到10累乘结果为：", sum)
}

还有一种特殊的循环就是无限循环，无限循环就是表示没有终止条件的循环，这样for循环体中的代码就会无休止的一直执行，在实际开发中要注意避免无限循环情况的发生。

package main

import "fmt"

func main() {
    sum := 0
    for {
        sum++       // 无限循环累加
    }
    fmt.Println(sum)   // 无法输出
}

2.3 第三种

第三种循环是用于数组、切片等输出的循环，在这种循环中，需要使用到一个关键字range，range后面紧跟的是需要遍历的数组或切片，range前面可以使用两个变量进行接收数据，第一个变量会接收到数组或切片的下标，第二个变量会接收到数组或切片的值，在循环的过程中，会把数组或切片中的下标和值依次一个个取出来赋值给index和value。

语法：

for index, value := range variable {
    // 循环体
}

代码示例：

package main

import "fmt"

func main() {
  numbers := [9]int {1,2,3,4,5,6,7,8,9}
  for i, v := range numbers {
    fmt.Printf("第%d个数是：%d \n", i, v)
  }
}

运行结果：

由于数组和切片的下标是从0开始的，所以第一行显示的是第0个数。

tips：数组和切片后面会详细介绍

2.4 break

break语句的作用是在循环中跳出循环，或者在switch中执行一个case后跳出swit。

代码示例：

package main

import "fmt"

func main() {
  sum := 1
  for {
    sum++
    if sum > 10 {
      break
    }
  }
  fmt.Println(sum)    // 输出11
}

虽然这里使用的for循环是一个死循环，但是在循环体内进行了判断，当sum的值大于10的时候就跳出循环，所以该循环不会无休止的执行下去，而是会在sum加到11时就跳出循环。

2.5 continue

continue和break用法类似，但是和break直接跳出循环不一样的是，continue并不是直接跳出循环，而是结束本轮循环，执行post对控制变量进行增量或减量后进行下一轮循环。

代码示例：

package main

import "fmt"

func main() {
    // 计算1到100之间所有奇数的和
  var sum int
  for i := 1; i <= 100; i++ {
        // 当i取余2为0时，则表示当前数为偶数，不参与计算，通过continue跳出本轮循环开始下一轮循环
    if i%2 == 0 {
      continue
    }
    sum += i
  }
  fmt.Println("1到100之间奇数和为：", sum)
}

运行结果：

本文参与了SegmentFault 思否写作挑战赛活动，欢迎正在阅读的你也加入。