Go语言の运算符
本文介绍了Go语言的运算符
运算符的基本介绍
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等等
- 算术运算符
- 赋值运算符
- 比较运算符/关系运算符
- 逻辑运算符
- 位运算符
- 其他运算符
算数运算符
算术运算符是对数值类型的变量进行运算的，比如：加减乘除。在Go程序中使用的非常多
算术运算符的一览表
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | -4 | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除 | 5/5 | 1 |
| % | 取模（取余） | 7%5 | 2 |
| ++ | 自增 | a=2 a++ | a=3 |
| – | 自减 | a=2 a– | a=1 |
| + | 字符串相加 | “He” + “llo” | “Hello” |
案例演示
- 案例：演示算术运算符的使用。
+，-，*，/，%，++，–，重点讲解/、%
自增：++
自减：–
- 演示/的使用的特点
package main
import (
"fmt"
)
func main() {
//重点讲解 / 、%
//说明：如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
fmt.Println(10/4)
var n1 float32 = 10 / 4 //
fmt.Println(n1)
//如果我们希望保留小数部分，则需要有浮点数参与运算
var n2 float32 = 10.0 / 4
fmt.Println(n2)
}运行结果
2
2
2.5- 演示 % 的使用特点
package main
import (
"fmt"
)
func main() {
//演示 % 的使用
// 看一个公式 a % b = a - a / b * b
fmt.Println("10 % 3 =", 10 % 3)// =-1
fmt.Println("-10 % 3 = ", -10 % 3) // =-10-(-10)/3*3=-10-(-9)=-1
fmt.Println("10 % -3 = ", 10 % -3) // =1
fmt.Println("-10 % -3 = ", -10 % -3) //=-1
}运行结果
10 % 3 = 1
-10 % 3 = -1
10 % -3 = 1
-10 % -3 = -1- ++和–的使用
package main
import (
"fmt"
)
func main() {
//演示 ++ 和 -- 的使用
var i int = 10
i++ //等价 i = i + 1
fmt.Println("i=", i) //11
i-- //等价 i = i - 1
fmt.Println("i=", i) // 10
}运行结果
i= 11
i= 10算术运算符使用的注意事项
- 对于除号”/“，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如： x:=19/5, 结果是3
- 当对一个数取模时，可以等价 a%b=a-a/b*b, 这样我们可以看到 取模的一个本质运算。
- Golang的自增自减只能当作一个独立语言使用时，不能这样使用：
package main
import (
"fmt"
)
func main() {
//在Golang中，++ 和 -- 只能独立使用
var i int = 8
var a int
a = i++ //错误 i++只能独立使用
a = i-- //错误 i--只能独立使用
if(i++>0){
fmt.Println("ok")
}
}- Golang的++和–只能写在变量的后面，不能写在变量的前面，即：只有a++,a–；没有++a,–a
var i int = 1
i++
++i //错误，在Golang没有 前++
i--
--i //错误，在Golang没有 前--
fmt.Println("i=", i)- Golang的设计者去掉 c/java 中的自增自减的容易混淆的写法，让Golang更加简洁，统一。（强制性的）
课堂练习1
var i int = 1
i = i++
fmt.Println(i)
//问 结果是多少，为什么？
//上面的代码报错，因为i=i++编译不通过var i int = 10
if i++ > 10
fmt.Println("ok")
//问 结果是多少，为什么？
//上面的代码报错，因为i++ > 10编译不通过课堂练习2
- 假如还有97天放假，问:97天相当于几个星期零几天?
var day int = 97
var week int = 97 / 7
var day int = 97 % 7- 解答
package main
import (
"fmt"
)
func main() {
var day int = 97
var week int = day / 7
var aday int = day % 7
fmt.Println(week)
fmt.Println(aday)
}
/**打印结果：13 6 **/- 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。
package main
import (
"fmt"
)
func main() {
var huashi float32 = 134.2
var sheshi float32 = 5.0 / 9 * (huashi - 100)
fmt.Printf("%v 对应的摄氏温度=%v\n", huashi, sheshi)
}
/**134.2 对应的摄氏温度=19**/关系运算符（比较运算符）
基本介绍
- 关系运算符的结果都是bool型，也就是 要么是true，要么是false
- 关系表达式常用于if结构的条件中或循环结构的条件中
关系运算符一览图
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4==3 | false |
| != | 不等于 | 4！=3 | true |
| < | 小于 | 4<3 | false |
| > | 大于 | 4>3 | true |
| <= | 小于等于 | 4<=3 | false |
| >= | 大于等于 | 4>=3 | true |
案例演示
package main
import (
"fmt"
)
func main() {
//演示关系运算符的使用
varn1int=9
varn2int=8
fmt. Println(n1 == n2) //false
fmt. .Print1n(n1 != n2) //true
fmt .Print1n(n1 > n2) //true
fmt. .Print1n(n1 >= n2) //true
fmt .Print1n(n1 < n2) //flase
fmt .Println(n1 <= n2) //flase
flag:=n1>n2
fmt. Print1n(" flag=", f1ag)]
}
关系运算符的细节说明
- 关系运算符的结果都是bool型，也就是要么是true，要么是false。
- 关系运算符组成的表达式，我们称为关系表达式：a>b
- **比较运算符”==”不能误写成”=” **
逻辑运算符
基本介绍
用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个bool值
逻辑运算的说明
假定A值为true，B值为false
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑与运算符。如果两边的操作数都是true，则为true，否则为false | （A&&B)为false |
| || | 逻辑或运算符。如果两边的操作数有一个true,则为true，否则为false。 | （A||B）为true |
| ！ | 逻辑非运算符。如果条件为true，则逻辑为false，否则为true。 | ！(A&&B)为true |
案例演示
//演示逻辑运算符的使用8&
var age int = 40
if age >30&& age < 50 {
fmt. Println("ok1")
}
if age >30&& age < 40 {
fmt. Print1n( "ok2")
}//演示逻辑运算符的使用
if age>38Ilage<5e{
fmt . PrintIn( "ok3")
}
if age>30|age<40{
fmt . Println( "ok4" )
}
//演示逻辑运算符的使用!
if age>30{
fmt . Println("ok5" )
if !(age > 30) {
fmt, . Println("ok6" )
}
注意事项和细节说明
&&也叫短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false
||也叫短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true
案例演示
//声明一个函数(测试)
func test() bool {
fmt.Println( "test...")
return true
}
func main() {
var i int =10
//短路与
//说明因为i < 9为false ,因此后面的test() 就不执行
if i<9 && test() {
fmt. Println( "ok..")
}
//说明 因为 i > 9为true ,因此后面的test() 就不执行
if i > 9 || test(){
fmt. Print1n( "hello...")
}
}赋值运算符
基本的介绍
赋值运算符就是将某个运算后的值，赋给指定的变量。
赋值运算符的分类
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C=A+B将A+B表达式结果赋值给C |
| += | 相加后再赋值 | C+=A 等于 C=C+A |
| -= | 相减后再赋值 | C-=A 等于 C=C-A |
| *= | 相乘后再赋值 | C*=A 等于 C=C*A |
| /= | 相除后再赋值 | C/=A 等于 C=C/A |
| %= | 求余后再赋值 | C%=A 等于 C=C%A |
| <<= | 左移后赋值 | C<<=2 等于 C=C<<2 |
| >>= | 右移后赋值 | C>>=2 等于 C=C>>2 |
| &= | 按位与后赋值 | C&=2 等于 C=C&2 |
| ^= | 按位异或后赋值 | C^=2 等于 C=C^2 |
| |= | 按位或后赋值 | C|=2 等于 C=C|2 |
**说明:**后半部分的赋值运算涉及到二进制相关知识哦！
赋值运算的案例演示
- 赋值基本案例
- 有两个变量，a和b，要求将其进行交换，最终打印结果
- +=的使用案例
- 案例
package main
import (
"fmt"
)
func main() {
//赋值运算符的使用演示
//var i int
// i = 10 // 基本赋值
//有两个变量，a和b，要求将其进行交换，最终打印结果
// a = 9, b = 2 ==> a = 2 , b = 9
a := 9
b := 2
fmt.Printf("交换前的情况： a = %v, b = %v\n",a,b)
//定义一个临时变量
t := a
a = b
b = t
fmt.Printf("交换后的情况: a = %v, b = %v\n",a,b)
//复合赋值的操作
a += 17
fmt.Printf("a+=17 --> a = a + 17 = %v",a)
}赋值运算符的特点
- 运算顺序从右往左
var c int
c = a + 3 // 赋值运算的执行顺序是从右向左- 赋值运算符的左边 只能是变量，右边可以是变量，表达式，常量值！
//赋值运算符的左边 只能是变量，右边可以是变量，表达式，常量值！
//表达式:任何有值的都可以看做是表达式
var d int
d = a //
d = 8 + 2 * 8 // =的右边是表达式
d = test() + 90 // =的右边是表达式
d = 890 //890常量
fmt.Println(d)- 复合赋值运算符等价于下面的效果
a += 3 <==> a = a + 3
面试题
有两个变量，a和b，要求将其进行交换，但是不允许使用中间变量，最终打印结果
package main
import (
"fmt"
)
func main() {
var a int = 9
var b int = 10
a = a + b
b = a - b // = a+b-b = a
a = a - b // = a+b-a = b
fmt.Printf("a = %v b = %v ", a, b)
}牛牛牛！
位运算符
| 运算符 | 描述 |
|---|---|
| & | 按位与运算符”&”是双目运算符。其功能是参与运算的两数各对应的二进位相与。运算规则是:同时为1，结果为1,否则为0 |
| | | 按位或运算符川”是双目运算符。其功能是参 与运算的两数各对应的二进位相或.运算规则是:同时为1，结果为1,否则为0 |
| ^ | 按位异或运算符”是双目运算符。其功能是参与运算的两数各对应的二进位相异或。运算规则是:当二进位不同时，结果为1,否则为0 |
| << | 左移运算符<<”是双目运算符。其功能把<<”左边的运算数的各二进位全部左移若干位，高位丢弃，低位补0。左移n位就是乘以2的n次方。 |
| >> | 右移运算符>>”是双目运算符。其功能是把”>>”左边的运算数的各二进位全部右移若干位，右移n位就是除以2的n次方 |
其他运算符说明
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a;将给出变量a的实际地址 |
| * | 指针变量 | *a;是一个指针变量 |
举例说明：
import (
"fmt"
)
func main() {
//演示一下 & 和 * 的使用
a := 100
fmt.Println("a的地址=", &a)
var ptr *int = &a
fmt.Println("ptr指向的值是:" ，*ptr)
}课堂案例
- 案例1：求两个数的最大值
func main() {
//求两个数的最大值
var n1 int = 10
var n2 int = 40
var max int
if n1 > n2{
max = n1
} else {
max = n2
}
fmt.Println("max=",max)
}- 案例2：求三个数的最大值
func main() {
//求两个数的最大值
var n1 int = 10
var n2 int = 40
var max int
if n1 > n2{
max = n1
} else {
max = n2
}
fmt.Println("max=",max)
//求三个数的最大值思路：先求两个数的最大值，再用第三个数与最大值相比，取较大的数。
var n3 int = 45
if n3 > max {
max = n3
}
fmt.Println("三个书中最大值是=", max)
}特别说明
Go语言明确不支持三元运算符，官方说明
演示在Go语言中实现三元运算符的效果：
var n int
var i int = 10
var j int = 12
//传统的三元运算
//n = i > j ? i : j
if i > j {
n = i
} else {
n = j
}
return n //12运算符的优先级
运算符的优先级的一览表
对上图的说明
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
- 只有单目运算符、赋值运算符是从右向左运算的。
- 梳理一个大概的优先级：
- 括号，++，–
- 单目运算
- 算术运算符
- 移位运算
- 关系运算符
- 位运算符
- 逻辑运算符
- 赋值运算符
- 逗号
键盘输入语句
介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。InputDemo.go
步骤
- 导入fmt包
- 调用fmt包的fmt.Scanln()或者fmt.Scanf()
案例演示
- 要求：可以从控制台接收用户信息，【姓名，年龄，薪水，是否通过考试】
- 使用fmt.Scanln()获取
package main
import (
"fmt"
)
//要求：可以从控制台接收用户信息，
//【姓名，年龄，薪水，是否通过考试】
func main() {
//1. 先声明需要的变量
var name string
var age byte
var sal float32
var isPass bool
fmt.Println("请输入姓名")
//当程序执行到 fmt.Scanln(&name),程序会停止在这里，等待用户输入，并回车
fmt.Scanln(&name)
fmt.Println("请输入年龄")
fmt.Scanln(&age)
fmt.Println("请输入薪水")
fmt.Scanln(&sal)
fmt.Println("请输入是否通过考试")
fmt.Scanln(&isPass)
fmt.Printf("名字是 %v \n年龄是 %v \n薪水是 %v \n是否通过考试 %v\n", name, age, sal, isPass)
}运行结果
请输入姓名
leafii
请输入年龄
23
请输入薪水
60000
请输入是否通过考试
true
名字是 leafii
年龄是 23
薪水是 60000
是否通过考试 true- 使用fmt.Scanf()获取
package main
import (
"fmt"
)
//要求：可以从控制台接收用户信息，
//【姓名，年龄，薪水，是否通过考试】
func main() {
//1. 先声明需要的变量
var name string
var age byte
var sal float32
var isPass bool
//方式2：fmt.Scanf，可以按指定的格式输入
fmt.Println("请输入你的姓名，年龄，薪水，是否通过考试，使用空格隔开")
fmt.Scanf("%s %d %f %t", &name, &age, &sal, &isPass)
fmt.Printf("名字是 %v \n年龄是 %v \n薪水是 %v \n是否通过考试 %v\n", name, age, sal, isPass)
}运行结果：
请输入你的姓名，年龄，薪水，是否通过考试，使用空格隔开
leafii 23 60000 true
名字是 leafii
年龄是 23
薪水是 60000
是否通过考试 true进制
对于整数，有四种表示方式：
- 二进制：0，1，满2进1。在Golang中，不能直接使用二进制来表示一个整数，它沿用了c的特点
- 十进制：0-9，满10进1.
- 八进制：0-7，满8进1.以数字0开头表示。
- 十六进制：0-9及A-F，满16进1。以0x 或0X开头表示。（A到F不区分大小写）
进制的图示
| 十进制 | 十六进制 | 八进制 | 二进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 10 |
| 3 | 3 | 3 | 11 |
| 4 | 4 | 4 | 100 |
| 5 | 5 | 5 | 101 |
| 6 | 6 | 6 | 110 |
| 7 | 7 | 7 | 111 |
| 8 | 8 | 10 | 1000 |
| 9 | 9 | 11 | 1001 |
| 10 | A | 12 | 1010 |
| 11 | B | 13 | 1011 |
| 12 | C | 14 | 1100 |
| 13 | D | 15 | 1101 |
| 14 | E | 16 | 1110 |
| 15 | F | 17 | 1111 |
| 16 | 10 | 20 | 10000 |
| 17 | 11 | 21 | 10001 |
进制转换的介绍
总览:
其他进制转十进制
二进制如何转十进制
134 = 4 * 1 + 3 * 10 + 10 * 10 = 4 + 30 + 100 = 134
规则：从最低位开始（右边），将每个位上的数提取出来，乘以2的（位数-1）次方然后求和。
案例： 请将二进制：1011转成十进制的数
1011 = 1 * 1 + 1 * 2 + 0 * 2 * 2 + 1 * 2 * 2 * 2 = 1 + 2 + 0 + 8 = 11
八进制转换成十进制实例
规则：从最低位开始（右边），将每个位上的数提取出来，乘以8的（位数-1）次方然后求和。
案例:请将0123转成十进制的数
0123 = 3 * 1 + 2 * 8 + 1 * 8 * 8 + 0 * 8 * 8 * 8 = 3 + 16 + 64 = 83
十六进制转成十进制
规则：从最低位开始（右边），将每个位上的数提取出来，乘以16的（位数-1）次方然后求和。
案例：请将0x34A转成十进制的数
0x34A = 10 * 1 + 4 * 16 + 3 * 16 * 16 = 10 + 64 + 768 = 842
其他进制转成10进制的课堂练习
课堂练习: 请将
- 二进制： 110001100 转成十进制
110001100(2) =1 * 2 2+ 1 * 2 3 + 1 * 27 + 1 * 28 = 396
- 八进制： 02456 转成十进制
02456(8) = 6 * 1 + 5 * 8 + 4 * 82 + 2 * 83 = 1326
- 十六进制： 0xA45 转成十进制
0xA45 (16) = 5 * 1 + 4 * 16 + 10 * 162 = 2629
十进制如何转成其他进制
十进制如何转二进制
十进制转成八进制
十进制转十六进制
课堂练习
请将
- 123 转成二进制
123（10） = 1111011 (2)
- 678转成八进制
678(10) = 1246(8)
- 8912 转成十六进制
8912(10) = 22D0(16)
二进制如何转成八进制、十六进制
二进制转换成八进制
**规则:**将二进制数每三位一组(从低位开始组合),转成对应的八进制数即可。
案例:请将二进制: 11010101 转成八进制
11010101= 0325
二进制转成十六进制
**规则:**将二进制数每四位一组(从低位开始组合),转成对应的十六进制数即可。
案例:请将二进制: 11010101 转成十六进制
11010101 = 0xD5
课堂练习：请将
- 二进制：11100101 转成 八进制
- 二进制： 1110010110 转成 十六进制
八进制、十六进制转成二进制
八进制转成二进制
规则：将八进制数每一位，转成对应的一个3位的二进制数即可。
案例：请将0237转换成二进制
0237（8） = 10011111（2）
十六进制转成二进制
规则：将十六进制数每一位，转成对应的一个4位的二进制数即可。
案例：请将0x237转成二进制
0x237(16) = 1000110111(2)
位运算
位运算的思考题
- 请看下面的代码段，回答a,b,c,d结果是多少？
func main() {
var a int = 1 >> 2
var b int = -1 >> 2
var c int = 1 << 2
var d int = -1 << 2
//a b c d结果是多少？
fmt.Println("a=",a)
fmt.Println("b=",b)
fmt.Println("c=",c)
fmt.Println("d=",d)
}
/*
a= 0
b= -1
c= 4
d= -4
*/- 请回答在Golang中，下面的表达式运算的结果是：
func main() {
fmt.Println(2&3)
fmt.Println(2|3)
fmt.Println(13&7)
fmt.Println(-3^3)
}
/**
2
3
5
-2
*/二进制在运算中的说明
二进制是逢2进位的进位制，0、1是基本算符。
现代的电子计算机技术全部采用的是二进制，因为它只使用0、1两个数学符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1“，数字1在不同的位上代表不同的值，按从右至左的次序，这个值以二倍递增。
在计算机的内部，运行各种运算时，都是以二进制的方式来运行。
原码、反码、补码
位运算符和移位运算符
- Golang有3个位运算
- 按位与& ： 两位全为1，结果为1，否则为0
- 按位或| ： 两位有一个为1，结果为1，否则为0
- 按位异或^ ： 两位一个为0，一个为1，结果为1，否则为0
- 案例练习
2&3=? 2|3=? 2^3=?
//2&3=? 2|3=? 2^3=?
func main() {
fmt.Println(2&3)//2
fmt.Println(2|3)//3
fmt.Println(2^3)//3
fmt.Println(-2^2)//-4
}
Golang中有两个移位运算符：
- 右移运算符 >>: 低位溢出，符号位不变，并用符号位补溢出的高位
- 左移运算符 <<: 符号位不变，低位补0
案例演示
a := 1 >> 2 // 0000 0001 => 0000 0000 = 0
c := 1 << 2 // 0000 0001 ==> 0000 0100 => 4