Go运算符
运算符用于在程序运行时执行数学或逻辑运算。
Go语言内置的运算符有:
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 其他运算符
算术运算符
假设a=1,b=2:
运算符 | 描述 | 实例 |
---|---|---|
+ | 相加 | a+b 输出结果为3 |
- | 相减 | b-a 输出结果为1 |
* | 相乘 | a*b 输出结果为2 |
/ | 相除 | b/a 输出结果为2 |
% | 求余 | a%b输出结果为0 |
++ | 自增 | a++ 输出结果为2 |
-- | 自减 | b--输出结果为1 |
关系运算符
假如 :a=1,b=2;
运算符 | 描述 | 实例 |
---|---|---|
== | 检查两个值是否相等,如果相等返回 True 否则返回 False | (a==b)为false |
!= | 检查两个值是否不相等,如果不相等返回 True 否则 返回 False。 | (a!= b) 为 True |
> | 检查左边值是否大于右边值,如果是返回 True 否则 返回 False | (a > b) 为 False |
< | 检查左边值是否小于右边值,如果是返回 True 否则 返回 False。 | (a <b) 为 True |
>= | 检查左边值是否大于等于右边值,如果是返回 True 否则返回 False。 | (a >=b) 为 False |
<= | 检查左边值是否小于等于右边值,如果是返回 True 否则返回 False。 | (a <= b) 为 True |
逻辑运算符
假如a为true,b为false
运算符 | 描述 | 实例 |
---|---|---|
&& | 逻辑 AND 运算符。 如果两边的操作数都是 True,则条件 True,否则为 False | (a&&b)为 false |
|| | 逻辑 OR 运算符。 如果两边的操作数有一个 True,则条件 True,否则为 False。 | (a||b)为true |
! | 逻辑 NOT 运算符。 如果条件为 True,则逻辑 NOT 条件 False,否则为 True。 | !(a&&b)为true |
位运算符
a | b | a&b | a|b | a^b |
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
假定 A 为 60,B 为 13:
运算符 | 描述 | 实例 |
---|---|---|
& | 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应 的二进位相与。 | (A & B) 结果为 12, 二 进 制 为 0000 1100 |
| | 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应 的二进位相或 | (A | B) 结果为 61, 二 进 制 为 0011 1101 |
^ | 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对 应的二进位相异或,当两对应的二进位相异时,结果为 1 | (A ^ B) 结果为 49, 二 进 制 为 0011 0001 |
<< | 左移运算符"<<"是双目运算符。左移 n 位就是乘以 2 的 n 次方。 其 功能把"<<"左边的运算数的各二进位全部左移若干位,由"<<"右边 的数指定移动的位数,高位丢弃,低位补 0。 | A << 2 结 果 为 240 , 二 进 制 为 1111 0000 |
>> | 右移运算符">>"是双目运算符。右移 n 位就是除以 2 的 n 次方。 其 功能是把">>"左边的运算数的各二进位全部右移若干位,">>"右边的数指定移动的位数。 | A >> 2 结 果 为 15 , 二 进 制 为0000 1111 |
赋值运算符
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符,将表达式的值赋给一个左值 | 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; 将给出变量的实际地址。 |
* | 间接寻址运算符 | *a; 是一个指针变量 |
运算符优先级
分类 | 描述 | 关联性 |
---|---|---|
后缀 | () [] -> . ++ - - | 左到右 |
一元 | + - ! ~ ++ - - (type) * & sizeof | 右到左 |
乘法 | * / % | 左到右 |
加减法 | + - | 左到右 |
移位 | << >> | 左到右 |
关系 | < <= > >= | 左到右 |
相等 | == != | 左到右 |
按位 AND | & | 左到右 |
按位 XOR | ^ | 左到右 |
按位 OR | | | 左到右 |
逻辑 AND | && | 左到右 |
逻辑 OR | || | 左到右 |
条件 | ?: | 右到左 |
分配 | = += -= *= /= %= >>= <<= &= ^= = | 右到左 |
逗号 | , | 左到右 |
如果想要临时提升某个表达式的整体运算优先级可以使用小括号。
Go语言类型转换
类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式,如下:
type_name(expression)
type_name 为类型,expression 为表达式。
以下实例中将整型转化为浮点型,并计算结果,将结果赋值给浮点型变量:
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum)/float32(count)
fmt.Printf("mean 的值为: %f\n",mean)
}
输出结果为:
mean的值为:3.400000
Go语言条件语句
条件语句需要开发者通过指定一个或多个条件,并通过测试条件是否为 true 来决定是否执行
指定语句,并在条件为 false 的情况在执行另外的语句。
Go 语言提供了以下几种条件判断语句:
语句 | 描述 |
---|---|
if语句 | if 语句 由一个布尔表达式后紧跟一个或多个语句组成。 |
if...else 语句 | if 语句 后可以使用可选的 else 语句, else 语句中的表达式 在布尔表达式为 false 时执行 |
if 嵌套语句 | 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语 句。 |
switch 语句 | switch 语句用于基于不同条件执行不同动作。 |
select 语句 | select 语句类似于 switch 语句,但是 select 会随机执行一 个可运行的 case。如果没有 case 可运行,它将阻塞,直到 有 case 可运行。 |
if语句案例:
package main
import "fmt"
func main() {
if num := 9; num < 0 {
fmt.Println(num, "is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
}
if...else 语句,if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行:
package main
import "fmt"
func main() {
/* 局部变量定义 */
var a int = 100;
/* 判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" );
} else {
/* 如果条件为 false 则执行以下语句 */
fmt.Printf("a 不小于 20\n" );
}
fmt.Printf("a 的值为 : %d\n", a);
}
以上代码执行结果为:
a 不小于 20
a 的值为 : 100
if 嵌套语句
if 布尔表达式 1 {
/* 在布尔表达式 1 为 true 时执行 */
if 布尔表达式 2 {
/* 在布尔表达式 2 为 true 时执行 */
}
}
你可以以同样的方式在 if 语句中嵌套 else if...else 语句
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int = 200
/* 判断条件 */
if a == 100 {
/* if 条件语句为 true 执行 */
if b == 200 {
/* if 条件语句为 true 执行 */
fmt.Printf("a 的值为 100 , b 的值为 200\n" );
}
}
fmt.Printf("a 值为 : %d\n", a );
fmt.Printf("b 值为 : %d\n", b );
}
以上代码执行结果为:
a 的值为 100 , b 的值为 200
a 值为 : 100
b 值为 : 200
switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上直下逐一测试,直到匹配为止。。switch 语句执行的过程从上至下,直到找到匹配项,匹配项后面也不需要再加 breakGo 编程语言中 switch 语句的语法如下:
switch var1 {
case val1:
...
case val2:
...
default:
...
}
变量 var1 可以是任何类型,而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数,但必须是相同的类型;或者最终结果为相同类型的表达式。您可以同时测试多个可能符合条件的值,使用逗号分割它们,例如:case val1, val2, val3。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var grade string = "B"
var marks int = 90
switch marks { //使用常量
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
switch { //使用表达式
case grade == "A" :
fmt.Printf("优秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
case grade == "F":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" );
}
fmt.Printf("你的等级是 %s\n", grade );
}
以上代码执行结果为:
优秀!
你的等级是 A
select因为只能和通道结合使用,因此学习完通道后在后面介绍。