《Go 语言第一课》课程学习笔记(十一)

这篇具有很好参考价值的文章主要介绍了《Go 语言第一课》课程学习笔记(十一)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

控制结构

if 的“快乐路径”原则

  • 针对程序的分支结构,Go 提供了 if 和 switch-case 两种语句形式;而针对循环结构,Go 只保留了 for 这一种循环语句形式。

if 语句

  • if 语句是 Go 语言中提供的一种分支控制结构,它也是 Go 中最常用、最简单的分支控制结构。它会根据布尔表达式的值,在两个分支中选择一个执行。
  • 虽然各种编程语言几乎都原生支持了 if 语句,但 Go 的 if 语句依然有着自己的特点:
    • 第一,和 Go 函数一样,if 语句的分支代码块的左大括号与 if 关键字在同一行上,这也是 Go 代码风格的统一要求,gofmt 工具会帮助我们实现这一点;
    • 第二,if 语句的布尔表达式整体不需要用括号包裹,一定程度上减少了开发人员敲击键盘的次数。而且,if 关键字后面的条件判断表达式的求值结果必须是布尔类型,即要么是 true,要么是 false。
    • 如果判断的条件比较多,我们可以用多个逻辑操作符连接起多个条件判断表达式,比如这段代码就是用了多个逻辑操作符 && 来连接多个布尔表达式:
      if (runtime.GOOS == "linux") && (runtime.GOARCH == "amd64") &&
      (runtime.Compiler != "gccgo") {
      	println("we are using standard go compiler on linux os for amd64")
      }
      
      《Go 语言第一课》课程学习笔记(十一),云原生,golang,学习,笔记
  • Go 语言的 if 语句还有其他多种形式,比如二分支结构和多(N)分支结构。多分支结构引入了 else if。

支持声明 if 语句的自用变量

  • 无论是单分支、二分支还是多分支结构,我们都可以在 if 后的布尔表达式前,进行一些变量的声明,在 if 布尔表达式前声明的变量,称为 if 语句的自用变量。顾名思义,这些变量只可以在 if 语句的代码块范围内使用。
  • 在 if 语句中声明自用变量是 Go 语言的一个惯用法,这种使用方式直观上可以让开发者有一种代码行数减少的感觉,提高可读性。同时,由于这些变量是 if 语句自用变量,它的作用域仅限于 if 语句的各层隐式代码块中,if 语句外部无法访问和更改这些变量,这就让这些变量具有一定隔离性,这样你在阅读和理解 if 语句的代码时也可以更聚焦。

if 语句的“快乐路径”原则

  • 从可读性上来看,单分支结构要优于二分支结构,二分支结构又优于多分支结构。那么显然,我们在日常编码中要减少多分支结构,甚至是二分支结构的使用,这会有助于我们编写出优雅、简洁、易读易维护且不易错的代码。
  • if 语句的“快乐路径(Happy Path)”原则
    • 仅使用单分支控制结构;
    • 当布尔表达式求值为 false 时,也就是出现错误时,在单分支中快速返回;
    • 正常逻辑在代码布局上始终“靠左”,这样读者可以从上到下一眼看到该函数正常逻辑的全貌;
    • 函数执行到最后一行代表一种成功状态。

Go 中的 switch 语句

