Golangg的逻辑运算

先说一下运算，运算符有：

* 算术运算符
* 关闭元算符
* 逻辑运算符
* 位运算符
* 赋值运算符
* 其他运算符

算术运算符

假如A值为10，B值为20

运算符	描述	实例
+	相加	A + B 输出结果 30
-	相减	A - B 输出结果 -10
*	相乘	A * B 输出结果 200
/	相除	B / A 输出结果 2
%	求余	B % A 输出结果 0
++	自增	A++ 输出结果 11
--	自减	A-- 输出结果 9

举例看一下

package main
//个人博客 http://www.wulaoer.org
import (
	"fmt"
)

func main()  {
	var a int = 21    //定义变量a的值，为了养成一个好习惯，建议把类型也加上，方便以后处理
	var b int = 10    //b也是一样的
	var c int         //申明变量c的类型

	c = a + b
	fmt.Println("计算a加b的和为c:",c)   //运算符的加
	c = a - b
	fmt.Println("计算a减b的差为c:",c)   //运算符的减
	c = a * b
	fmt.Println("计算a乘以b的积c为:",c)  //运算符的乘
	c = a / b
	fmt.Println("计算a除以b的商c为:",c)  //运算符的除
	c = a % b
	fmt.Println("计算a除以b的余为c:",c)  //运算符求余
	a++
	fmt.Println("计算a的自增为",a)       //运算符自增
	a--
	fmt.Println("a自减为",a)           //运算符自减
}

打印结果：

计算a加b的和为c: 31
计算a减b的差为c: 11
计算a乘以b的积c为: 210
计算a除以b的商c为: 2
计算a除以b的余为c: 1
计算a的自增为 22
a自减为 21

关系运算符

假如A值为10，B值为20

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

因为举例的时候需要用到后面的判断，不过没关系，就当提前预习了，所以我们可以看一下例子 举例看一下：

package main
//关系原算符
//个人博客 http://www.wulaoer.org
import "fmt"

func main()  {
	var a int = 21
	var b int = 10

	if ( a == b) {
		fmt.Println("判断a等于b的值==")
	} else {
		fmt.Println("a不等于b的值==")
	}

	if ( a != b) {
		fmt.Println("a不等于b的值是!=")
	} else {
		fmt.Println("a等于b的值是!=")
	}

	if ( a > b ) {
		fmt.Println("判断a大于b的值>")
	} else {
		fmt.Println("判断a不大于b的值>")
	}
	if ( a < b ) {
		fmt.Println("a小于b的值<")
	} else {
		fmt.Println("a不小于b的值<")
	}

	if ( a >= b ) {
		fmt.Println("a大于等于b的值>=")
	} else {
		fmt.Println("a不大于等于b的值>=")
	}

	if ( a <= b ) {
		fmt.Println("a小于等于b的值<=")
	} else {
		fmt.Println("a不小于等于b的值")
	}
}

打印结果：

a不等于b的值==
a不等于b的值是!=
判断a大于b的值>
a不小于b的值<
a大于等于b的值>=
a不小于等于b的值

逻辑运算符

假定A值为True，B值为False

运算符	描述	实例
&&	逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。	(A && B) 为 False
||	逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。	(A || B) 为 True
!	逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。	!(A && B) 为 True

看下面的例子

package main
import "fmt"
//个人博客 http://www.wulaoer.org
func main()  {
	var a bool = true
	var b bool = true
	if ( a && b ) {  //两者均为true，者为true，否为false
		fmt.Println("逻辑a&&b的条件，两者均为true")
	} else {
		fmt.Println("逻辑a&&b的条件，其中有一个为false")
	}
	if ( a || b ) {  //两者有一个为true，者为true，否为false
		fmt.Println("逻辑a||b的条件，两者有一个为true")
	} else {
		fmt.Println("逻辑a||b的条件，两者都为false")
	}
	if ( !( a && b) ) {  //如果条件为true，者逻辑NOT的条件为false
		fmt.Println("逻辑a&&b的条件为false，!(a&&b)为true")
	} else {
		fmt.Println("逻辑a&&b的条件为true，!(a&&b)为false")
	}
}

执行结果：

逻辑a&&b的条件，两者均为true
逻辑a||b的条件，两者有一个为true
逻辑a&&b的条件为true，!(a&&b)为false

位运算符

位运算符对整数在内存中的二进制进行操作。

p	q	p&q	p|q	p^q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

