基本数据——运算符

表达式：(a + b) * c

​ a,b,c叫做操作数

​ +，*，叫做运算符

一、运算符

1.1 算术运算符

+ - * / %(求余) ++ --

示例：

package main

import "fmt"

func main() {
    /*
    算术运算符：+，-，*,/,%,++,--
    +
    -
    *,乘法
    /：取商，两个数相除，取商
    %：取余，取模，两个数相除，取余数

    ++：给自己加1
        i++
    --：给自己减1
        i--

    整数
     */
    a := 10
    b := 3
    sum := a + b
    fmt.Printf("%d + %d = %d\n", a, b, sum)

    sub := a - b
    fmt.Printf("%d - %d = %d\n", a, b, sub)

    mul := a * b
    fmt.Printf("%d * %d = %d\n", a, b, mul)

    div := a / b //取商
    mod := a % b //取余
    fmt.Printf("%d / %d = %d\n", a, b, div)
    fmt.Printf("%d %% %d = %d\n", a, b, mod)

    c := 3
    c++ //就是给c+1
    fmt.Println(c)

    c-- //给c减1
    fmt.Println(c)

}

1.2 关系运算符

== != > < >= <=

示例

package main

import "fmt"

func main() {
    /*
    赋值运算符：
        =,+=,-=,*=,/=,%=,<<=,>>=,&=,|=,^=...
        =，把=右侧的数值，赋值给=左边的变量

        +=, a += b,相当于a = a + b
            a++, a += 1
     */
     var a int
     a = 3
     fmt.Println(a)

     a += 4 // a = a + 4
     fmt.Println(a) // 7

     a -= 3
     fmt.Println(a) // 4
     a *= 2
     fmt.Println(a) // 8
     a /= 3
     fmt.Println(a) // 2
     a %= 1
     fmt.Println(a) // 0



}

1.3 逻辑运算符

示例

package main

import "fmt"

func main() {
    /*
    逻辑运算符：操作数必须是bool，运算结果也是bool
    逻辑与：&&
        运算规则：所有的操作数都是真，结果才为真，有一个为假，结果就为假
            "一假则假，全真才真"
    逻辑或：||
        运算规则：偶有的操作数都是假，结果才为假，有一个为真，结果就为真
            "一真则真，全假才假"
    逻辑非：！
        !T-->false
        !F-->true
     */
    f1 := true
    f2 := false
    f3 := true
    res1 := f1 && f2
    fmt.Printf("res1: %t\n", res1)

    res2 := f1 && f2 && f3
    fmt.Printf("res2: %t\n", res2)

    res3 := f1 || f2
    fmt.Printf("res3: %t\n", res3)
    res4 := f1 || f2 || f3
    fmt.Printf("res4: %t\n", res4)
    fmt.Println(false || false || false)

    fmt.Printf("f1:%t,!f1:%t\n", f1, !f1)
    fmt.Printf("f2:%t,!f2:%t\n", f2, !f2)

    a := 3
    b := 2
    c := 5
    res5 := a > b && c%a == b && a < (c/b)
    fmt.Println(res5)

    res6 := b*2 < c || a/b != 0 || c/a > b
    fmt.Println(res6)
    res7:=!(c/a==b)
    fmt.Println(res7)

}

1.4 位运算符

这里最难理解的就是^了，只要认为AB两者都相同的时候，为0，其他都为1

假设A为60，B为13

示例

package main

import "fmt"

func main() {
    /*
    位运算符：
        将数值，转为二进制后，按位操作
    按位&：
        对应位的值如果都为1才为1，有一个为0就为0
    按位|：
        对应位的值如果都是0才为0，有一个为1就为1
    异或^：
        二元：a^b
            对应位的值不同为1，相同为0
        一元：^a
            按位取反：
                1--->0
                0--->1
    位清空：&^
            对于 a &^ b
                对于b上的每个数值
                如果为0，则取a对应位上的数值
                如果为1，则结果位就取0

    位移运算符：
    <<：按位左移，将a转为二进制，向左移动b位
        a << b
    >>: 按位右移，将a 转为二进制，向右移动b位
        a >> b
     */

    a := 60
    b := 13
    /*
    a: 60 0011 1100
    b: 13 0000 1101
    &     0000 1100
    |     0011 1101
    ^     0011 0001
    &^    0011 0000


    a : 0000 0000 ... 0011 1100
    ^   1111 1111 ... 1100 0011
     */
    fmt.Printf("a:%d, %b\n",a,a)
    fmt.Printf("b:%d, %b\n",b,b)

    res1 := a & b
    fmt.Println(res1) // 12

    res2 := a | b
    fmt.Println(res2) // 61

    res3 := a ^ b
    fmt.Println(res3) // 49

    res4 := a &^ b
    fmt.Println(res4) // 48

    res5 := ^a
    fmt.Println(res5)

    c:=8
    /*
    c : ... 0000 1000
          0000 100000
    >>        0000 10
     */
    res6 := c << 2
    fmt.Println(res6)

    res7 := c >> 2
    fmt.Println(res7)
}

1.5 赋值运算符

示例

package main

import "fmt"

func main() {
    /*
    赋值运算符：
        =,+=,-=,*=,/=,%=,<<=,>>=,&=,|=,^=...
        =，把=右侧的数值，赋值给=左边的变量

        +=, a += b,相当于a = a + b
            a++, a += 1
     */
     var a int
     a = 3
     fmt.Println(a)

     a += 4 // a = a + 4
     fmt.Println(a) // 7

     a -= 3
     fmt.Println(a) // 4
     a *= 2
     fmt.Println(a) // 8
     a /= 3
     fmt.Println(a) // 2
     a %= 1
     fmt.Println(a) // 0



}

1.6优先级运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。