目 录CONTENT

文章目录

Go学习系列06-运算符

cplinux98
2022-10-19 / 0 评论 / 0 点赞 / 64 阅读 / 1,752 字 / 正在检测是否收录...

算术运算符

image-20221017200538388

算术表达式

由算术运算符连接起来的式子: 如:1+1 a-b

(变量ab前面已声明并赋初值)

运算优先级:先乘除,后加减,有括号先算括号里的,相同级别的从左至右运算

必须是同等类型才可以进行运算!

int 转float多小数,float转int丢精度

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 20
	fmt.Printf("a+b=%d\n", a+b)
	fmt.Printf("b-a=%d\n", b-a)
	fmt.Printf("b*a=%d\n", b*a)
	fmt.Printf("b/a=%d\n", b/a)
	fmt.Printf("b%%a=%d\n", b%a)
}
//a+b=30
//b-a=10
//b*a=200
//b/a=2
//b%a=0

自增和自减

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 12
	a++  // 等价于 a=a+1,并且只能独立使用
	b--  // 等价于 b=b-1
	fmt.Printf("a=%d, b=%d", a, b)
}
//a=11, b=11

注意:GO语言中没有前自增,这是与其它编程语言不同的地方

示例

某学生三门课成绩为,语文:90 数学:80 英语:67,编程求总分和平均分

package main

import "fmt"

func main() {
	var chinese int = 90
	var math int = 80
	var english int = 67

	var sum, avg int
	sum = chinese + math + english
	avg = sum / 3
	fmt.Printf("总分: %d,平均分: %d", sum, avg)
}

优化: 减少变量定义,可以直接在fmt的时候计算

package main

import "fmt"

func main() {
	var chinese int = 90
	var math int = 80
	var english int = 67
	fmt.Printf("总分: %d,平均分: %.2f", chinese+math+english, float64((chinese+math+english)/3))
}

赋值运算符

运算符 描述 实例
= 简单的赋值运算符,将一个表达式的值赋给一个左值 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() {
	a := 10
	b := 20

	a = a + b // 此时a是两者的和
	b = a - b // 此时 两者和 - b 就是之前a的值
	a = a - b // 此时b是之前a的值,两者之和-之前a的值就是之前b的值
	fmt.Printf("a=%v, b=%v", a, b)
}
//a=20, b=10

关系运算符

假定 A 值为 10,B 值为 20

运算符 描述 实例
== 检查两个值是否相等,如果相等返回 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

关系运算符注意的点

  • 同类型才可以比较
  • 结果是bool类型,只有true和false
  • 用关系运算符组成的表达式,就是关系表达式 A > B

示例

func main() {
	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1 == n2)
	fmt.Println(n1 != n2)
	fmt.Println(n1 > n2)
	fmt.Println(n1 >= n2)
	fmt.Println(n1 < n2)
	fmt.Println(n1 <= n2)
	flag := n1 > n2
	fmt.Println("flag=", flag)
}
//false
//true
//true
//true
//false
//false
//flag= 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

逻辑运算符注意的点

  • 有逻辑运算符连接的表达式叫做逻辑表达式
  • 逻辑运算符两边的一般都是关系表达式或bool类型
  • 逻辑表达式的值也是bool类型
  • &&也叫短路与
    • 如果第一个条件为fasle,则第二个条件不会判断,最终结果为fasle
  • || 也叫短路或
    • 如果第一个条件为true,则第二个条件不会判断,最终结果为true

示例

func test(num int) bool {
	fmt.Printf("test %d func is running", num)
	return true
}
func main() {
	var i int = 10
	if i < 9 && test(1) {
		fmt.Println("1: false && true")
	}

	if i > 9 && test(2) {
		fmt.Println("2: true && true")
	}

	if i < 9 || test(3) {
		fmt.Println("3: false || true")
	}

	if i > 9 || test(4) {
		fmt.Println("4: true || true")
	}

}
//test 2 func is running2: true && true
//test 3 func is running3: false || true
//4: true || true

其他运算符

运算符 描述 实例
& 返回变量存储地址 &a 将给出变量的实际地址
* 返回内存地址指向的变量 *a 是一个指针变量
func main() {
	var a int = 4
	var b int32
	var c float32
	var ptr *int
	fmt.Printf("a type is :%T\n", a)
	fmt.Printf("b type is :%T\n", b)
	fmt.Printf("c type is :%T\n", c)

	ptr = &a
	fmt.Printf("a value is : %d\n", a)
	fmt.Printf("ptr is : %d\n", ptr)
	fmt.Printf("ptr is : %d\n", *ptr)
}
//a type is :int
//b type is :int32
//c type is :float32
//a value is : 4
//ptr is : 824633811112
//ptr is : 4

运算的优先级

  • 一元运算符(单目运算符):只需要一个操作数的运算符
  • 二元运算符:有2个操作数的运算符
  • 逻辑与的优先级高于逻辑或

一元运算符拥有最高优先级

分类 描述 顺序
赋值运算符 = += -= *= /= %= >>= <<= &= ^= |= 右到左
单目 + - ! ~ (type) * & sizeof 右到左
后缀 () [[ -> . ++ – 左到右
乘法 * / % 左到右
加法 + - 左到右
移位 >> << 左到右
关系 > >= < <= 左到右
相等(关系) == != 左到右
按位AND & 左到右
按位XOR ^ 左到右
按位OR | 左到右
逻辑AND && 左到右
逻辑OR || 左到右
逗号 , 左到右
0

评论区