Go学习第三章——运算符与进制

运算符是—种特殊的符号，用以表示数据的运算、赋值和比较等

ps：没有三元运算符

1 算术运算符

1. 算术运算符：+ ，-，*，/，%，++，–
2. 介绍：算术运算符是对数值类型的变量进行运算的，比如，加减乘除。
3. 细节说明：

• 当对一个数取模时，可以等价a%b=a-a/b*b，这样就是取模的本质运算
• Golang的自增自减只能当作一个独立的语言使用，不能这样使用b := a++或者b := a--
• Golang的++和–只能写在变量的后面，不能卸载变量的前面，即：只有a++ a--没有++a --a
• Golang的设计者去掉c/java中的自增自减容易混淆的写法，让Golang更加简洁，统一。

例子演示：

func main() {
	var i int = 8
	var a int

	//a = i++ // 错误
	//a = i-- // 错误
	// 下面这个做法也是错的
	/*if i++ >0 {
		fmt.Println("ok")
	}*/
	i++
	a = i
	fmt.Println("a的值：", a)

	//--i // 错误
	i--
	a = i
	fmt.Println("a的值：", a)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出：

a的值： 9
a的值： 8
1
2

课堂练习：

func main() {
	// 假如还有97天放假，问：xx个星期零xx天
	var days int = 97
	var week int = days / 7
	var day int = days % 7
	fmt.Printf("%d个星期零%d天\n", week, day)

	// 定义一个变量保存华氏温度
	// 华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100)，求出华氏温度对应的摄氏温度。
	var huashi float32 = 134.2
	var sheshi float32 = 5.0 / 9 * (huashi - 100)
	fmt.Printf("%v 对应的摄氏温度=%v \n", huashi, sheshi)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

13个星期零6天
134.2 对应的摄氏温度=19
1
2

2 关系运算符

1. 关系运算符:==,!=,>,<,> =，<=
2. 关系运算符的结果都是bool型，也就是要么是true，要么是false
3. 关系表达式经常用在流程控制中

例子演示：

func main() {
    fmt.Println(5 == 9) //判断左右两侧的值是否相等，相等返回true，不相等返回的是false， ==不是=
    fmt.Println(5 != 9) //判断不等于
    fmt.Println(5 > 9)
    fmt.Println(5 < 9)
    fmt.Println(5 >= 9)
    fmt.Println(5 <= 9)
}
1
2
3
4
5
6
7
8

输出：

false
true
false
true
false
true
1
2
3
4
5
6

3 逻辑运算符

逻辑运算符:&&(逻辑与/短路与)，||（逻辑或/短路或），!（逻辑非）

与逻辑：&& :两个数值/表达式只要有一侧是false，结果一定为false
也叫短路与：只要第一个数值/表达式的结果是false，那么后面的表达式等就不用运算了，直接结果就是false

或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true
也叫短路或：只要第一个数值/表达式的结果是true，后面的表达式等就不用运算，直接就是true -->提高运算效率

非逻辑：!:逻辑非运算符，!true就是false，!false就是true

例子演示：

func main() {
	var age int = 40
	fmt.Println("逻辑与(一边为false)：", age < 35 && age == 40)
	fmt.Println("逻辑与(一边为true)：", age > 35 && age > 40)
	fmt.Println("逻辑与(两边为true)：", age > 35 && age == 40)
	fmt.Println("逻辑与(两边为false)：", age > 35 && age < 40)
	fmt.Println()
	fmt.Println("逻辑或(一边为false)：", age < 35 || age == 40)
	fmt.Println("逻辑或(一边为true)：", age > 35 || age < 40)
	fmt.Println("逻辑或(两边为true)：", age > 35 || age == 40)
	fmt.Println("逻辑或(两边为false)：", age > 35 || age < 40)
	fmt.Println()
	// 短路，只要第一个数值为true，后面的表达式不用运算，直接就是true
	// 所以会发现输出的地方，并没有打印test
	fmt.Println("逻辑或(一边为true)：", age > 35 || test())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出：

逻辑与(一边为false)： false
逻辑与(一边为true)： false
逻辑与(两边为true)： true
逻辑与(两边为false)： false

逻辑或(一边为false)： true
逻辑或(一边为true)： true
逻辑或(两边为true)： true
逻辑或(两边为false)： true

逻辑或(一边为true)： true
1
2
3
4
5
6
7
8
9
10
11

4 赋值运算符

1. 赋值运算符:=,+=，-=，*=，/=,%=
2. 赋值运算符就是将某个运算后的值，赋给指定的变量。

例子演示：

func main() {
	var a int = 10
	var b int = 1

	fmt.Println("b+=a前，b=", b)
	b += a
	fmt.Println("b+=a后，b=", b)
	fmt.Println()
	fmt.Println("b-=a前，b=", b)
	b -= a
	fmt.Println("b-=a后，b=", b)
	fmt.Println()
	fmt.Println("b*=a前，b=", b)
	b *= a
	fmt.Println("b*=a后，b=", b)
	fmt.Println()
	fmt.Println("b/=a前，b=", b)
	b /= a
	fmt.Println("b/=a后，b=", b)
	fmt.Println()
	fmt.Println("b%=a前，b=", b)
	b %= a
	fmt.Println("b%=a后，b=", 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

输出：

b+=a前，b= 1
b+=a后，b= 11

b-=a前，b= 11
b-=a后，b= 1

b*=a前，b= 1
b*=a后，b= 10

b/=a前，b= 10
b/=a后，b= 1

b%=a前，b= 1
b%=a后，b= 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14

赋值运算符的特点：

1. 运算顺序从右往左
2. 赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值
3. 复合赋值运算符等价于下面的效果，比如：a+=3 等价于 a=a + 3

5 其他运算符

5.1 位运算符

5.2 跟指针有关的运算符

& ：返回变量的存储地址
*：取指针变量对应的数值

func main() {
    var age int = 18
    fmt.Println("age对应的存储空间的地址为：", &age) //age对应的存储空间的地址为： 0xc0000100b0
    var ptr *int = &age
    fmt.Println("ptr对应的存储空间的地址为：", ptr)
    fmt.Println("ptr这个指针指向的具体数值为：", *ptr)
}
1
2
3
4
5
6
7

输出：

age对应的存储空间的地址为： 0x980a0b8
ptr对应的存储空间的地址为： 0x980a0b8
ptr这个指针指向的具体数值为： 18
1
2
3

6 运算符的优先级

Go语言有几十种运算符，被分成十几个级别，有的运算符优先级不同，有的运算符优先级相同，请看下表。

逗号的优先级是最低，括号（后缀运算符）优先级最高

为了提高优先级，就加()括号

7 获取用户终端输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

有两种方式可以获取到键盘的输入：

**fmt.Scanln(a … interface{}) **在换行的时候停止，也就是获取一行的数据

**fmt.Scanf(format string, a … interface{}) **根据格式，把值传到变量里面

案例演示：

要求：可以从控制台接收用户信息，【姓名，年龄，薪水，是否通过考试】

方式一：使用fmt.Scanln()

func main() {
	var name string
	var age byte
	var sale float32
	var isPass bool
	//方式一：使用fmt.Scanln()
	// 注意：只用使用&name，才会影响到这个name的值
	fmt.Println("请输入姓名 ")
	// 当执行程序到这里，程序会停止在这里，等到用户输入，并回车
	fmt.Scanln(&name)

	fmt.Println("请输入年龄 ")
	fmt.Scanln(&age)

	fmt.Println("请输入薪水 ")
	fmt.Scanln(&sale)

	fmt.Println("请输入是否通过考试 ")
	// 如果你输入是，返回的会是bool类型的默认值，false
	fmt.Scanln(&isPass)

	fmt.Printf("名字是 %v，年龄是 %v，薪水是 %v，是否通过考试 %v 。", name, age, sale, isPass)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出：

请输入姓名
小智
请输入年龄 
18
请输入薪水 
11111
请输入是否通过考试 
true
名字是 小陈，年龄是 18，薪水是 11111，是否通过考试 true 。
1
2
3
4
5
6
7
8
9

方式二：使用fmt.Scanf()

func main() {
    var name string
    var age byte
    var sale float32
    var isPass bool
    //方式二：使用fmt.Scanf()，可以按照指定的格式输入
    fmt.Println("请输入你的姓名，年龄，薪水，是否通过考试，使用空格隔开")
    fmt.Scanf("%s %d %f %t", &name, &age, &sale, &isPass)
    fmt.Printf("名字是 %v，年龄是 %v，薪水是 %v，是否通过考试 %v 。", name, age, sale, isPass)
}
1
2
3
4
5
6
7
8
9
10

输出：

请输入你的姓名，年龄，薪水，是否通过考试，使用空格隔开
小智 18 11111 true
名字是 小智，年龄是 18，薪水是 11111，是否通过考试 true 。
1
2
3

8 进制转换

8.1 进制基本使用

对于整数，有四种表示方式：

1. 二进制：0,1 ，满 2 进 1。
   在 golang 中，不能直接使用二进制来表示一个整数，它沿用了 c 的特点。
2. 十进制：0-9 ，满 10 进 1。
3. 八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。
4. 十六进制：0-9 及 A-F，满 16 进 1. 以 0x 或 0X 开头表示。
   此处的 A-F 不区分大小写。

func main() {
    var num int = 5
    // 二进制输出
    fmt.Printf("num的二进制：%b \n", num)

    // 八进制
    var num8 int = 011
    fmt.Println("八进制011的十进制值：", num8)

    // 十六进制
    var num16 int = 0x11
    fmt.Println("十六进制011的十进制值：", num16)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

num的二进制：101
八进制011的十进制值： 9
十六进制011的十进制值： 17
1
2
3

8.2 进制之间的转换

略~~~~这里就不写了，网上大把！！

8.3 原码 反码 补码

略~~~~这里也不写了，网上大把！！

8.4 位运算符详解

& 按位与运算符

| 按位或运算符

^ 按位异或运算符

移位运算符

Golang中有2个移位运算符：>>、<< 右移和左移，运算规则：

右移运算符 >> ：低位溢出，符号位不变，并用符号位补溢出的高位

左移运算符 << ：符号位不变，低位补0

案例演示

func main() {
    a := 10 // 十进制10，二进制1010
    // 输出 10 << 1 = 20，10的二进制1010向左移1位是10100，即十进制的20
    fmt.Printf("%d << %d = %d\n", a, 1, a<<1)

    var b uint8 = 255 // 返回的类型是无符号整型 255的二进制是11111111
    // 输出 255 >> 1 = 127，11111111向右移动一位变成01111111，十进制为127
    fmt.Printf("%d >> %d = %d\n", b, 1, b>>1)
}
1
2
3
4
5
6
7
8
9

输出：

10 << 1 = 20
255 >> 1 = 127
1
2

第三章结束啦~~~冲冲冲，接着学！！！