Golang语言学习笔记（四）

GoLang中的运算符

1.Golang内置运算符

1.算数运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	取余

2.关系运算符

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

3.逻辑运算符

运算符	描述
&&	逻辑 AND 运算符，如果两边的额操作数都是true，则为true，否则为false
||	逻辑 OR 运算符，如果两边的额操作数有一个为true，则为true，否则为false
!	逻辑 NOT 运算符，如果条件为true，则为false，否则为true

4.位运算符

运算符	描述
&	两位均为1才为1
|	两位有一个为1就为1
^	相异或 两位不一样则为1
<<	左移n位就是乘以2的n次方。 "a<<b" 是把a的各二进位全部左移b位，高位丢弃，低位补0
>>	右移n位就是除以2的n次方。

5.赋值运算符

运算符	描述
=	简单的赋值运算，将一个表达式的值赋给一个左值
+=	相加后在赋值
*=	相减后在赋值
/=	相乘后在赋值
%=	取余后在赋值

代码：
Demo09/main.go

package main
import (
	"fmt"
)


//定义一个方法

func test() bool {
	fmt.Println("test....")
	return true
}
func main(){

	//1.算数运算符
	/*
		+|-|*|/|%
		/ 两个整数相除，结果不为整数时，去掉小数部分，保留整数部分,如果时浮点数相除，会保留小数部分
		% 取余=被除数 - （被除数/除数） * 除数

		注意：++（自增）和--（自减）在Go语言中时单独的语句，不是运算符
	
	*/

	// var a = 6
	// var b = 3
	// fmt.Println(a + b)//9
	// fmt.Println(a - b)//3
	// fmt.Println(a * b)//18
	// fmt.Println(a / b)//2


	// 两个整数相除，结果不为整数时，去掉小数部分，保留整数部分,如果时浮点数相除，会保留小数部分
	// var n1 = 10
	// var n2 = 3
	// fmt.Println(n1 / n2)//3


	// var n1 = 10.0
	// var n2 = 3.0
	// fmt.Println(n1 / n2)//3.3333333333333335

	//% 取余=被除数 - （被除数/除数） * 除数
	// var n1 = 10
	// var n2 = 3
	// fmt.Println(n1 % n2)//1
	// fmt.Println(-10 % 3)//-1
	// fmt.Println(10 % -3)//1

	//在Golanlg中，++ 和 --只能独立使用, 错误写法如下
	// var i int =8
	// var a int 
	// a = i ++//错误， i++只能独立使用:syntax error: unexpected ++ at end of statement
	// a = i-- //错误，i--只能独立使用:syntax error: unexpected -- at end of statement
	// fmt.Println(a)

	//在Golang中没有前++错误写法如下：
	// var a = 12
	// --a//错误写法
	// a--//正确写法，结果为11
	// fmt.Println(a)

	//2.关系运算符

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

	//演示关系运算符的使用

	// var a1 = 9
	// var a2 = 8
	// fmt.Println(a1 == a2)//false
	// fmt.Println(a1 != a2)//true
	// fmt.Println(a1 > a2)//true
	// fmt.Println(a1 >= a2)//true
	// fmt.Println(a1 < a2)//false
	// fmt.Println(a1 <= a2)//false


	//关系运算符主要用于条件判断
	// var a1 = 9
	// var a2 = 8
	// flag := a1 > a2
	// if flag {
	// 	fmt.Println("a1>a2")//a1>a2
	// }

	// if a1 == a2 {
	// 	fmt.Println("a1等于a2")
	// } else {
	// 	fmt.Println("a1不等于a2")//a1不等于a2
	// }

	/*
		&& 逻辑 AND 运算符，如果两边的额操作数都是true，则为true，否则为false
		|| 逻辑 OR 运算符，如果两边的额操作数有一个为true，则为true，否则为false
		! 逻辑 NOT 运算符，如果条件为true，则为false，否则为true
	*/
	// var a = 23
	// var b = 8

	// fmt.Println(a > 10 && b < 10)//true
	// fmt.Println(a > 24 && b < 10)//false
	// fmt.Println(a > 5 && b < 6)//false
	// fmt.Println(a > 25 || b < 6)//false

	// fmt.Println(a > 10 || b < 10)//true
	// fmt.Println(a > 24 || b < 10)//true
	// fmt.Println(a > 5 || b < 6)//true
	// fmt.Println(a > 25 || b < 6)//false

	// flag := true
	// fmt.Println(!flag)//false


	//逻辑与和逻辑或短路

	/*
		输出：
		test....
		执行
		当第一个条件已经为true时，第二个条件会执行，两个条件都为true，整个条件返回true，执行打印
	*/
	// var a = 10
	// if a > 9 && test() {
	// 	fmt.Println("执行")
	// }

	/*
		输出： 空
		当第一个条件已经为false时，第二个条件不会执行，整个条件返回false，不执行打印
	*/
	// var a = 10
	// if a > 11 && test() {
	// 	fmt.Println("执行")
	// }

	/*
		输出： 
		test....
		执行
		当地一个条件为false时，第二个条件需要执行，有一个为true，整个条件返回true，执行打印。
	*/
	// var a = 10
	// if a > 11 || test() {
	// 	fmt.Println("执行")
	// }


	/*
		输出：
		test....
		执行
		当地一个条件为false时，第二个条件需要执行，有一个为true，整个条件返回true，执行打印。
	*/
	// var a = 10
	// if a > 11 || test() {
	// 	fmt.Println("执行")
	// }

	/*
		输出：
		执行
		当地一个条件为true时，第二个条件不需要执行，有一个为true，整个条件返回true，执行打印。
	*/
	// var a = 10
	// if a > 9 || test() {
	// 	fmt.Println("执行")
	// }

	/*
		= 简单的赋值运算，将一个表达式的值赋给一个左值
		+= 相加后在赋值
		*= 相减后在赋值
		/= 相乘后在赋值
		%= 取余后在赋值
	*/

	//赋值运算
	// var a = 20
	// a = 21
	// fmt.Println(a)//21

	// var a = 23 +1
	// fmt.Println(a)//24

	// var a = 10
	// b := a
	// fmt.Println(b)//10

	// var a = 10
	// b := a + 2
	// fmt.Println(b)//12

	// var a = 10
	// a += 2 //等价于a = a + 2
	// fmt.Println(a)//12

	// var a = 10
	// a -= 2 //等价于a = a - 2
	// fmt.Println(a)//8

	// var a = 10
	// a *= 2 //等价于a = a * 2
	// fmt.Println(a)//20

	// var a = 10
	// a /= 3 //等价于a = a / 3
	// fmt.Println(a)//3，两个整数相除，结果为整数，舍弃小数部分

	// var a = 10.0
	// a /= 3.0 //等价于a = a / 3.0
	// fmt.Println(a)//3.3333333333333335，两个浮点数相除，结果小数

	// var a = 10
	// a %= 3//等价于a = a % 3
	// fmt.Println(a)//1

	/*
		位运算符，对整数在内存中的二进制位进行操作
		& 两位均为1才为1
		| 两位有一个为1就为1
		^ 相异或  两位不一样则为1
		<< 左移n位就是乘以2的n次方。 "a<<b" 是把a的各二进位全部左移b位，高位丢弃，低位补0
		>> 右移n位就是除以2的n次方。

	*/

	// var a = 5   //101
	// var b = 2   //010


	// fmt.Println("a&b=",a&b)//000   十进制值：0
	// fmt.Println("a|b=",a|b)//111   十进制值：7
	// fmt.Println("a^b=",a^b)//111   十进制值：7
	// fmt.Println("a<<b=",a<<b)//10100 十进制值：20, 5 * 2的2次方
	// fmt.Println("a>>b=",a>>b)//001  十进制值：1， 5 / （2的2次方）



	//----------------------练习---------------------------
	//1.有两个变量，a和b，要求将其进行交换，最终打印结果
	// var a = 34
	// var b = 10
	// t := a
	// a = b
	// b = t
	// fmt.Printf("a=%v,b=%v",a,b)//a=10,b=34
	//2.有两个变量，a和b，要求将其进行交换（不能使用中间变量），最终打印结果
	// var a = 34
	// var b = 10

	// a = a + b
	// b = a - b
	// a = a - b
	// fmt.Printf("a=%v,b=%v",a,b)//a=10,b=34
	//3.假如还有100天房价，请输出:距离放假还有xx个星期零xx天

	// var days = 100
	// var week = 100 / 7
	// var day = days % 7
	// fmt.Printf("距离放假还有%v个星期零%v天", week, day)//距离放假还有14个星期零2天
	//4.定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：C = (F - 32)/1.8，请求出华氏温度对应的摄氏温度
	
	var F float64= 100 //华氏温度
	C := (F - 32) / 1.8
	fmt.Printf("100度华氏温度对应的设施温度时%.2f",C)//100度华氏温度对应的设施温度时37.78





}