go语言基础语法02天-1

7.2赋值运算符

关于赋值运算符前面我们已经使用过多次，赋值运算符 = ， varint num=9;num=num+1; 这里的=号是赋值运算符,不是数学义意上的相等. 常见的赋值运算符如下，前面我们使用的=是普通赋值，+=，-=等我们称为“复合赋值运算符”。

运算符	说明	示例
=	普通赋值	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

7.3 关系运算符

关系运算符我们又称为比较运算符，听到比较这个词，大家想到的就是比较大小，例如：

大象的重量(1500)>老鼠的重量(1)

兔子的寿命(3)>乌龟的寿命(1000)

我的年龄(20)==你的年龄(20)

提问：比大比小的结果是什么？

结果是对或者是错，在GO语言中，怎样表示对于错呢？

关系运算的结果是布尔类型的。

bool值只有两个

真:true

假:false

GO语言中常见的关系运算符如下：

运算符	术语	示例	结果
==	相等于	4==3	false
!=	不等于	4 != 3	true
<	小于	4 < 3	false
>	大于	4 > 3	true
<=	小于等于	4 <= 3	false
>=	大于等于	4>=1	true

由以上关系运算符链接的表达式我们称为关系表达式。

关系运算符具体使用方式如下：

package main

import (
    "fmt"
)

func main() {

    var b bool
    // 大象的重量（1500）> 老鼠的重量（1）
    b = 1500 >1
    fmt.Printf("%t\n",b)
    //兔子的寿命（3）> 乌龟的寿命（1000）
    b = 3 > 1000
    fmt.Printf("%t\n",b)
    //我的年龄（20）==你的年龄（20）
    b = 20 == 20
    fmt.Printf("%t",b)

}


输出结果如下：
true
false
true

7.4 逻辑运算符

7.4.1 常见的逻辑运算符如下：

运算符	术语	示例	结果
！	非	!a	如果a为假，则!a为真；如果a为真，则!a为假。
&&	与	a && b	如果a和b都为真，则结果为真，否则为假。
||	或	a || b	全假为假，其余为真

有逻辑运算符连接的表达式叫做逻辑表达式：

package main

import (
	"fmt"
)

func main() {
	a := 10
	b := 5
	//比较运算符返回值
	c := a > b //a > b的布尔值赋值给c

	fmt.Println(!c)

}

输出结果：
false

package main

import (
	"fmt"
)

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

	fmt.Println(a > b && b > 20)

}

输出结果如下：
false

通过以上表格我们发现：逻辑表达式的结果同样也是bool类型

package main

import (
	"fmt"
)

func main() {
	a := 10
	b := 5
	//比较运算符返回值
	c := a > b

	fmt.Printf("%T",c)

}

输出结果如下：
bool   ##输出布尔类型

a := 10
b := 20
c := a+20 > b  //表示a+20后赋值给c，再和b比较
fmt.Println(c)

输出为：
true

逻辑运算符两边放的一般都是关系表达式或者bool类型的值。

例如：

5>3 &&true

3>5||false

括号优先级>比较运算符>逻辑运算符>赋值运算符

7.4.2 案例演示

让用户输入老王的语文和数学成绩,输出以下判断是否正确,正确输出True,错误输出False

2.1)老王的语文和数学成绩都大于90分

2.2)语文和数学有一门是大于90分的

7.4.2 异常

• 编辑时异常
• 编译时异常
• 运行时异常

7.4.3 编译运行

• go build 编译
• go run 编译运行

7.4.4 注意事项

• 取余运算符不能为0
• 取余运算符
• 取余运算符不能对浮点型使用

7.5 其他运算符

运算符	术语	示例	说明
&	取地址运算符	&a	变量a的地址
*	取值运算符	*a	指针变量a所指向内存的值

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

package main

import "fmt"

func main() {
    a := 10
    //& 取地址运算符
    fmt.Println(&a)

    //*取值运算符，p 指针变量
    p := &a
    fmt.Println(*p)

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


输出结果如下：
0xc00011e058
10
123
123

7.6 运算符优先级

7.6.1 上面我们已经将运算符介绍完了，下面说一下它们的运算符优先级。

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

优先级	运算符
7	     ^      !   
6	     *       /    %    << >>&&^
5	     +      -     |      ^
4	     ==   !=   < <=    >=    >
3	     <-
2	     &&
1	     ||

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

7.6.2 示例练习

写下判断闰年的表达式,设待判断的年份变量为year.

闰年的判定(符合下面两个条件之一):

• 年份能够被400整除.(2000)
• 年份能够被4整除但不能被100整除.(2008)
• 让用户输入一个年份,如果是润年,则输出true,如果不是,则输出false.

2100/1600/1800/2009年是闰年吗？

package main

import (
	"fmt"
)

func main() {
	var year int
	var b bool
	fmt.Println("请输入年份: ")
	fmt.Scanf("%d",&year)
	b = (year%400 == 0)|| (year%4 == 0 && year%100 != 0)
	fmt.Printf("%t",b)

}

注意：逻辑与的优先级要高于逻辑或。