认识 switch 语句

  • 除了 if 语句之外,Go 语言还提供了一种更适合多路分支执行的分支控制结构,也就是 switch 语句。
  • 在一些执行分支较多的场景下,使用 switch 分支控制语句可以让代码更简洁,可读性更好。
  • Go 语言中 switch 语句的一般形式:
    switch initStmt; expr {
    	case expr1:
    	// 执行分支1
    	case expr2:
    	// 执行分支2
    	case expr3_1, expr3_2, expr3_3:
    	// 执行分支3
    	case expr4:
    	// 执行分支4
    	... ...
    	case exprN:
    	// 执行分支N
    	default:
    	// 执行默认分支
    }
    
    • 首先看这个 switch 语句一般形式中的第一行,这一行由 switch 关键字开始,它的后面通常接着一个表达式(expr),这句中的 initStmt 是一个可选的组成部分。
    • 我们可以在 initStmt 中通过短变量声明定义一些在 switch 语句中使用的临时变量。
    • 接下来,switch 后面的大括号内是一个个代码执行分支,每个分支以 case 关键字开始,每个 case 后面是一个表达式或是一个逗号分隔的表达式列表。
    • 这里还有一个以 default 关键字开始的特殊分支,被称为默认分支。
    • 最后,我们再来看 switch 语句的执行流程。switch 语句会用 expr 的求值结果与各个 case 中的表达式结果进行比较,如果发现匹配的 case,也就是 case 后面的表达式,或者表达式列表中任意一个表达式的求值结果与 expr 的求值结果相同,那么就会执行该 case 对应的代码分支,分支执行后,switch 语句也就结束了。
    • 如果所有 case 表达式都无法与 expr 匹配,那么程序就会执行 default 默认分支,并且结束 switch 语句。
    • Go 先对 switch expr 表达式进行求值,然后再按 case 语句的出现顺序,从上到下进行逐一求值。在带有表达式列表的 case 语句中,Go 会从左到右,对列表中的表达式进行求值。

switch 语句的灵活性

  • C 语言中的 switch 语句对表达式类型有限制,每个 case 语句只可以有一个表达式。而且,除非你显式使用 break 跳出,程序默认总是执行下一个 case 语句。这些特性开发人员带来了使用上的心智负担。
  • 相较于 C 语言中 switch 语句的“死板”,Go 的 switch 语句表现出极大的灵活性,主要表现在如下几方面:
    • 首先,switch 语句各表达式的求值结果可以为各种类型值,只要它的类型支持比较操作就可以了。
      • C 语言中,switch 语句中使用的所有表达式的求值结果只能是 int 或枚举类型,其他类型都会被 C 编译器拒绝。
      • Go 语言就宽容得多了,只要类型支持比较操作,都可以作为 switch 语句中的表达式类型。比如整型、布尔类型、字符串类型、复数类型、元素类型都是可比较类型的数组类型,甚至字段类型都是可比较类型的结构体类型,也可以。
        type person struct {
        	name string
        	age int
        } 
        func main() {
        	p := person{"tom", 13}
        	switch p {
        	case person{"tony", 33}:
        		println("match tony")
        	case person{"tom", 13}:
        		println("match tom")
        	case person{"lucy", 23}:
        		println("match lucy")
        	default:
        		println("no match")
        	}
        }
        
    • 第二点:switch 语句支持声明临时变量。
    • 第三点:case 语句支持表达式列表。
    • 第四点:取消了默认执行下一个 case 代码逻辑的语义。

type switch

  • "type switch”这是一种特殊的 switch 语句用法:
    func main() {
    	var x interface{} = 13
    	switch x.(type) {
    	case nil:
    		println("x is nil")
    	case int:
    		println("the type of x is int")
    	case string:
    		println("the type of x is string")
    	case bool:
    		println("the type of x is string")
    	default:
    		println("don't support the type")
    	}
    }
    
    • switch 关键字后面跟着的表达式为 x.(type),这种表达式形式是 switch 语句专有的,而且也只能在 switch 语句中使用。这个表达式中的 x 必须是一个接口类型变量,表达式的求值结果是这个接口类型变量对应的动态类型。
    • 接着,case 关键字后面接的就不是普通意义上的表达式了,而是一个个具体的类型。这样,Go 就能使用变量 x 的动态类型与各个 case 中的类型进行匹配,之后的逻辑就都是一样的了。
  • Go 语言规范中明确规定,不带 label 的 break 语句中断执行并跳出的,是同一函数内 break 语句所在的最内层的 for、switch 或 select。

Go 的 for 循环

for 语句的经典使用形式

  • 主流编程语言都提供了对循环结构的支持,绝大多数主流语言,包括 C 语言、C++、Java 和 Rust,甚至连动态语言 Python 还提供了不止一种的循环语句,但 Go 却只有一种,也就是 for 语句。
  • Go 语言中 for 循环语句的经典形式:
    var sum int
    for i := 0; i < 10; i++ {
    	sum += i
    }
    println(sum)
    

