SRE文档

深浅模式

1.Go语言中的流控制 ​

1.1go语言中的条件 ​

条件语句是用来判断给定的条件是否满足(表达式值是否为true或者false)，并根据判断的结果（真或假）决定执行的语句，go语言中的条件语句也是这样。

1.2go语言中的条件语句 ​

if ​

if语句：if语句由一个布尔表达式后紧跟一个或多个语句组成

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

注意：在go语言中布尔表达式不使用括号

go
package main

import "fmt"

func main() {
	a := 100
	b := 2000
	if a > b {
		fmt.Printf("a>b %v\n", a)
	} else {
		fmt.Printf("a<b %v\n", b)
	}
}
package main

import "fmt"

func main() {
	a := 100
	b := 2000
	if a > b {
		fmt.Printf("a>b %v\n", a)
	} else {
		fmt.Printf("a<b %v\n", b)
	}
}
go
package main

import "fmt"

func main() {
	if age := 20; age > 18 {
		fmt.Print("chengnian")
	} else {
		fmt.Print("no")
	}
package main

import "fmt"

func main() {
	if age := 20; age > 18 {
		fmt.Print("chengnian")
	} else {
		fmt.Print("no")
	}

注意：初始变量可以声明在布尔表达式里面，注意它的作用域,只能在条件语句打印

注意：不能使用0或非0表示真假

go
func test4(){
    a:=1
    if i {
        fmt.Printf("herer")
    }
    fmt.Printf("end")
}
func test4(){
    a:=1
    if i {
        fmt.Printf("herer")
    }
    fmt.Printf("end")
}

go语言if语句使用提示

1.不需要使用括号将条件包含起来

2.大括号{}必须存在，即使只有一行语句

3.左括号必须在if或else同一行

4.在if之后，条件语句之前，可以添加变量初始化语句，使用;进行分割

if嵌套 ​

  • 语法
go
if 布尔表达式1{
    // 在表达式1为true时执行
    if 布尔表达式2{
        // 在表达式2为true时执行
    }
}
if 布尔表达式1{
    // 在表达式1为true时执行
    if 布尔表达式2{
        // 在表达式2为true时执行
    }
}
go
func f4() {
	a, b, c := 1, 2, 3
	if a > b {
		if a > c {
			fmt.Printf("a最大")
		}
	} else {
		if b > c {
			fmt.Printf("b最大")
		} else {
			fmt.Printf("c最大")
		}
	}
}
func f4() {
	a, b, c := 1, 2, 3
	if a > b {
		if a > c {
			fmt.Printf("a最大")
		}
	} else {
		if b > c {
			fmt.Printf("b最大")
		} else {
			fmt.Printf("c最大")
		}
	}
}

if...else ​

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

  • 语法
go
if 布尔表达式 {
    /*在布尔表达式为true时执行*/
}else {
     /*在布尔表达式为false 时执行*/
}
if 布尔表达式 {
    /*在布尔表达式为true时执行*/
}else {
     /*在布尔表达式为false 时执行*/
}
go
func if_else() {
	a := 1
	b := 2
	if a > b {
		fmt.Printf("a>b: %v\n", "a>b")
	} else {
		fmt.Printf("a<b: %v\n", b)
	}
}
//或者

func if2() {
	var number int
	fmt.Printf("Please: number %v\n")
	fmt.Scan(&number)

	if number%2 == 0 {
		fmt.Printf("偶数")
	} else {
		fmt.Printf("奇数")
	}
}
func if_else() {
	a := 1
	b := 2
	if a > b {
		fmt.Printf("a>b: %v\n", "a>b")
	} else {
		fmt.Printf("a<b: %v\n", b)
	}
}
//或者

func if2() {
	var number int
	fmt.Printf("Please: number %v\n")
	fmt.Scan(&number)

	if number%2 == 0 {
		fmt.Printf("偶数")
	} else {
		fmt.Printf("奇数")
	}
}

go语言if语句使用提示

1.不需要使用括号将条件包含起来

2.大括号{}必须存在，即使只有一行语句

3.左括号必须在if或else同一行

4.在if之后，条件语句之前，可以添加变量初始化语句，使用;进行分割

if else嵌套 ​

if嵌套语句：可以在if或else if语句中嵌入一个或多个if或else if语句

  • 语法
go
if 布尔表达式1 {
	//do something
}else if 布尔表达式2{
	//do something else
}else{
    //catch-all or default
}
if 布尔表达式1 {
	//do something
}else if 布尔表达式2{
	//do something else
}else{
    //catch-all or default
}
go
func if_elseif() {
	score := 80
	if score >= 60 && score <= 70 {
		fmt.Printf("c")
	} else if score >= 70 && score <= 90 {
		fmt.Printf("B")
	} else {
		fmt.Printf("a")
	}
}
func if_elseif() {
	score := 80
	if score >= 60 && score <= 70 {
		fmt.Printf("c")
	} else if score >= 70 && score <= 90 {
		fmt.Printf("B")
	} else {
		fmt.Printf("a")
	}
}
go
// Monday  Tuesday  Wednesday Thursday Friday
func f3() {
	var c string
	fmt.Printf("请输入一个字符:")
	fmt.Scan(&c)

	if c == "M" {
		fmt.Printf("Monday")
	} else if c == "T" {
		fmt.Printf("请输入第二个字符：")
		fmt.Scan(&c)
		if c == "u" {
			fmt.Printf("Tuesday")
		} else {
			fmt.Printf("Thursday")
		}
	} else if c == "W" {
		fmt.Printf("wednesday")
	} else if c == "F" {
		fmt.Printf("Friday")
	}
}
// Monday  Tuesday  Wednesday Thursday Friday
func f3() {
	var c string
	fmt.Printf("请输入一个字符:")
	fmt.Scan(&c)

	if c == "M" {
		fmt.Printf("Monday")
	} else if c == "T" {
		fmt.Printf("请输入第二个字符：")
		fmt.Scan(&c)
		if c == "u" {
			fmt.Printf("Tuesday")
		} else {
			fmt.Printf("Thursday")
		}
	} else if c == "W" {
		fmt.Printf("wednesday")
	} else if c == "F" {
		fmt.Printf("Friday")
	}
}

switch ​

switch语句：switch语句用于基于不同条件执行不同动作。可以非常容易判断多个值的情况

  • 语法：case可以是表达式
go
switch var1 {
	case val1:
		...
	case val2:
		...
	default:
		...
}
switch var1 {
	case val1:
		...
	case val2:
		...
	default:
		...
}
go
func switchFunc() {
	grade := "A"
	switch grade {
	case "A":
		fmt.Printf("优秀")
	case "B":
		fmt.Printf("良好")
	default:
		fmt.Printf("一般")
	}
}
func switchFunc() {
	grade := "A"
	switch grade {
	case "A":
		fmt.Printf("优秀")
	case "B":
		fmt.Printf("良好")
	default:
		fmt.Printf("一般")
	}
}
go
func f5() {
	score := 90
    //不写条件，默认是bool值=true
	switch 【默认不写东西，是ture】{
	case score >= 90:
		fmt.Printf("假期")
	case score < 90 && score >= 80:
		fmt.Printf("学习")
	default:
		fmt.Printf("再学习")
	}
}
func f5() {
	score := 90
    //不写条件，默认是bool值=true
	switch 【默认不写东西，是ture】{
	case score >= 90:
		fmt.Printf("假期")
	case score < 90 && score >= 80:
		fmt.Printf("学习")
	default:
		fmt.Printf("再学习")
	}
}

fallthrough可以执行满足条件的下一个case

go
func fall() {
	a := 100
	switch a {
	case 100:
		fmt.Printf("100 %v \n")
		fallthrough
	case 200:
		fmt.Printf("200")
	case 300:
		fmt.Printf("300")
	}
}
func fall() {
	a := 100
	switch a {
	case 100:
		fmt.Printf("100 %v \n")
		fallthrough
	case 200:
		fmt.Printf("200")
	case 300:
		fmt.Printf("300")
	}
}

注意：

1.支持多条件匹配

2.不同的case之间不使用break分割，默认只会执行一个case

3，如果想要执行多个case，需要使用fallthrough关键字，也可用break终止

4，分支还可以使用表达式，例如：a>10

select ​

select语句：select语句类似switch语句，但是select会随机执行一个可运行的case.如果没有case可运行，它将阻塞，直到有case可运行

1.3go语言中循环语句 ​

go语言中的循环语句只有for循环，去除了while,do while循环，使用起来更加简洁（可以直接替换while和do while）

for ​

  • 语法：
go
for 初始语句; 条件表达式; 结束语句{
	循环体语句
}
for 初始语句; 条件表达式; 结束语句{
	循环体语句
}

注意：for表达式不用加括号

go
func forFunc() {
	for i := 1; i <= 10; i++ {
		fmt.Printf("i: %v\n", i)
	}
}
func forFunc() {
	for i := 1; i <= 10; i++ {
		fmt.Printf("i: %v\n", i)
	}
}

初始条件可以写到外面

go
func forFunc() {
	i := 1
	for ; i <= 10; i++ {
		fmt.Printf("i:%v\n", i)
	}
}
func forFunc() {
	i := 1
	for ; i <= 10; i++ {
		fmt.Printf("i:%v\n", i)
	}
}

初始条件和结束条件都可以省略

go
func f2() {
	i := 1 //初始条件
	for i <= 10 {
		fmt.Printf("i:%v\n", i)
		i++ //结束条件
	}
}
func f2() {
	i := 1 //初始条件
	for i <= 10 {
		fmt.Printf("i:%v\n", i)
		i++ //结束条件
	}
}

永真循环也叫死循环，类似其他语言中的while

for循环可以通过break,goto,return,panic语句强制退出循环

go
func f4() {
	for {
		fmt.Printf("一直运行中")
	}
}
func f4() {
	for {
		fmt.Printf("一直运行中")
	}
}

for range ​

Go语言中可以使用for range遍历数组、切片(即动态数组)、字符串、map(key:value)及通道(channel)。通过for range遍历的返回值有以下规律:

1.数组、切片、字符串返回索引和值

2.map返回键和值

3.通道(channel)只返回通道内的值。

在for range中，如果不需要index或者value,可以使用_（下划线）不接收

go
func forrFunc() {
	//数组
	var a = [5]int{1, 2, 3, 4, 5}
    //或者,索引值省略
	var a = [...]int{1, 2, 3, 4, 5}
	//i代表索引，v代表数组值
	for i, v := range a {
		fmt.Printf("i:%d,v:%v\n", i, v)
	}
    //或者
    for _, v := range a {
		fmt.Printf("v:%v\n", v)
	}
}
func forrFunc() {
	//数组
	var a = [5]int{1, 2, 3, 4, 5}
    //或者,索引值省略
	var a = [...]int{1, 2, 3, 4, 5}
	//i代表索引，v代表数组值
	for i, v := range a {
		fmt.Printf("i:%d,v:%v\n", i, v)
	}
    //或者
    for _, v := range a {
		fmt.Printf("v:%v\n", v)
	}
}
go
//切片，即动态数组
func sliceFunc() {
	//[]里面什么都不写
	var s = []int{1, 2, 3}
	for _, v := range s {
		fmt.Printf("v:%v\n", v)
	}
}
//切片，即动态数组
func sliceFunc() {
	//[]里面什么都不写
	var s = []int{1, 2, 3}
	for _, v := range s {
		fmt.Printf("v:%v\n", v)
	}
}
go
//map
func mapFunc() {
	// key:value
	m := make(map[string]string, 0)
	m["name"] = "tom"
	for key, value := range m {
		fmt.Printf("%v:%v", key, value)
	}
}
//map
func mapFunc() {
	// key:value
	m := make(map[string]string, 0)
	m["name"] = "tom"
	for key, value := range m {
		fmt.Printf("%v:%v", key, value)
	}
}
go
func forRange() {
	str := "abc"
	fmt.Println(len(str))
	for i := 0; i < len(str); i++ {
		fmt.Printf("str[%d]=%c\n", i, str[i])
	}
	fmt.Println("================")
	// range表示迭代打印每个元素，默认返回2个值：一个是元素的位置，一个是元素的值
	for k, v := range str { // k表示的是元素的位置（0,1,2）,v 表示的是元素对应的值（a,b,c）
		fmt.Printf("str[%d]=%c\n", k, v)
	}
	// 等同于
	for k := range str {
		fmt.Printf("str[%d]=%c\n", k, str[k])
	}
	/// 又等同于
	fmt.Println("=======。。。。。=========")
	for k := range str {
		fmt.Printf("str[%d]=%c\n", k, str[k])
	}
	fmt.Println("========______========")
	//
	// for _, v := range str { // 如果只想取到元素的值，可以用_来占位
	// 	fmt.Printf("%c\n", v)
	// }
}
func forRange() {
	str := "abc"
	fmt.Println(len(str))
	for i := 0; i < len(str); i++ {
		fmt.Printf("str[%d]=%c\n", i, str[i])
	}
	fmt.Println("================")
	// range表示迭代打印每个元素，默认返回2个值：一个是元素的位置，一个是元素的值
	for k, v := range str { // k表示的是元素的位置（0,1,2）,v 表示的是元素对应的值（a,b,c）
		fmt.Printf("str[%d]=%c\n", k, v)
	}
	// 等同于
	for k := range str {
		fmt.Printf("str[%d]=%c\n", k, str[k])
	}
	/// 又等同于
	fmt.Println("=======。。。。。=========")
	for k := range str {
		fmt.Printf("str[%d]=%c\n", k, str[k])
	}
	fmt.Println("========______========")
	//
	// for _, v := range str { // 如果只想取到元素的值，可以用_来占位
	// 	fmt.Printf("%c\n", v)
	// }
}