Skip to content

Latest commit

 

History

History

逻辑和判断语句

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
 
 

逻辑和判断语句

go 语言基本上继承了 c 语言的逻辑判断语句,但是仍有些不同,比如:

  • 在循环语句中,仅保留了 for 语句,do-while,while 均不支持,这也是满足了 go 小而美的原则 -- 单一功能仅保留一种方式。
  • break continue 后面添加 label 功能
  • switch 中 case 语句不会自动执行下一个 case,需要显示的使用 fallthrough,当然了在 select 中的 case,并没有 fallthrough 功能
  • switch 中 case 支持表达式列表
  • switch 增加 type 模式,让类型也可以作为选择的条件
  • 跟 c 语言最大的不同,增加了 select - case 功能。

if

go 语言中的控制语句基础语法:

if conditon {

} else if condition{

} else {
  
}
// 比如:

if a > 0 {
  println("a > 0")
}else if a < 12 {
  println("a > 0 并且 < 12")
}else {
  println("a > 12 或者是非正数")
}

go 语言推崇的控制语句是 “快乐路径”:

  • 当出现错误时,直接返回
  • 成功的逻辑不要放在 if 语句中
  • 返回值通常在此函数的最后一行
err, value := handle()

if err != nil {
  return err
}

return value

for

for 循环的基础语言和 c 类似,for range 语句中,range 后面接数组,指向数组的指针,切片,字符串,和拥有读权限的 channel

for i:= 0;i< 10;i++ {}

for k,v := range sliceValue{}

其中普通循环语句中,i 值属于整个 loop 所有,这一点需要好好注意,我们在作用域那一章节中也提到过。

for-range 语句中,有两点需要注意,首先跟普通循环一样,变量属于整个 loop 所有。

其次,k,v 变量是切片或者 map 的 index 和 value 复制体,当遇到比如 slice 更改数据的时候,切勿直接更改 k v,可使用 arr[k] = v+1 这种方式直接改变切片本身,另外,当使用 for-range 语句时,如果第二个变量没有使用的价值,可以不写,并且无需使用占位符 _

for k := range sliceValue{}

// 如果是省略第一个,那么还是需要占位符的


for _,v := range sliceValue{}

切片在运行时,len 是会变化的,因为确定切片的 len 是 runtime 的责任,而数组的 len 是在编译期确定的,for - range 后面的数组或者切片,真正处理的其实是这个数据的复制,下面看一个 bug

	a := []int{1, 2, 3, 4, 5}
	var number int
	for i := range a {
		number++
		if i == 0 {
			a = append(a, 6, 7)
		}
	}
	println(number) // 5

这里 number 输出的是 5,因为我们 append 添加的长度是原切片的长度,但是循环体中存储的 len,还是最初的长度 5,所以只能循环 5 次。

for-range 中还有一个容易出 bug 的事情,比如 range 后面跟一个数组,因为 range 的时候实际上是数组的复制品,看下面这段代码:

package main

import "fmt"

func main() {
	var a = [5]int{1, 2, 3, 4, 5}
	var r [5]int
	fmt.Println(a)

	for i, v := range a {
		if i == 0 {
			a[1] = 12
			a[2] = 13
		}
		r[i] = v
	}

	fmt.Println(r, a)

}

本来期望的 r 值是 1 12 13 4 5,因为在 i == 0 时就更改了数组 a 的值,但是最终输出的却是 1 2 3 4 5,原因很简单,因为 v 读取的是 a 这个数组的复制品,也就是说,实际上这个代码的隐藏含义是 range a' 这里的 a' 就是 a 的复制品,所以更改了 a,a 的复制品也不会被改变,解决方法就是取这个数组的切片就可以了,这样即便是复制了,也只是复制了一份儿指针而已。

string

如果 for-range 中后面接的是 string,每次迭代不是按照 byte 来进行的,而是按照 rune 来进行,比如 "你好" 每次的迭代输出的就是你和好,而不是 byte

map