《Go 语言第一课》课程学习笔记(十一),云原生,golang,学习,笔记文章来源地址https://www.toymoban.com/news/detail-671843.html

  • 图中①对应的组成部分执行于循环体(③ )之前,并且在整个 for 循环语句中仅会被执行一次,它也被称为循环前置语句。
    • 我们通常会在这个部分声明一些循环体(③ )或循环控制条件(② )会用到的自用变量,也称循环变量或迭代变量,比如这里声明的整型变量 i。
    • 与 if 语句中的自用变量一样,for 循环变量也采用短变量声明的形式,循环变量的作用域仅限于 for 语句隐式代码块范围内。
  • 图中②对应的组成部分,是用来决定循环是否要继续进行下去的条件判断表达式。
    • 和 if 语句的一样,这个用于条件判断的表达式必须为布尔表达式,如果有多个判断条件,我们一样可以由逻辑操作符进行连接。
    • 当表达式的求值结果为 true 时,代码将进入循环体(③)继续执行,相反则循环直接结束,循环体(③)与组成部分④都不会被执行。
  • 图中③对应的组成部分是 for 循环语句的循环体。
    • 如果相关的判断条件表达式求值结构为 true 时,循环体就会被执行一次,这样的一次执行也被称为一次迭代(Iteration)。
    • 在上面例子中,循环体执行的动作是将这次迭代中变量 i 的值累加到变量 sum 中。
  • 图中④对应的组成部分会在每次循环体迭代之后执行,也被称为循环后置语句。
    • 这个部分通常用于更新 for 循环语句组成部分①中声明的循环变量,比如在这个例子中,我们在这个组成部分对循环变量 i 进行加 1 操作。
  • Go 语言的 for 循环支持声明多循环变量,并且可以应用在循环体以及判断条件中:
    for i, j, k := 0, 1, 2; (i < 20) && (j < 10) && (k < 30); i, j, k = i+1, j+1,
    	sum += (i + j + k)
    	println(sum)
    }
    
    • 除了循环体部分之外,其余的三个部分都是可选的。
    • 虽然对前置语句或后置语句进行了省略,但经典 for 循环形式中的分号依然被保留着,这是 Go 语法的要求。
    • 当循环前置与后置语句都省略掉,仅保留循环判断条件表达式时,我们可以省略经典 for 循环形式中的分号。
    • 当 for 循环语句的循环判断条件表达式的求值结果始终为 true 时,我们就可以将它省略掉了。这个 for 循环就是我们通常所说的“无限循环”。

for range 循环形式

  • 针对像切片这样的复合数据类型,还有 Go 原生的字符串类型(string),Go 语言提供了一个更方便的“语法糖”形式:for range。
    var sl = []int{1, 2, 3, 4, 5}
    for i, v := range sl {
    	fmt.Printf("sl[%d] = %d\n", i, v)
    }
    
    • for range 循环形式与 for 语句经典形式差异较大,除了循环体保留了下来,其余组成部分都“不见”了。其实那几部分已经被融合到 for range 的语义中了。
    • 这里的 i 和 v 对应的是经典 for 语句形式中循环前置语句的循环变量,它们的初值分别为切片 sl 的第一个元素的下标值和元素值。
    • 隐含在 for range 语义中的循环控制条件判断为:是否已经遍历完 sl 的所有元素,等价于i < len(sl)这个布尔表达式。
    • 每次迭代后,for range 会取出切片 sl 的下一个元素的下标和值,分别赋值给循环变量 i 和 v,这与 for 经典形式下的循环后置语句执行的逻辑是相同的。
  • for range 语句也有几个常见“变种”:
    • 变种一:当我们不关心元素的值时,我们可以省略代表元素值的变量 v,只声明代表下标值的变量 i。
    • 变种二:如果我们不关心元素下标,只关心元素值,那么我们可以用空标识符替代代表下标值的变量 i。这里一定要注意,这个空标识符不能省略,否则就与上面的“变种一”形式一样了,Go 编译器将无法区分。
    • 变种三:如果我们既不关心下标值,也不关心元素值,可以将 i,v 都省略。