go支持的位运算如下：假定A为60，B为13

运算符	描述	实例
&	按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。	(A & B) 结果为 12, 二进制为 0000 1100
|	按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或	(A | B) 结果为 61, 二进制为 0011 1101
^	按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。	(A ^ B) 结果为 49, 二进制为 0011 0001
<<	左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	A << 2 结果为 240 ，二进制为 1111 0000
>>	右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。	A >> 2 结果为 15 ，二进制为 0000 1111

举个例子：

package main
import "fmt"
//个人博客 http://www.wulaoer.org
//位运算例子
func main()  {
	var a uint = 0
	var b uint = 1
	var c uint = 0
	c = a & b  //两位相与
	fmt.Println("为运算&,c的值",c)
	c = a | b  //两位相或
	fmt.Println("为运算|,c的值",c)
	c = a ^ b  //两位相异或
	fmt.Println("为运算^,c的值",c)
}

执行结果：

为运算&,c的值 0
为运算|,c的值 1
为运算^,c的值 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
<<=	左移后赋值	C <<= 2 等于 C = C << 2
>>=	右移后赋值	C >>= 2 等于 C = C >> 2
&=	按位与后赋值	C &= 2 等于 C = C & 2
^=	按位异或后赋值	C ^= 2 等于 C = C ^ 2
|=	按位或后赋值	C |= 2 等于 C = C | 2

举例看一下：

package main
import "fmt"
//个人博客 http://www.wulaoer.org
//赋值运算符
func main()  {
	var a int = 20
	var c int
	c = a
	fmt.Println("把a的值赋值给c，为",c)
	c += a
	fmt.Println("c等于a加c的值",c)
	c -= a
	fmt.Println("c等于c减a的值",c)
	c *= a
	fmt.Println("c等于c乘以a的值",c)
	c /= a
	fmt.Println("c等于c除以a的值",c)
	c %= a
	fmt.Println("c等于c除以a的余数",c)
	c = 200;  //重新赋值c
	c <<= 2
	fmt.Println("c左移两位后的值赋值给c",c)
	c >>= 2
	fmt.Println("c右移两位后的值赋值给c",c)
	c &= 2
	fmt.Println("c按位与后的值赋值给c",c)
	c ^= 2
	fmt.Println("c按位异或后的值赋值给c",c)
	c |= 2
	fmt.Println("c按位或后的值赋值给c",c)
}

打印结果：

把a的值赋值给c，为 20
c等于a加c的值 40
c等于c减a的值 20
c等于c乘以a的值 400
c等于c除以a的值 20
c等于c除以a的余数 0
c左移两位后的值赋值给c 800
c右移两位后的值赋值给c 200
c按位与后的值赋值给c 0
c按位异或后的值赋值给c 2
c按位或后的值赋值给c 2

其他运算符

运算符	描述	实例
&	返回变量存储地址	&a; 将给出变量的实际地址。
*	指针变量。	*a; 是一个指针变量

举例说明一下：

package main
import "fmt"
//个人博客 http://www.wulaoer.org
//其他运算符
func main()  {
	var a int = 4
	var b int32
	var c  float32
	var ptr  *int
	fmt.Printf("变量a的数据类型为 = %T\n",a)
	fmt.Printf("变量b的数据类型为 = %T\n",b)
	fmt.Printf("变量c的数据类型为 = %T\n",c)
	ptr = &a //ptr包含了a变量的内存地址
	fmt.Printf("变量ptr的数据类型为 %d\n", ptr)
	fmt.Printf("变量*ptr的数据类型为 %d\n", *ptr)
}

打印结果：

变量a的数据类型为 = int
变量b的数据类型为 = int32
变量c的数据类型为 = float32
变量ptr的数据类型为 824634327040
变量*ptr的数据类型为 4

运算符优先级

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

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

举例说明一下：

package main
//个人博客 http://www.wulaoer.org
import "fmt"
//运算优先级
func main()  {
	var a int = 20
	var b int = 10
	var c int = 15
	var d int = 5
	var e int;
	e = (a + b) * c / d;      // ( 30 * 15 ) / 5
	fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );
	e = ((a + b) * c) / d;    // (30 * 15 ) / 5
	fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e );
	e = (a + b) * (c / d);   // (30) * (15/5)
	fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );
	e = a + (b * c) / d;     //  20 + (150/5)
	fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e );
}

打印结果：

(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50

这是golong的基础运算方法，可以参考一下。