7.Go_The operator(运算符)

Go_运算符

运算符用于在程序运行时执行数学或逻辑运算。

Go_内置运算符:

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

算术运算符

+ -->> 相加
- -->> 相减
* -->> 相乘
/ -->> 相除
% -->> 求余
++ -->> 自增
-- -->> 自减

例如:
package main
import "fmt"
func main() {
    var s1 int = 20
    var s2 int = 10
    var s3 int
    s3 = s1 + s2
    fmt.Println("s1+s2=",s3)
    s3 = s1 - s2
    fmt.Println("s1-s2=",s3)
    s3 = s1 * s2
    fmt.Println("s1 * s2=",s3)
    s3 = s1 / s2
    fmt.Println("s1 / s2=",s3)
    s3 = s1 % s2
    fmt.Println("s1 % s2=",s3)
    s1++
    fmt.Println("s1++",s1)
    s1--
    fmt.Println("s1--",s1)
}

关系运算符

== -->> 检查两个值是否相等，如果相等返回 True 否则返回 False。
!= -->> 检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>  -->> 检查左边值是否大于右边值，如果是返回 True 否则返回 False。
<  -->> 检查左边值是否小于右边值，如果是返回 True 否则返回 False。
>= -->> 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<= -->> 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

例如:
package main
import "fmt"
func main() {
    var  l1 int = 20
    var  l2 int = 10
    if(l1 == l2){
        fmt.Println("l1等于l2")
    } else
    {
    fmt.Println("l1不等于l2")
    }
    if(l1 < l2){
        fmt.Println("l1小于l2")
    }else {
        fmt.Println("l1不小于l2")
    }
    if(l1>l2){
        fmt.Println("l1大于l2")
    }else {
        fmt.Println("l1不大于l2")
    }
    if(l1 <= l2) {
        fmt.Println("l1 小于等于l2")
    }else
    {
        fmt.Println("l1 大于等于l2")
    }
}

运行结果:
l1不等于l2
l1不小于l2
l1大于l2
l1 大于等于l2

逻辑运算符

&& -->> 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。
|| -->> 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。
!  -->> 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。

例如:
package main
import "fmt"
func main() {
    var m1 bool = true
    var m2 bool = false
    if (m1 && m2){
        fmt.Println("ture")
    }
    if (m1 || m2){
        fmt.Println("true")
    }
    m1 = false
    m2 = true
    if (m1 && m2){
        fmt.Println("true")
    } else {
    fmt.Println("false")
    }
    if (!(m1 && m2)){
        fmt.Println("true")
    }
}

运行结果:
true
false
true

位运算符

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

假定A = 60 ,B = 13
A = 0011 1100
B = 0000 1101
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A = 1100 0011

& -->> 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。
| -->> 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或
^ -->> 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位
相异时，结果为1。
<< -->> 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部
左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
>> -->>右移运算符">>"是双目运算符.右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部
右移若干位，">>"右边的数指定移动的位数。

package main

import "fmt"

func main() {
    var n1 uint = 60
    var n2 uint = 13
    var n3 uint = 0

    n3 = n1 & n2
    fmt.Println(n3)

    n3 = n1 | n2
    fmt.Println(n3)

    n3 = n1 ^ n2
    fmt.Println(n3)

    n3 = n1 << 2
    fmt.Println(n3)

    n3 = n1 >> 2
    fmt.Println(n3)
}

运行结果:
12
61
49
240
15

赋值运算符

= -->> 简单的赋值运算符，将一个表达式的值赋给一个左值
+= -->> 相加后再赋值
-= -->> 相减后再赋值
*= -->> 相乘后再赋值
/= -->> 相除后再赋值
%= -->> 求余后再赋值
<<= -->> 左移后赋值
>>= -->> 右移后赋值
&=  -->> 按位与后赋值
^=  -->> 按位异或后赋值
|=  -->> 按位或后赋值

例如:
package main
import "fmt"
func main() {
    var p1 int = 20
    var p2 int
    p2 = p1
    fmt.Println(p2)
    p2 += p1
    fmt.Println(p2)
    p2 -= p1
    fmt.Println(p2)
    p2 *= p1
    fmt.Println(p2)
    p2 /= p1
    fmt.Println(p2)
    p2 = 200
    p2 <<= 2
    fmt.Println(p2)
    p2 >>= 2
    fmt.Println(p2)
    p2 &= 2
    fmt.Println(p2)
    p2 ^= 2
    fmt.Println(p2)
    p2 |= 2
    fmt.Println(p2)
}

运行结果:
20
40
20
400
20
800
200
0
2
2

其他运算符

& -->> 返回变量存储地址
* -->> 指针变量。

package main
import "fmt"
func main() {
    var q1 int = 4
    var q2 int32
    var q3 float32
    var ptr *int
    fmt.Println(q1)
    fmt.Print(q2)
    fmt.Println(q2)
    fmt.Println(q3)
    ptr = &q1
    fmt.Println(q1)
    fmt.Println(*ptr)
}

运行结果:
int
int32
float32
4
4

运算符优先级

7 -->>  ^!
6 -->>  * / % << >> & &^
5 -->>  + - | ^
4 -->>  == != < <= >= >
3 -->>  <-
2 -->>  &&
1-->>   ||

package main
import "fmt"

func main() {
    var a int = 20
    var b int = 10
    var c int = 15
    var d int = 5
    var e int;
    e = (a + b) * c / d;      // ( 30 * 15 ) / 5
    fmt.Printf("(a + b) * c / d 值 : %d\n",  e );

    e = ((a + b) * c) / d;    // (30 * 15 ) / 5
    fmt.Printf("((a + b) * c) / d 值  : %d\n" ,  e );

    e = (a + b) * (c / d);   // (30) * (15/5)
    fmt.Printf("(a + b) * (c / d) 值  : %d\n",  e );

    e = a + (b * c) / d;     //  20 + (150/5)
    fmt.Printf("a + (b * c) / d 值 : %d\n" ,  e );
}

运行结果:
(a + b) * c / d 值 : 90
((a + b) * c) / d 值  : 90
(a + b) * (c / d) 值  : 90
a + (b * c) / d 值  : 50