GO语法笔记 条件与循环及函数｜青训营笔记

语句	描述
if 语句	if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
if...else 语句	if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句	你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句	switch 语句用于基于不同条件执行不同动作。
select 语句	select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。
（引用自菜鸟教程）

if语句

很简单，自己理解

package main

import (
	"fmt"
)

func main() {
	a := "noob"
	if a == "whoami" {
		fmt.Println("hack")
	} else if a == "noob" {
		fmt.Println("noob")
	} else {
		fmt.Println("Wrong")
	}
}

go还可以在条件内声明变量

package main

import (
	"fmt"
)

func main() {
	if num := 114; num < 514 {
		fmt.Println("好臭！")
	} else {
		fmt.Println("鉴作赞赏！")
	}
}

Switch语句

语法如下：

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

使用起来跟C语言大同小异

package main

import "fmt"

func main() {
	var date int = 6
	switch date {
	case 0:
		fmt.Println("今天是星期一")
	case 1:
		fmt.Println("今天是星期二")
	case 2:
		fmt.Println("今天是星期三")
	case 3:
		fmt.Println("今天是星期四")
	case 4:
		fmt.Println("今天是星期五")
	case 5:
		fmt.Println("今天是星期六")
	case 6:
		fmt.Println("今天是星期日")
	default:
		fmt.Println("你的输入有误！")
	}
}

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", i)
	case int:
		fmt.Printf("x 是 int 型")
	case float64:
		fmt.Printf("x 是 float64 型")
	case func(int) float64:
		fmt.Printf("x 是 func(int) 型")
	case bool, string:
		fmt.Printf("x 是 bool 或 string 型")
	default:
		fmt.Printf("未知型")
	}
}

select语句

不是sql哦~

select 是 Go 中的一个控制结构，类似于 switch 语句。 select 语句只能用于通道操作，每个 case 必须是一个通道操作，要么是发送要么是接收。 select 语句会监听所有指定的通道上的操作，一旦其中一个通道准备好就会执行相应的代码块。 如果多个通道都准备好，那么 select 语句会随机选择一个通道执行。如果所有通道都没有准备好，那么执行 default 块中的代码。 （搬运自菜鸟教程） 首先要理解一个go通道的概念

通道概念

Go语言中的通道（Channel）是用于在 Goroutine 之间进行通信和同步的一种机制。通道充当了 Goroutine 之间传递数据的管道，类似于管道操作系统中的管道概念 新建一个通道

ch := make(chan 数据类型)

把数据发送给通道

ch <- data   // 将 data 发送到通道 ch
data := <-ch // 从通道 ch 接收数据，并赋值给变量 data

引入生产者消费者模型

package main

import (
	"fmt"
	"time"
)

// func main() {
// ch := make(chan int)
// ch <- 114514 // 将 data 发送到通道 ch
// data := <-ch    // 从通道 ch 接收数据，并赋值给变量 data
// fmt.Println(ch) // 会输出内存地址 0
// }

// 生产者
func producer(ch chan<- int) {
	for i := 1; i <= 5; i++ {
		fmt.Println("生产者发送数据：", i)
		ch <- i // 发送到通道
		time.Sleep(500 * time.Millisecond)
	}
	close(ch) // 关闭通道
}

// 消费者
func consumer(ch <-chan int) {
	for num := range ch { // 从通道接收数据
		fmt.Println("消费者接收数据：", num)
		time.Sleep(1 * time.Second)
	}
}

func main() {
	ch := make(chan int)        // 创建一个通道
	go producer(ch)             // 启动生产者的Goroutine（）
	go consumer(ch)             // 启动消费者的Goroutine
	time.Sleep(5 * time.Second) // 等待一段时间，等他们互相完成
	fmt.Println("模型模拟结束")
}

接下来开始介绍go的select

package main

import (
	"fmt"
	"time"
)

func main() {
	c1 := make(chan string)
	c2 := make(chan string)

	go func() {
		time.Sleep(1 * time.Second)
		c1 <- "one"
	}()

	go func() {
		time.Sleep(1 * time.Second)
		c2 <- "one"
	}()
	for i := 0; i < 2; i++ {
		select {
		case msg1 := <-c1: // 通道传数据给msg1
			fmt.Println("received", msg1) // 会输出one
		case msg2 := <-c2:
			fmt.Println("received", msg2)
		}

	}
}

go的循环

非常简单，和C语言语法差不多 和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

简简单单实现一个小九九

package main

import "fmt"

func main() {
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Print(j, "x", i, "=", (i * j), " ")
		}
		fmt.Println()
	}
}

For-each range 循环

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

package main

import "fmt"

func main() {
	strings := []string{
		"google", "icecliffs", "baidu", "ryu1nser",
	}
	for i, s := range strings {
		fmt.Println(i, s)
	}
	numbers := [6]int{1, 3, 5, 7}
	for i, x := range numbers {
		fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)
	}
}

for 循环的 range 格式可以省略 key 和 value，如下实例：

package main

import "fmt"

func main() {
	map1 := make(map[int]float32)
	map1[1] = 1.0
	map1[2] = 2.0
	map1[3] = 3.0
	map1[4] = 4.0
	map1[5] = 5.0
	for key, value := range map1 {
		fmt.Printf("key is: %d - value is: %f\n", key, value)
	}
	fmt.Println("输出key")
	// 单独读取key
	for key := range map1 {
		fmt.Printf("key is: %d\n", key)
	}
	fmt.Println("输出value")
	// 单独读取value
	for value := range map1 {
		fmt.Printf("value is: %d\n", value)
	}
}