Go核心开发学习笔记(七) —— 运算符

运算符： 用以表示数据运算，赋值，比较等

1. 算术运算符： + - * / % ++ – 正负等
2. 赋值运算符 = += -= *= /= %=
3. 比较(关系)运算符 >= <= < > == ！=
4. 逻辑运算符 && || !
5. 位运算符
6. 其他运算符 &取址 *取值

表达式概念： 任何有值的都可以看做表达式

运算符优先级：

1. 运算符有不同的优先级，也就是运算顺序。
2. 只有单目运算符，赋值运算符才是从右到左。
3. 优先级从高到低： 后缀(括号，++, --等)，单目(±正负,!~，* &取址取值)，算术运算符，移位运算符，比较运算符，位运算符，逻辑运算符，赋值运算符，逗号

算术运算符
看示例和注释

package main
import "fmt"
func main() {

//默认除数结果带小数，必须被除数要为小数10.0
fmt.Println(10 / 4)
fmt.Println(10.0 / 4)

//取模公式：无所谓包含负数或者不包含，a%b = a- a/b*b
fmt.Println(10 % 3)
fmt.Println(-10 % 3)
fmt.Println(10 % -3)

//自增自减
var i int = 10
i++
fmt.Println(i)      //11
i--

fmt.Println(i)      //10
}

1. 整数除和小数除有区别，整数做除法会去掉小数部分。
2. 取模本质：a%b = a- (a/b)*b。
3. 自增自减只能当独立语言使用，例如i++,i–，而不能 a := i++(i–), 也不能比较 i++ >0也不行。
4. ★★★自增自减没有++i和–i了，只有i++和i–了，这个大赞！
5. Golang去掉自增自减易混淆性写法，使golang更加简洁，统一(强制性)。

赋值运算符

1. C=A+B 就是将A+B结果赋予C
   C+=A 就是 C= C+A
   以此类推

进制

1. Golang不支持用二进制表达一个数，如果要输出一个数字的二进制数，则使用fmt.Printf("%b",i)的方式
2. 八进制可以支持 var i int = 011 这种表示
3. 十六进制可以支持 var i int = 0x11 这种表示

原码，反码，补码

1. 有符号的数字，二进制高位为符号位，0正1负
2. 正数的原码、反码、补码都是一样的 => 1 原:[0000 0001] 反：[0000 0001] 补：[0000 0001]
3. 负数的反码是原码符号位不变，其他位取反，补码是反码+1 => -1 原：[1000 0001] 反：[1111 1110] 补：[1111 1111]
4. ★★★计算机运行没有减法，所有的计算都是补码进行的，也就是说没有 1-1=0，而是1+(-1)=0

位运算符

1. 五个运算符：五种运算符均为双目运算符
   &：按位与，左右数字转换为二进制，同位与，同为1结果为1，其他情况都为0。
   |：按位或，左右数字转换为二进制，同位或，有一个1结果为1，都为0则都为0。
   ^：按位异或，左右数字转换为二进制，同位异或，10,01则为1，同1同0则为0。
   >>：左方数字转换成二进制，向右移=>(右方数字)的位数，高位丢弃，低位补0，乘以2的n次方。
   <<：左方数字转换成二进制，向左移=>(右方数字)的位数，高位补0，低位丢弃，除以2的n次方。
   案例：

    package main
    
    import "fmt"
    
    func main() {
    var (
    	a int = 2&3
    	b int = 2|3
    	c int = 2^3
    	d int = 2>>1
    	e int = 2<<2
    )
    fmt.Printf("%b %b %b %b %b",a,b,c,d,e)
    //结果如下：10 11 1 1 1000 => 2 3 1 1 4
    }
   

比较运算符

1. 结果是布尔值类型的，只有True和False
2. 经常用在if结构或循环结构中。
3. 关系运算符组成的表达式为关系表达式，==不能写成=，==代表判断是否相等，=代表赋值，两码事儿

逻辑运算符

1. 连接多个条件，一般来讲都是关系表达式，最终结果也是布尔值。

2. 与py一样
   逻辑与：&& 两边表达式是都为真则为真，一个为假则为假；
   逻辑或：|| 两边表达式是都为假则为假，其他都为真；
   逻辑非： ! 表达式为假，逻辑非为真，表达式为真，逻辑非为假。 取反

3. 短路与：两个条件，如果第一个条件不成立，那么后面那个条件不会再判断，直接程序结果为False
   if 10<9 && 1==1 {…} ： 1==1都不会去判断了，因为10<9已经错了。
   4、 短路或：两个条件，第一个条件成立，那么后面那个条件不会再判断了，直接程序结果为True
   if 10>9 || func() {…}： 因为10>9已经为真了，后面func()调用就不会执行了，结果为True。