string 类型

  • for range 对于 string 类型来说,每次循环得到的 v 值是一个 Unicode 字符码点,也就是 rune 类型值,而不是一个字节,返回的第一个值 i 为该 Unicode 字符码点的内存编码(UTF-8)的第一个字节在字符串内存序列中的位置。
  • 使用 for 经典形式与使用 for range 形式,对 string 类型进行循环操作的语义是不同的。

map

  • map 就是一个键值对(key-value)集合,最常见的对 map 的操作,就是通过 key 获取其对应的 value 值。但有些时候,我们也要对 map 这个集合进行遍历,这就需要 for 语句的支持了。
  • 但在 Go 语言中,我们要对 map 进行循环操作,for range 是唯一的方法,for 经典循环形式是不支持对 map 类型变量的循环控制的。
  • for range 对于 map 类型来说,每次循环,循环变量 k 和 v 分别会被赋值为 map 键值对集合中一个元素的 key 值和 value 值。

channel

  • channel 是 Go 语言提供的并发设计的原语,它用于多个 Goroutine 之间的通信。
  • 当 channel 类型变量作为 for range 语句的迭代对象时,for range 会尝试从 channel 中读取数据,使用形式是这样的:
    var c = make(chan int)
    for v := range c {
    	// ...
    }
    
    • for range 每次从 channel 中读取一个元素后,会把它赋值给循环变量 v,并进入循环体。当 channel 中没有数据可读的时候,for range 循环会阻塞在对 channel 的读操作上。
    • 直到 channel 关闭时,for range 循环才会结束,这也是 for range 循环与 channel 配合时隐含的循环判断条件。

带 label 的 continue 语句

  • 日常开发中,出于算法逻辑的需要,我们可能会有中断当前循环体并继续下一次迭代的时候,也会有中断循环体并彻底结束循环语句的时候。针对这些情况,Go 语言提供了 continue 语句和 break 语句。
    • 如果循环体中的代码执行到一半,要中断当前迭代,忽略此迭代循环体中的后续代码,并回到 for 循环条件判断,尝试开启下一次迭代,这个时候我们可以使用 continue 语句来应对。
    • Go 语言中的 continue 在 C 语言 continue 语义的基础上又增加了对 label 的支持。
      • label 语句的作用,是标记跳转的目标。
        func main() {
        	var sum int
        	var sl = []int{1, 2, 3, 4, 5, 6}
        loop:
        	for i := 0; i < len(sl); i++ {
        		if sl[i]%2 == 0 {
        		// 忽略切片中值为偶数的元素
        		continue loop
        	}
        		sum += sl[i]
        	}
        	println(sum) // 9
        }
        
      • 在这段代码中,我们定义了一个 label:loop,它标记的跳转目标恰恰就是我们的 for 循环。也就是说,我们在循环体中可以使用 continue+ loop label 的方式来实现循环体中断。
      • 通常我们在这样非嵌套循环的场景中会直接使用不带 label 的 continue 语句。
      • 带 label 的 continue 语句,通常出现于嵌套循环语句中,被用于跳转到外层循环并继续执行外层循环语句的下一个迭代:
        func main() {
        	var sl = [][]int{
        		{1, 34, 26, 35, 78},
        		{3, 45, 13, 24, 99},
        		{101, 13, 38, 7, 127},
        		{54, 27, 40, 83, 81},
        	}
        outerloop:
        	for i := 0; i < len(sl); i++ {
        		for j := 0; j < len(sl[i]); j++ {
        			if sl[i][j] == 13 {
        				fmt.Printf("found 13 at [%d, %d]\n", i, j)
        				continue outerloop
        			}
        		}
        	}
        }
        

