Golang 学习笔记 - 流程控制

2021-05-13 16:34:05 阅读：100 来源： 互联网

标签：case 语句 temp 流程笔记 Golang len main fmt

if-else 结构

关键字 if 和 else 之后的左大括号 { 必须和关键字在同一行，如果你使用了 else-if 结构，则前段代码块的右大括号 } 必须和 else-if 关键字在同一行。这两条规则都是被编译器强制规定的。

// 非法代码

if condition{

}
else {  // 无效的
}

在有些情况下，条件语句两侧的括号是可以被省略的；当条件比较复杂时，则可以使用括号让代码更易读。条件允许是符合条件，需使用 &&、|| 或！，你可以使用括号来提升某个表达式的运算优先级，并提高代码的可读性。

package main
import "fmt"

func main() {
    bool1 := true
    if bool1 {
        fmt.Printf("The value is true\n")
    } else {
        fmt.Printf("The value is false\n")
    }
}

当 if 结构内有 break、continue、goto 或者 return 语句时，Go 代码的常见写法是省略 else 部分。无论满足哪个条件都会返回 x 或者 y 时，一般使用以下写法：

if condition {
    return x
}
return y

获取操作系统信息

package main

import (
	"fmt"
	"runtime"
)

func main() {
	os := runtime.GOOS
	if os == "windows"     {
		fmt.Println("windows")
	} else if os == "linux" {
		fmt.Println("linux")
	} else {
		fmt.Println("darwin")
	}
}

switch 结构

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。前花括号 { 必须和 switch 关键字在同一行。

您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

switch var1 {
    case val1, val2:
        ...
    case val3:
        ...
    default:
        ...
}

一旦成功地匹配到某个分支，在执行完相应代码后就会退出整个 switch 代码块，也就是说您不需要特别使用 break 语句来表示结束。

因此，程序也不会自动地去执行下一个分支的代码。如果在执行完每个分支的代码后，还希望继续执行后续分支的代码，可以使用 fallthrough 关键字来达到目的。
使用了 fallthrough 关键字后不管下一个 case 语句有没有匹配成功都会执行，但是一个 fallthrough 只会执行下一个 case ，如果使用了 fallthrough，但是后面没有语句则会编译报错

package main

import "fmt"

func main() {
	i := 0
	switch i {
	case 0: fallthrough
	case 1:
		f1() // 当 i == 0 时函数也会被调用，此处如果还有 fallthrough 则后面 case 将被继续执行
	}
	case 2: f2()
}

func f1(){
	fmt.Println("this is f1")
}

func f2(){
	fmt.Println("this is f2")
}

switch 语句的第二种形式是不提供任何被判断的值（实际上默认为判断是否为 true），然后在每个 case 分支中进行测试不同的条件。当任一分支的测试结果为 true 时，该分支的代码会被执行。这看起来非常像链式的 if-else 语句，但是在测试条件非常多的情况下，提供了可读性更好的书写方式。

package main

import "fmt"

func main() {
	num := 7

	switch {
	case num < 0:
		fmt.Println("Number is negative")
	case num > 0 && num < 10:
		fmt.Println("Number is between 0 and 10")
	default:
		fmt.Println("Number is 10 or greater")
	}
}

// 打印：Number is between 0 and 10

switch 语句的第三种形式是包含一个初始化语句：

package main

import "fmt"

func main() {
	switch result := f1(); {
	case result < 0: fmt.Println("result < 0")
	case result > 0: fmt.Println("result > 0")
	default:
		fmt.Println("result = 0")
	}
}

func f1() int {
	return 1
}

for 结构

基于计数器的迭代

基本形式为：
for 初始化语句; 条件语句; 修饰语句 {}

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Printf("This is the %d iteration\n", i)
    }
}

基于条件判断的迭代

for 结构的第二种形式是没有头部的条件判断迭代（类似其它语言中的 while 循环），基本形式为：for 条件语句 {}。

您也可以认为这是没有初始化语句和修饰语句的 for 结构，因此 ;; 便是多余的了。

package main

import "fmt"

func main() {
    var i int = 5

    for i >= 0 {
        i = i - 1
        fmt.Printf("The variable i is now: %d\n", i)
    }
}

无线循环

条件语句是可以被省略的，如 i:=0; ; i++ 或 for { } 或 for ;; { }（;; 会在使用 gofmt 时被移除）：这些循环的本质就是无限循环。最后一个形式也可以被改写为 for true { }，但一般情况下都会直接写 for { }。

如果 for 循环的头部没有条件语句，那么就会认为条件永远为 true，因此循环体内必须有相关的条件判断以确保会在某个时刻退出循环。

想要直接退出循环体，可以使用 break 语句或 return 语句直接返回。

但这两者之间有所区别，break 只是退出当前的循环体，而 return 语句提前对函数进行返回，不会执行后续的代码。

无限循环的经典应用是服务器，用于不断等待和接受新的请求。

for-range 结构

它可以迭代任何一个集合，语法上很类似其它语言中 foreach 语句般形式为：
for ix, val := range coll { }

要注意的是，val 始终为集合中对应索引的值拷贝，因此它一般只具有只读性质，对它所做的任何修改都不会影响到集合中原有的值（如果 val 为指针，则会产生指针的拷贝，依旧可以修改集合中的原值）。一个字符串是 Unicode 编码的字符（或称之为 rune）集合，因此您也可以用它迭代字符串：

package main

import "fmt"

func main() {

	str := "Go is a beautiful language!"
	fmt.Printf("The length of str is: %d\n", len(str))
	for pos, char := range str {
		fmt.Printf("Character on position %d is: %c \n", pos, char)
	}
}

下面这段代码会造成死循环吗？

package main

import "fmt"

func main() {
 s := []int{1,2,3,4,5}
 for _, v:=range s {
  s =append(s, v)
  fmt.Printf("len(s)=%v\n",len(s))
 }
}

for range 源码

// The loop we generate:
//   for_temp := range
//   len_temp := len(for_temp)
//   for index_temp = 0; index_temp < len_temp; index_temp++ {
//           value_temp = for_temp[index_temp]
//           index = index_temp
//           value = value_temp
//           original body
//   }

不会死循环，for range其实是golang的语法糖，在循环开始前会获取切片的长度 len(切片)，然后再执行len(切片)次数的循环。

上面的代码会被编译器认为是

func main() {
 s := []int{1,2,3,4,5}
 for_temp := s
 len_temp := len(for_temp)
 for index_temp := 0; index_temp < len_temp; index_temp++ {
  value_temp := for_temp[index_temp]
  _ = index_temp
  value := value_temp
  // 以下是 original body
  s =append(s, value)
  fmt.Printf("len(s)=%v\n",len(s))
 }
}

代码运行输出

len(s)=6
len(s)=7
len(s)=8
len(s)=9
len(s)=10

标签：case,语句,temp,流程,笔记,Golang,len,main,fmt
来源： https://blog.csdn.net/qq_35953955/article/details/116755149

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9