Go中的逻辑处理(if,switch),for循环

Go中的逻辑处理

if 语句

package main

import "fmt"

func main() {
	if stu != nil {
		//如果逻辑表达式成立,则执行这的代码
	}

	for i := 0; i < 100; i++ {
		if i > 98 {
			fmt.Println("hello")
		}
	}

	for i := 0; i < 3; i++ {
		//逻辑表达式中可以有变量或者常量
		//if句子中云粗包含一个分号
		//常见的if语句的形式
		/**
		if 条件表达式{
		}
		或者
		if 初始化变量;条件{
		}
		*/
		if c, d, e := 10, 12, 15; c < d && e > d {
			fmt.Println("条件成立")

		} else if i < 69 {
			fmt.Println("条件不成立")
		} else {
			fmt.Println("条件不成立")
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

1,逻辑表达式中可以有变量或者常量
if句子中云粗包含一个分号常见的if语句的形式
/**
if 条件表达式{
}
或者
if 初始化变量;条件{
}
*/

注意:if所在行的大括号要跟if处在同一行,否则会报错:

在if中声明的局部变量只是作用在if这个判断逻辑里,

	for i := 0; i < 100; i++ {
		if i > 90 {
			fmt.Println("hello")
		}else if i<99{
			fmt.Println("hi")
		}
	}

1
2
3
4
5
6
7
8

//看一下时间的包中的函数:

func TimeTest() {

	now := time.Now()//2022-08-21 19:32:41.6640761 +0800 CST m=+0.001829201
	weekday := now.Weekday()//Sunday
	day := weekday.String()//Sunday

	hour:=time.Now().Hour()//19

	fmt.Println(now,weekday,day,hour)
}

1
2
3
4
5
6
7
8
9
10
11

switch语句

if可以嵌套,但是如果是多个判断条件,那么可以使用switch

func switchTest() {
	day := time.Now().Weekday().String()
	switch day {
	case "Sunday":
		fmt.Println("今天周日")
	case "Saturday":
	fmt.Println("今天周六")
	case "Monday", "TuesDay"://case后面可以跟多个值,只要有一个匹配就可以了
	default:
		fmt.Println("滚去上班")
	}

}
func main() {
		switchTest()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

switch -case-default 这个跟java类似;

switch 和case后面可以跟常量,变量,表达式,只要switch后面的数据类型跟case后面的数据类型相匹配就可以了;

switch 支不支持穿透呢?

上面的案例看到switch是不支持穿透的,

从上往下,只要找到成立的case,就不在执行后面的case了,所以为了提高亿点点性能,把大概率的情况放在前面

但是—>>

case里如果带了fallthrouth,则执行完本case之后还会去判断下一个case是否满足;

在switch type 语句中case字句不能使用fallthrough

func main() {
TimeDemo()
}

func TimeDemo(){
	t:=time.Now().Month().String()
	switch{
	case t=="September":
		fmt.Println("九月了")
	default:
		fmt.Println("还是夏天")
	}

	switch {
	case add(12,13)<30:
		fmt.Println("不符合条件")

	//case add(0,12):
		fmt.Println("不能同名呀")
		fallthrough
	case t=="August":
		fmt.Println("八月")
		fallthrough
	default:
		fmt.Println("如果switch后面无数据,则case后面可以接任意的常量,表达式的逻辑的判断")
	}

}

func add(a,b int) int{

	return a+b
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

switch 后面没有加条件时,我们可以将条件写在case后面

func main() {
	 TimeDemo()
}

func TimeDemo(){
	t:=time.Now().Month().String()
	switch{
	case t=="September":
		fmt.Println("九月了")
	default:
		fmt.Println("还是夏天")
	}

	switch {
	case add(12,13)<30:
		fmt.Println("不符合条件")
	//case add(0,12):
		fmt.Println("不能同名呀")
	case t=="August":
		fmt.Println("八月")
	default:
		fmt.Println("如果switch后面无数据,则case后面可以接任意的常量,表达式的逻辑的判断")
	}

}

func add(a,b int) int{

	return a+b
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

switch 来判断数据类型:

这里提示要求是左侧应该是接口类型的数据类型

查资料—>>
即下面这种方式:

	//这里用接口来声明
var str interface{}=10.889
1
2

接口之后再去深入学习,先简单了解下—

//switch判断数据类型
func switchType(){

	//这里用接口来声明
var str interface{}=10.889
	switch  str.(type){
	case int:
		fmt.Println("int")//这里已经被强制转换为int类型了,如果数据类型是int的话;
	case float64:
		fmt.Println("float64")
	default:
		fmt.Println("other type")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
	var a interface{}=64.0
	fmt.Println(square(a))
	
}

func square(a interface{}) interface{} {

	switch value := a.(type) {

	case int:
		return value * value
	case float64:
		return value * value
	default:
		return value
	}
}

//相当于已经强制转换了数据类型

func square2(a interface{}) interface{} {

	switch   a.(type) {

	case int:
		value:=a.(int)
		return value * value
	case float64:
		value:=a.(float64)
		return value * value
	default:
		value:=a.(byte)
		return value
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

for循环

fori

func forTest() {
	arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	for i := 0; i < len(arr); i++ {

		fmt.Println(arr[i])
	}

	var i = 0
	for i < len(arr) {
		fmt.Println(arr[i])
		i++
	}
	for i,con:= range arr{

		fmt.Println(arr[i],con)
	}
	for a,sum:=0,0;a<len(arr)&&sum<60;a++ {

		sum+=a
		fmt.Println(sum)
	}
}


func main() {
	forTest()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

关于for循环,

1. 初始化变量可以放在for()之外(上),后续操作可以放在for内部
2. 只有条件判断时可以不适用分号
3. 死循环for{}

for range

1,遍历数组或切片

//声明一个数组
	a := [...]int{1, 2, 3, 4}
	//遍历数组
	//方式1
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}
	//方式2
	for i, ele := range a {
		fmt.Println(i, ele)
		fmt.Println(a[i], ele)
	}
	//同理遍历切片
1
2
3
4
5
6
7
8
9
10
11
12
13

2,遍历string

	//声明一个string
	str := "床前明月光"
	//遍历string
	//这里应该把string转为数组
brr:=[]byte(str)
	for i := 0; i < len(brr); i++ {
		//这怎么输出呢？
		fmt.Println(brr[i])
	}
	for i, ele := range str {
		fmt.Println(i, ele)
	}
1
2
3
4
5
6
7
8
9
10
11
12

3,遍历map

//声明一个map
	var m map[string]string
	//实例化map
	m = make(map[string]string, 5)

	m = map[string]string{"hello": "你好", "hi": "你也好"}

	//遍历map
	for i := 0; i < len(m); i++ {
		//这里没法输出呀
	}
	//使用range  ----有点类似于java中iterator  不保证便利的顺序
	for key, value := range m {
		fmt.Println(key, m[key], value)
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4,遍历管道

//声明一个channel
	var ch chan string
	//实例化一个管道
	ch = make(chan string, 9)
	//管道中添加元素
	ch <- "1"
	ch <- "2"
	//关闭管道之后才能 用range遍历
	close(ch)
	for ele := range ch {
		fmt.Println(ele)
	}
	//这种方式不要求关闭管道
	for i := 0; i < len(ch); i++ {
		value := <-ch
		fmt.Println(value)
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

for range拿到的是数据的拷贝

continue 与break

package main

import "fmt"

func main() {

	arr := [5]int{1, 2, 3, 4, 5}
	breakTest(arr)

	var fast = [4][4]int{{1, 2, 3, 4}, {5, 4, 3, 2}, {6, 7, 8, 9}, {9, 8, 7, 6}}

	test(fast)
}
func breakTest(a [5]int) {

	for i := 0; i < len(a); i++ {
		fmt.Println(i, a[i])
		if i > 2 {
			continue //
		}
		fmt.Printf("next I %d\n", i+1)
	}

}

func test(a [4][4]int) {
	for i := 0; i < len(a[i]); i++ {
		if i%2==1 {
			break
		}
		for j := 0; j < len(a[j]); j++ {
			if j%2==0 {
				continue
			}

			fmt.Println(a[i][j])
		}
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

goto 与label

简单的goto 与label

func master() {
	var result int
	var i = 0
	goto LB1
LB1:
	i=i+999
	result = result + i
	fmt.Println(result)
}
1
2
3
4
5
6
7
8
9

结果 999

在if使用goto 和label:

func test() {

	var i int
	i = 100

	if i%2 == 0 {
		goto L1

	} else {
		goto L2
	}
L1:
	i = i + 19

L2:
	i = i - 1
	fmt.Println(i)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

猜一下结果---->>

100%20是成立的,所以跳到L1中执行,此时i=119 但是119%20是不成立的所以会执行L2,最后输出了 118

break continue 与lable 也可以结合使用:
我们来看一下在没有使用 label时,

func break_GOTO() {

//Lb:
	for i := 0; i < 100; i++ {

		for j := 0; j < 100; j++ {
			if j == 50 {
				fmt.Println(i)
				break //跳出循环到外层循环--本来break只能中断内存循环
			}
		}
		//continue Lb

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

此时代码输出结果:

可以看到并没有影响到 外层循环,那如果我想要在某一个条件下退出,那怎么办呢?

func break_GOTO() {

Lb:
	for i := 0; i < 100; i++ {

		for j := 0; j < 100; j++ {
			if j == 50 {
				fmt.Println(i)
				break Lb //跳出循环到外层循环--本来break只能中断内存循环
			}
		}
		//continue Lb

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

执行结果:

这个就像java中的 那一种形式 循环标签

//这是java代码
public class Demo {
 
    public static void main(String[] args) {
 outer:
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < 100; j++) {
                if(j==56){
                    break outer;
                }
                System.out.println(j);
            }
            System.out.println("测测试");
        }
        System.out.println("完成了");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17