break 语句的使用

  • 无论带不带 label,continue 语句的本质都是继续循环语句的执行。但日常编码中,我们还会遇到一些场景,在这些场景中,我们不仅要中断当前循环体迭代的进行,还要同时彻底跳出循环,终结整个循环语句的执行。面对这样的场景,continue 语句就不再适用了,Go 语言为我们提供了 break 语句来解决这个问题。
  • 和 continue 语句一样,Go 也 break 语句增加了对 label 的支持。而且,和 continue 语句一样,如果遇到嵌套循环,break 要想跳出外层循环,用不带 label 的 break 是不够,因为不带 label 的 break 仅能跳出其所在的最内层循环。要想实现外层循环的跳出,我们还需给 break 加上 label。

for 语句的常见“坑”与避坑方法

  • 问题一:循环变量的重用
    • for range 形式的循环语句,使用短变量声明的方式来声明循环变量,循环体将使用这些循环变量实现特定的逻辑,但在使用的时候,可能会发现循环变量的值与“预期”不符。
    • 有时候循环变量在 for range 语句中仅会被声明一次,且在每次迭代中都会被重用。
  • 问题二:参与循环的是 range 表达式的副本
    • 在 for range 语句中,range 后面接受的表达式的类型可以是数组、指向数组的指针、切片、字符串,还有 map 和 channel(需具有读权限)。
      func main() {
      	var a = [5]int{1, 2, 3, 4, 5}
      	var r [5]int
      	fmt.Println("original a =", a)
      	for i, v := range a {
      	  if i == 0 {
      		a[1] = 12
      		a[2] = 13
      	  }
      	  r[i] = v
      	} 
      	fmt.Println("after for range loop, r =", r)
      	fmt.Println("after for range loop, a =", a)
      }
      
      • 每次迭代的都是从数组 a 的值拷贝 a’ 中得到的元素。
      • a’是 Go 临时分配的连续字节序列,与 a 完全不是一块内存区域。
      • 因此无论 a 被如何修改,它参与循环的副本 a’依旧保持原值,因此 v 从 a’中取出的仍旧是 a 的原值,而不是修改后的值。
    • 那么应该如何解决这个问题,让输出结果符合我们的预期呢?
      • 大多数应用数组的场景我们都可以用切片替代:
        func main() {
        	var a = [5]int{1, 2, 3, 4, 5}
        	var r [5]int
        	fmt.Println("original a =", a)
        	for i, v := range a[:] {
        		if i == 0 {
        			a[1] = 12
        			a[2] = 13
        		}
        		r[i] = v
        	} 
        	fmt.Println("after for range loop, r =", r)
        	fmt.Println("after for range loop, a =", a)
        }
        
      • 在 range 表达式中,我们用了 a[:]替代了原先的 a,也就是将数组 a 转换为一个切片,作为 range 表达式的循环对象。
      • 当进行 range 表达式复制时,我们实际上复制的是一个切片,也就是表示切片的结构体。表示切片副本的结构体中的 array,依旧指向原切片对应的底层数组,所以我们对切片副本的修改也都会反映到底层数组 a 上去。
      • 而 v 再从切片副本结构体中 array 指向的底层数组中,获取数组元素,也就得到了被修改后的元素值。
  • 问题三:遍历 map 中元素的随机性
    • 如果我们在循环的过程中,对 map 进行了修改,那么这样修改的结果是否会影响后续迭代呢?这个结果和我们遍历 map 一样,具有随机性。
    • 我们日常编码遇到遍历 map 的同时,还需要对 map 进行修改的场景的时候,要格外小心。