for range 后面是 map 时,无法保证 map 的输出顺序,但是 map 和 slice 一样都是胖指针,所以时可以对 map 进行直接操作的。如果在循环体中新创建一个 map 项,那么这个项目在 range 时有可能会被输出,不能保证一定。

channel

channel 的本质也是一个胖指针,所以它也可以直接被操作本体,channel 在 range 时是阻塞式的读取,如果不关闭 channel,这个 range 会一直阻塞。

var c chan int

for v := range c {

}

这段代码就会造成一直阻塞,进而触发系统的 Panic

switch && select

在 go 语言的 switch 和 select 的 case 中,我们经常会使用 break 来跳出循环,默认跳出的就是最小的那个循环单位,比如下面这个例子

func a(){
  for {
    select {
      case <- time.After(time.Second):
      break
    }
  }
}

这段代码是有 bug 的,因为它无法跳出 for 这层循环,只能跳出 select 这里。那么我们该怎么做呢?这个时候应该使用 label 了,所谓 label 就是标签的意思,意思就是指定好了 break 的位置,它的作用就是这个。

func a(){
  Now:
  for {
    select {
      case <- time.After(time.Second):
      break Now
    }
  }
}

这个时候就可以 break 到 Now 指定的层级了。

我们应避免使用 fallthrough 来执行多条件表达式,比如这样的代码

switch v.(type){
  case int: fallthrough
  case int8: fallthrough
    println("yes")
}

这种代码也很烂,我们可以直接使用多个 case 并列的方式:

package main

func main() {
	var i int16 = 12
	a(i)
}

func a(v any) {
	switch v.(type) {
	case int, int8:
		println("yes")
	default:
		println("no")
	}
}

这段代码使用的就是判断 type 的断言模式,固定用法就是 value.(type) 前面是要判断的 value,后面是固定用法 type,必须是这个单词才行。

我再带你回忆一下普通的断言,a.(int) 除了在 switch 中的断言方式,普通的断言就跟这段代码是一致的,一个 any 类型 (interface {}) 后面跟具体的类型。

经过上面的初步介绍,接下来,我们深入看一下 for range 的一些底层原理

汇总一下 for 和 for range 中最容易迷惑的几段代码

第一段代码:

func main() {
  arr := []int {1,2,3}
  for _,v :=  range arr {
    arr = append(arr,v)
  }
  fmt.Println(arr) 
}

这段代码 for 循环不会一直循环,原因是,arr 会在 range 一个复制一份儿,这个复制体的 len 在最初的 range 中的开头已经确定是 3,后面继续追加的 arr,并不会改变这个最初读取的 len == 3 这个结果。

不过,如果你使用的是传统的循环,那么这种写法就会出现 bug:

package main

import "fmt"

func main() {
	n := 12
	for i := 0; i < n; i++ {
		n++
		fmt.Println("i")
	}
}

使用这种传统的 for 循环,因为 n 在循环体和循环内部都是同一个,所以循环不会结束

因此你应该将这种代码改写为 for - range 模式:

go 1.22 增加了对于整数的 for range,之前只有 chan slice map,不过整数的 for range 前面只有一个变量,并且跟其他 for range 一致,n 为复制值,并且 for i := range n,i 也是复制值。这跟其他的 for range 保持一致

package main

import "fmt"

func main() {
	n := 12
	for range n {
		n++
		fmt.Println("i")
	}
}

第二段代码:

arr := []int{1,2,3}
result := [] *int{}
for ,v := range arr {
result = append(result, &v)
}

这段代码是存在 bug 的,&v,首先,根据作用域可知道,这个 v 是 loop 级作用域,那么这个 result 中存在的&v 就是同一个值,所以这个代码是错误的。

改正的方式就是放入正确的切片中数据的指针即可:

arr := []int{1,2,3}
result := [] *int{}
for k := range arr {
result = append(result, &arr[k])
}

第三段代码:

for i,_ := range result {

  result[i] = 0
}

这是一段对 int 切片进行归零的方法,很多人会觉得这要循环一次会非常浪费时间,其实不会,因为在编译器中,它不会真的循环,编译器会优化这个操作,直接给它内存清零。