6：运算符

在前面的课程中，我们已经学习了变量，常量，那么接下来我们学习一下运算符。GO语言中常见的运算符有算术运算符，赋值运算符，关系运算符，逻辑运算符等。

1：算术运算符

package main

import "fmt"

func main0701() {
    a := 10
    b := 5

    fmt.Println(a + b) //30
    fmt.Println(a - b) //-10
    fmt.Println(a * b) //200
    //两个整数相除等到的结果也是整型
    //在除法计算时 除数不能为0
    fmt.Println(a / b) //???0

    //通过命令编译代码
    //go build 源文件1.go 源文件2.go
    //编译并运行程序
    //go run 源文件1.go 源文件2.go
    //异常
    /*
    1、编辑时异常
    2、编译时异常
    3、运行时异常
     */
}
func main0702() {
    a := 10
    b := 2
    //取余运算符除数不能为0
    //取余运算符不能对浮点型使用
    c := a % b
    fmt.Println(c)
}

func main() {
    //自增自减运算符
    //可以对浮点型进行自增自减运算 但是不能对常量进行自增自减运算
    a := 10
    //const a =10
    //a = a + 1
    //a++//自增 在变量本身加一

    //a--//自减

    //自增自减不能出现在表达式中
    //a = a++ + a--
    //二义性 在不同操作系统中运算方式不同 结果可能会产生偏差
    //a = a++ * a-- - a--//err
    //b:=a--//err

    fmt.Println(a)
    //fmt.Println(b)
}

2：类型转换：

package main

import "fmt"

func main0801() {

    a, b, c := 0, 0, 0

    fmt.Scan(&a, &b, &c)

    sum := a + b + c
    fmt.Println(sum)
    //类型转换 数据类型(变量)  数据类型(表达式)
    //fmt.Println(float64(sum / 3))
    fmt.Printf("%.2f", float64(sum)/3)
}

func main0802() {
    //var a float32 = 12.34
    //var b float64 = 22.22

    //int8 -> int16 ->int32 ->int64
    //float32 ->float64

    //int64 -> float64
    //在类型转换时建议低类型转成高类型  保证数据精度
    //建议整型转成浮点型
    //高类型转成低类型 可能会丢失精度
    //fmt.Printf("%.2f", float64(a)+b)

    //fmt.Println(float64(a) + b)

    //数据溢出 符号发生变化
    //var a int = 1234
    //fmt.Println(int8(a))
    var a float64 = 3.999

    //将浮点型转成整型 保留数据整数部分 丢弃小数部分
    b := int(a) //3
    fmt.Println(b)
}

//练习题
func main() {
    //107653几天几小时几分几秒

    s := 107653

    fmt.Println("天：", s/60/60/24%365)
    fmt.Println("时：", s/60/60%24)
    fmt.Println("分：", s/60%60)
    fmt.Println("秒：", s%60)

    //1*24*60*60 + 5*60*60 + 54*60 + 13 =107653
}

3：赋值运算符

package main

import "fmt"

func main() {
    //a := 10
    //b := 20
    //c := a + b
    //
    ////c += 20 //c=c+20
    ////c -= 20
    ////c *= 20
    ////c /= 20 //30
    //c = 20
    //c %= 3 //c = c % 3

    var c int = 10
    //将表达式右侧进行结果计算在进行赋值运算符
    c %= (2 + 3)

    //c = c % 5 //ok
    //c = c % 2 + 3//err

    fmt.Println(c)
}

4：关系(比较)运算符

关系运算符我们又称为比较运算符，听到比较这个词，大家想到的就是比较大小，例如：
大象的重量(1500)>老鼠的重量(1)
兔子的寿命(3)>乌龟的寿命(1000)
我的年龄(20)==你的年龄(20)
提问：比大比小的结果是什么？
结果是对或者是错，在GO语言中，怎样表示对于错呢？
关系运算的结果是布尔类型的。
bool值只有两个
真:true
假:false

package main

import "fmt"

func main1001() {

    //比较运算符返回值bool类型
    a := 10
    b := 10

    //大于 >  小于 <
    //fmt.Println(a < b)
    //大于等于 >= 小于等于 <=
    //fmt.Println(a < b)
    //相等于 ==  不等于 !=
    fmt.Println(a != b)
}

func main() {
    //a := 10
    //b := 20
    //
    ////比较运算符返回值类型为bool类型
    //c := a + 20 > b
    //
    //fmt.Printf("%T\n", c)
    //fmt.Println(c)
    a := 'a'
    b := 'A'

    fmt.Println(a > b)
}

5：逻辑运算符

1）常见的逻辑运算符如下：

有逻辑运算符连接的表达式叫做逻辑表达式
通过以上表格我们发现：逻辑表达式的结果同样也是bool类型
逻辑运算符两边放的一般都是关系表达式或者bool类型的值。
例如：
5>3 &&true
3>5||false

package main

import "fmt"

func main1101() {

    a := 10
    b := 20

    //c := a > b //flase

    //逻辑非 !  非真为假 非假为真
    fmt.Println(!(a > b))
    //单目运算符
    // ! ++ -- &(取地址运算符)
    //双目运算符

}

func main1102() {

    a := 10
    b := 20

    //逻辑与  &&  同真为真 其余为假

    c := a < b && false
    fmt.Println(c)

}

func main1103() {
    a := 10
    b := 20
    //逻辑或  ||  同假为假 其余为真
    fmt.Println(a < b || a > b)
}

func main() {
    a := 10
    b := 20

    //逻辑与高于逻辑或
    fmt.Println(a > b && b > a || a > 0)
}

6：其他运算符

传址：传内存块

传值：传变量值，两个内存块

关于指针的应用，我们后面会重点给大家讲解，目前大家只需要掌握 &

代码看下面

7：运算符优先级

在Go语言中，一元运算符（一些只需要一个操作数的运算符称为一元运算符（或单目运算符）。）拥有最高的优先级，二元运算符的运算方向均是从左至右。
下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

上图中部分运算符现在没有讲解到，后期用到时再给大家具体讲解，目前大家需要掌握的是算术，赋值，关系，逻辑，取地址运算符。

package main

import "fmt"

func main1201() {

    a := 10

    //& 取地址运算符
    fmt.Println(&a)

    //* 取值运算符 p  指针变量
    p := &a

    //通过指针间接修改变量的值
    *p = 123
    fmt.Println(*p)
    fmt.Println(a)

    //()括号运算符  最高级
    //[]数组切片下标
    //. 结构体.成员 包.函数 对象.方法

    // 位运算  & | ^ ~ 位移运算 >>  <<

    // 通信 >-

}

func main(){

    //()括号运算符  最高级
    //[]数组切片下标
    //. 结构体.成员 包.函数 对象.方法

    //单目运算符
    // !(逻辑非) ++(自增) --(自减) &(取地址) *(取值)

    //双目运算符
    //*(乘) /(除) %(取余)
    //+(加) -(减)
    // >(大于) <(小于) >=(大于等于) <=(小于等于) ==(相等于) !=(不等于)
    //&& (逻辑与)
    //|| (逻辑或)
    //= += -= *= /= %=(赋值运算符)

}