3 运算符

Go 内置运算符：

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符

算术运算符

运算符
+	相加
-	相减
*	相乘
/	相除
%	求余

注意：++和--是Go中单独的语句，而非运算符

关系运算符

运算符	描述
==	是否相等
！=	是否不相等
>	左边值是否大于右边值
>=	左边值是否大于等于右边值
<	左边值是否小于右边值
<=	左边值是否小于等于右边值

逻辑运算符

运算符	描述
&&	逻辑AND运算符
\|\|	逻辑OR运算符
！	逻辑NOT运算符

位运算符

位运算符 对整数在内存中的二进制位 进行操作

运算符	描述
&	参与运算的两数各对应的二进制位相与（两位均为1 才为1）
\|	参与运算的两数各对应的二进制位相或（两位有一个为1 就为1）
^	参与运算的两数各对应的二进制位相异或（两位相异则为1）
<<	左移n位，即乘以`2^n`
>>	右移n位，即除以`2^n`

赋值运算符

运算符	描述
=	将表达式的值赋给一个左值
+=	相加后在赋值
-=
*=
/=
%=
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
\|=	按位或后赋值
^=	按位异或后赋值

练习题

有一堆数字，如果除了一个数字以外，其他数字都出现了两次，那么如何找到出现一次的数字？
目前能想到的是暴力遍历：

4 流程控制

流程控制是每种语言控制逻辑走向和执行次序的重要部分
Go 中有if 和 for, 而switch 和 goto主要是为了简化代码、降低重复代码而生，属于扩展类的流程控制

if else分支结构

if 条件判断的基本写法

if 条件判断格式

if expr1{
    block1
}else if expr2{
    block2
}else {
    block3
}
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

  * ==注意：==Go 规定，`if`的**左括号**必须与`if expr`放于同一行；**右括号必须与下一个语句在同一行**

#### if 条件判断特殊写法

* 可以在 if 表达式前添加一个执行语句，再根据变量值判断

  * 示例：

  * ```go
    package main
    
    import "fmt"
    
    func main() {
    
    	if score := 65; score >= 90 {
    		fmt.Println("A")
    	} else if score > 75 {
    		fmt.Println("B")
    	} else {
    		fmt.Println("C")
    	}
    }

思考：区别可能就是作用域不同

for 循环结构

Go 语言中的所有循环类型都可以使用关键字 for 完成

基本格式：

1
2
3

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

当循环条件表达式 为true 时进行循环，直到为false
for 循环的 初始语句 可以被省略，但是分号必须要写
- for ;i<10;i++
for 循环的初始语句和结束语句都可以被省略, 此时不需要分号
- 类似于C中的关键词while
- for i<10

无限循环

1
2
3
for {
循环体
}
可以通过关键字break goto return panic强制退出循环

for range 键值循环

可以使用 for range 遍历数组、切片、字符串、map以及通道
- 数组、切片、字符串返回 索引和值
- map 返回键和值
- 通道只返回通道内的值

switch case

对大量值进行条件判断

i := 1
switch(i){
    case 1:
        block1
    case 2:
        block2
    default :
        block3
}
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

    

* Go 规定，只能有一个`default`分支

* 一个分支可以有多个值，多个case值使用逗号分开

* `case 1, 3, 5:`

* 分支可以使用表达式判断：

  * `case age<25:`

* `fallthrough`语法可以执行满足条件的 case 的下一个 case，为了兼容 C 中的case

  * ```go
    func switchDemo5() {
     	s := "a"
     	switch {
     	case s == "a":
     		fmt.Println("a")
     		fallthrough
     	case s == "b":
     		fmt.Println("b")
     	case s == "c":
     		fmt.Println("c")
     	default:
     		fmt.Println("...")
     	}
    }

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



### goto 跳转到指定标签

* `goto`通过标签进行代码间的无条件跳转
* 可以在快速跳出循环、避免重复退出上有一定的帮助
  * 

```go
func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")
}

break 跳出循环

结束for、switch、select 的代码块

可以在break语句后面添加标签：退出某个标签对应的代码块

标签必须定义在对应的for、switch、select 的代码块上

func breakDemo1() {
BREAKDEMO1:
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if j == 2 {
                break BREAKDEMO1
            }
            fmt.Printf("%v-%v\n", i, j)
        }
    }
    fmt.Println("...")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

      

### continue 继续下次循环

* continue 语句: 结束当前循环，开始下一次循环，仅限在`for`循环内使用

* 在`continue` 语句后添加标签时，表示开始标签对应的循环

  * ```go
    func continueDemo() {
    forloop1:
    	for i := 0; i < 5; i++ {
    		// forloop2:
    		for j := 0; j < 5; j++ {
    			if i == 2 && j == 2 {
    				continue forloop1
    			}
    			fmt.Printf("%v-%v\n", i, j)
    		}
    	}
    }

练习题

编写代码打印 99 乘法表

package main

import "fmt"

func main() {
    for i := 1; i <= 10; i++ {
        for j := 1; j <= 10; j++ {
            fmt.Printf("%d * %d = %d ", i, j, i*j)
        }
        fmt.Println()
    }
}