Go语句（5）

最新推荐文章于 2024-04-08 20:34:45 发布

watermelon_z

最新推荐文章于 2024-04-08 20:34:45 发布

阅读量187

点赞数

分类专栏： Go 文章标签： if语句 select语句 golang switch语句

本文链接：https://blog.csdn.net/watermelon_z/article/details/94558764

版权

Go 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

条件语句

if语句

if 语句由布尔表达式后紧跟一个或多个语句组成。（注意：Go 没有三目运算符，所以不支持 ?: 形式的条件判断）

Go语言中 if 语句的语法：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

package main

import (
	"fmt"
)

func main() {
	var a int = 10

	if a < 20 {
		fmt.Println("a 小于20")
	}
	fmt.Printf("a的值是：%d\n", a)
}
//输出结果：
a 小于20
a的值是：10

嵌套：Go语言也可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。语法：

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

package main

import (
	"fmt"
)

func main() {
	var a int = 100
	var b int = 200

	if a == 100 {
		if b == 100 {
			fmt.Println("a 的值为100，b的值为200")
		}
	}
	fmt.Printf("a 的值为：%d\n", a)
	fmt.Printf("b 的值为：%d\n", b)
}
//输出结果：
a 的值为：100
b 的值为：200

if...else语句

if 语句后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。

Go 语言中 if...else 语句的语法：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

（注意：Go语言中else后的左大括号与main函数一样要紧跟其后，不能另换一行）

package main

import (
	"fmt"
)

func main() {
	var a int = 20
	if a < 20 {
		fmt.Println("a 的值小于20")
	} else {
		fmt.Println("a 的值不小于20")
	}
	fmt.Printf("a 的值：%d\n", a)
}
//输出结果：
a 的值不小于20
a 的值：20

switch语句

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。

switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。

switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。

Go 语言中 switch 语句的语法：

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

Go语言中switch还有一些特点:

支持多条件匹配
不同的 case 之间不使用 break 分隔，默认只会执行一个 case。
如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止。

package main

import (
	"fmt"
)

func main() {
	var grade string = "B"
	var marks int = 90

	switch marks {
	case 90:
		grade = "A"
	case 80:
		grade = "B"
	case 70, 60, 50:
		grade = "c"
	default:
		grade = "D"
	}
	switch {
	case grade == "A":
		fmt.Println("优秀")
	case grade == "B", grade == "c":
		fmt.Println("良好")
	case grade == "D":
		fmt.Println("及格")
	case grade == "F":
		fmt.Println("不及格")
	default:
		fmt.Println("差")
	}
	fmt.Printf("你的等级是：%q\n", grade)
}
//输出结果：
优秀
你的等级是："A"

Type Switch语句

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。语法：

switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}

package main

import "fmt"

func main() {

	var x interface{}

	switch i := x.(type) {
	case nil:
		fmt.Printf("x 的类型：%T\n", i)
	case int:
		fmt.Println("x 是 int 类型")
	case float64:
		fmt.Println("x 是 float64类型")
	case func(int) float64:
		fmt.Println("x 是 func(int)类型")
	case bool, string:
		fmt.Println("x 是 bool或string型")
	default:
		fmt.Println("未知类型")
	}
}
//输出结果：
x 的类型：<nil>

fallthrough

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

package main

import (
	"fmt"
)

func main() {
	switch {
	case false:
		fmt.Println("1、case条件语句为：false")
		fallthrough
	case true:
		fmt.Println("2、case条件语句为：true")
		fallthrough
	case false:
		fmt.Println("3、case条件语句为：false")
		fallthrough
	case true:
		fmt.Println("4、case条件语句为：true")
	case false:
		fmt.Println("5、case条件语句为：false")
		fallthrough
	default:
		fmt.Println("6、默认 case")
	}
}
//输出结果：
2、case条件语句为：true
3、case条件语句为：false
4、case条件语句为：true

select语句

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

每个 case 都必须是一个通信
所有 channel 表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。
否则：
1. 如果有 default 子句，则执行该语句。
2. 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。

Go 语言中 select 语句的语法：

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

package main

import "fmt"

func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
      case i1 = <-c1:
         fmt.Printf("received ", i1, " from c1\n")
      case c2 <- i2:
         fmt.Printf("sent ", i2, " to c2\n")
      case i3, ok := (<-c3): 
         if ok {
            fmt.Printf("received ", i3, " from c3\n")
         } else {
            fmt.Printf("c3 is closed\n")
         }
      default:
         fmt.Printf("no communication\n")
   }    
}
//输出结果：
no communication

循环语句

for语句

Go语言的For循环有3中形式，只有其中的一种使用分号。

//和 C 语言的 for 一样：
for init; condition; post { }

//和 C 的 while 一样：
for condition { }

//和 C 的 for(;;) 一样：
for { }

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。

for key, value := range oldMap {
    newMap[key] = value
}

package main

import (
	"fmt"
)

func main() {
	var b int = 15
	var a int

	numbers := [6]int{1, 2, 3, 5}

	for a := 0; a < 10; a++ {
		fmt.Printf("a 的值为：%d\n", a)
	}
	for a < b {
		a++
		fmt.Printf("a 的值为：%d\n", a)
	}
	for i, x := range numbers {
		fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)
	}

}
//输出结果：
a 的值为：0
a 的值为：1
a 的值为：2
a 的值为：3
a 的值为：4
a 的值为：5
a 的值为：6
a 的值为：7
a 的值为：8
a 的值为：9
a 的值为：1
a 的值为：2
a 的值为：3
a 的值为：4
a 的值为：5
a 的值为：6
a 的值为：7
a 的值为：8
a 的值为：9
a 的值为：10
a 的值为：11
a 的值为：12
a 的值为：13
a 的值为：14
a 的值为：15
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

for嵌套

package main

import "fmt"

func main() {
  
   var i, j int

   for i=2; i < 100; i++ {
      for j=2; j <= (i/j); j++ {
         if(i%j==0) {
            break; 
         }
      }
      if(j > (i/j)) {
         fmt.Printf("%d  是素数\n", i);
      }
   }  
}

循环控制语句

break 语句

Go 语言中 break 语句用于以下两方面：

用于循环语句中跳出循环，并开始执行循环之后的语句。

break 在 switch（开关语句）中在执行一条case后跳出语句的作用。

package main

import "fmt"

func main() {

   var a int = 10

  
   for a < 20 {
      fmt.Printf("a 的值为 : %d\n", a);
      a++;
      if a > 15 {
        
         break;
      }
   }
}
//输出结果：
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15

continue 语句

Go 语言的 continue 语句有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

for 循环中，执行 continue 语句会触发for增量语句的执行。

package main

import "fmt"

func main() {
  
   var a int = 10

   
   for a < 20 {
      if a == 15 {
         a = a + 1;
         continue;
      }
      fmt.Printf("a 的值为 : %d\n", a);
      a++;     
   }  
}
//输出结果：
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19

goto 语句

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto 语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。

但是，在结构化程序设计中一般不主张使用 goto 语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。

Go语言中goto 语法：

goto label;
..
.
label: statement;

package main

import "fmt"

func main() {
  
   var a int = 10

   
   LOOP: for a < 20 {
      if a == 15 {
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++     
   }  
}
//输出结果：
a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19