Skip to main content

流程控制

if​

  1. 根据不同的条件执行不同的程序。
  2. Go语言中不推荐打括号。
  3. 判断的条件必须是bool表达式。

单条件判断​

/*
if 条件 => 程序
*/

Go语言中的语法为：

if 条件 {
 // 程序
}

多条件判断​

/*
if       条件 => 条件1
else if  条件 => 条件2
else if  条件 => 条件3
else     条件 => 条件4
*/

Go语言中的语法为：

if 条件 {
    // 程序
} else if 条件 {
    // 程序
} else {
    // 程序
}

if括号问题​

如果复杂的条件判断，要用括号括起来，如果外层也有括号，就显得很混乱，且没有必要性。

一般情况下，if条件判断给每个子条件打括号：

package main

import (
  "fmt"
)

func main() {
  x := 1
  y := 2  

  if (x >= 1) && (y == 2) {
    fmt.Println(x + y)
  }
}

if嵌套​

与其它编程语言类似，if可以嵌套：

package main

import "fmt"

func main() {
  x := 1
  y := 2

  if x >= 1 {
    if y == 2 {
      fmt.Println(x + y)
    }
  }
}

switch​

if常用在条件是范围、函数内部进行程序返回等情况下。

switch常用在条件是一个个固定值的时候：

switch 变量 {
  case 值1:
      程序1 
  case 值2:
      程序2 
  case 值3:
      程序3
  default:
      程序4 
}

break​

Go语言中switch不会主动穿透case，因此不需要在case内部使用break防止穿透case。

break会强制让程序跳出switch，并且当前case中break以下的代码都是无法访问的代码。

package main

import "fmt"

func main() {
  const a = 123
  switch a {
  case 123:
    break
    // 执行不到
    fmt.Println(a + 1)
  case 456:
    fmt.Println(a - 1)
  default:
    fmt.Println(a)
  }
}

fallthrough​

fallthrough可以穿透case，但只能穿透到下一个case。

package main

import "fmt"

func main() {
  const a = 123  
  switch a {
  case 123:
    fmt.Println(a + 1) // 124
    fallthrough
  case 456:
    fmt.Println(a - 1) // 122
  default:
    fmt.Println(a)
  }
}

case多值​

Go语言中，单个case条件可以匹配多个值。

package main

import "fmt"

func main() {
  const a = 789
  switch a {
  case 123, 789:
    fmt.Println(a + 1) // 790
  case 456:
    fmt.Println(a - 1)
  default:
    fmt.Println(a)
  }
}

case条件​

switch后面如果没有明确的变量，那么case则可以充当条件。

package main

import "fmt"

func main() {
  const a = 789  
  switch {
  case a > 790:
    fmt.Println(a + 1)
  case a < 788:
    fmt.Println(a - 1)
  default:
    fmt.Println(a) // 789
  }
}

for loop​

计步式循环，重复地执行某一段程序，以实现相应的功能。

三要素​

步数、循环条件、步数的操作。

for i := 0; i < 10; i++ {
  // 循环程序
}

如上，i为迭代变量，初始值为0，每次循环时检查i < 10，然后执行循环程序，接着进行步数操作，直到迭代完成。

for​

Go语言中，没有while和do...while循环，因为for循环可以代替它们。

package main

import "fmt"

func main() {
  /**
  i := 0
  while ( i < 10) {
    fmt.Println(i)
    i++
  }
  */    

  i := 0
  // for允许下面的写法，可以代替while循环
  for i < 10 {
    fmt.Println(i)
    i++
  }    

  // break
  for {
    if i >= 10 {
      break
    }    
    fmt.Println(i)
    i++
  }
}

break​

可使用break跳出一层循环：

package main

import "fmt"

func main() {
  i := 0  
  for {
    if i >= 10 {
      break
    }  
    fmt.Println(i)
    i++
  }
}

// 判断质数
isPrimNumber := true

for i := 2; i <= 100; i++ {
  for j := 2; j < i; j++ {
    if i%j == 0 {
      isPrimNumber = false
      break
    }
  }

  if isPrimNumber {
    fmt.Println(i)
  }

  isPrimNumber = true
}

continue​

continue可用来跳出本次循环：

package main

import "fmt"

func main() {
  for i := 0; i <= 100; i++ {
    if i % 2 == 1 {
      continue
    }
    fmt.Println(i)
  }
}

迭代与遍历​

  1. 对于一个数据集合，每一次按照顺序获取一个数据的过程叫做迭代。
  2. 对于一个数据集合，所有迭代的过程叫做遍历。
  3. 迭代是可以通过遍历实现的，所有迭代的过程加在一起就是遍历的过程。

有序与无序​

  1. 无序列表：键与键之间没有顺序。
  2. 有序列表：元素按照一定的顺序排列，具有其数据意义。

for range​

用于遍历有序集合，如字符串、数组、切片、Map、channel等。

如果元素是字符串，则遍历出来是其对应的ASCII码。

package main

import "fmt"

func main() {
  name := "hello,world. 你好"

  for index, element := range name {
    fmt.Printf("%d, %c\r\n", index, element)
  }
}

goto​

跳转到某个代码块。

package main

import "fmt"

func main() {
  aStr := "abc"
  bStr := "cdf"  
  for _, aCh := range aStr {
    for _, bCh := range bStr {
      if aCh == bCh {
        // return
      	goto hasRepeatedChar
      }
    }
  }

hasRepeatedChar:
  fmt.Println("有重复字符")
}

goto太过灵活，代码复用性及可维护性都有待考量，非必要情况下不建议使用。

Last updated on