到了这里,关于《Go 语言第一课》课程学习笔记(十一)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 《Go 语言第一课》课程学习笔记(十二)

    在 Go 语言中,函数是唯一一种基于特定输入,实现特定任务并可返回任务执行结果的代码块(Go 语言中的方法本质上也是函数)。 在 Go 中,我们定义一个函数的最常用方式就是使用函数声明。 第一部分是 func,Go 函数声明必须以 func 开始。 第二部分是函数名。

    2024年02月11日
    浏览(49)
  • 《Go 语言第一课》课程学习笔记(五)

    Go 语言中有一个特殊的函数:main 包中的 main 函数,也就是 main.main,它是所有 Go 可执行程序的用户层执行逻辑的入口函数。 Go 程序在用户层面的执行逻辑,会在这个函数内按照它的调用顺序展开。 main 函数的函数原型非常简单,没有参数也没有返回值。 Go 语言要求:可执行

    2024年02月12日
    浏览(44)
  • C语言入门课程学习笔记-6

    本文学习自狄泰软件学院 唐佐林老师的 C语言入门课程,图片全部来源于课程PPT,仅用于个人学习记录 D,越界 C D 20 2 0 -1 A wrong 赋值越界 B str2[4]初始化为0元素 A wrong C AD strlen(s) ij j– 10 3 abc

    2024年04月28日
    浏览(36)
  • [Go]-Go语言第一课

    1-1 Go语言特点 1-2 Go语言优势与劣势 1-3 Linux下的安装 1-4 Linux下的环境变量 2-1 Go语言-工作区和GOPATH 2-2 Go语言-源码文件的分类和含义 2-34 Go语言-代码包的相关知识 3-1 go run 命令简介 goc2p项目地址:https://github.com/hyper-carrot/goc2p 用go编写了ds和pds,用以打印目录结构 3-4 go run 常用标

    2024年02月09日
    浏览(40)
  • Ubuntu学习---跟着绍发学linux课程记录(第一部分)

    Ubuntu的学习过程的笔记分为4个部分来记录: 1、Ubuntu学习—跟着绍发学linux课程记录(第1部分) 2、Ubuntu学习—跟着绍发学linux课程记录(第2部分) 3、Ubuntu学习—跟着绍发学linux课程记录(第3部分) 4、Ubuntu学习—跟着绍发学linux课程记录(第4部分) 视频链接: Ubuntu 21.04乌班

    2024年02月10日
    浏览(32)
  • 尚硅谷webpack课程学习笔记

    为什么需要使用打包工具? 开发时使用的框架、es6 语法 、less 等浏览器无法识别。 需要经过编译成浏览器能识别的css、js才可以运行。 打包工具可以帮我们编译,还可以做代码压缩、兼容处理、性能优化。 常见的打包工具有什么? vite、webpack、glup、grunt webapck最基本的使用

    2024年02月07日
    浏览(50)
  • 【学习笔记】黑马程序员Java课程学习笔记(更新至第12章---集合)

    Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言, 2009年Oracle甲骨文公司收购Sun公司。Java之父:詹姆斯·高斯林(James Gosling)。 Java可以在任意操作系统上运行,Windows、Mac、Linux。我们只需要在运行Java应用程序的操作系统上,安装一个与操作系统对应

    2024年02月07日
    浏览(46)
  • 《Kubernetes入门实战课》课程学习笔记(一)

    现在 Kubernetes 已经没有了实际意义上的竞争对手,它的地位就如同 Linux 一样,成为了事实上的云原生操作系统,是构建现代应用的基石。 现代应用是什么? 是微服务,是服务网格,这些统统要围绕着容器来开发、部署和运行。 使用容器就必然要用到容器编排技术,在现在只

    2024年02月17日
    浏览(72)
  • 《MySQL 实战 45 讲》课程学习笔记(四)

    索引的出现其实就是为了提高数据查询的效率,就像书的目录一样。 哈希表 哈希表是一种以键 - 值(key-value)存储数据的结构,我们只要输入待查找的值即 key,就可以找到其对应的值即 Value。 哈希的思路很简单,把值放在数组里,用一个哈希函数把 key 换算成一个确定的位

    2024年02月14日
    浏览(45)
  • 《Redis 核心技术与实战》课程学习笔记(一)

    为了保证数据的可靠性,Redis 需要在磁盘上读写 AOF 和 RDB,但在高并发场景里,这就会直接带来两个新问题: 一个是写 AOF 和 RDB 会造成 Redis 性能抖动; 另一个是 Redis 集群数据同步和实例恢复时,读 RDB 比较慢,限制了同步和恢复速度。 其实,一个可行的解决方案就是使用

    2024年02月12日
    浏览(55)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包