go语言变量与常量 go语言%c

文章目录

• 04 Go语言运算符

• 4.1 Go语言内置的运算符有
• 4.2 算术运算符
• 4.3 关系运算符
• 4.4 逻辑运算符
• 4.5 位运算符
• 4.6 赋值运算符
• 4.7 其他运算符
• 4.7 运算符优先级

04 Go语言运算符

4.1 Go语言内置的运算符有

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

4.2 算术运算符

下面列出了Go语言的算术运算符。

运算符	描述
+	相加
-	相减
*	相乘
/	相除（对于整数表示整除，对于浮点数是浮点除）
%	求余
++	自增1（Go只有a++，没有++a；只能作为表达式使用，不能作为赋值语句的右值）
–	自减1（Go只有a–，没有–a；且只能作为表达式使用，不能作为赋值语句的右值）

实例：

package main

import "fmt"

func main() {

   var a int = 21
   var b int = 10
   var c int

   c = a + b
   fmt.Printf("第一行 - c 的值为 %d\n", c )
   c = a - b
   fmt.Printf("第二行 - c 的值为 %d\n", c )
   c = a * b
   fmt.Printf("第三行 - c 的值为 %d\n", c )
   c = a / b
   fmt.Printf("第四行 - c 的值为 %d\n", c )
   c = a % b
   fmt.Printf("第五行 - c 的值为 %d\n", c )
   a++
   fmt.Printf("第六行 - a 的值为 %d\n", a )
   a=21   // 为了方便测试，a 这里重新赋值为 21
   a--
   fmt.Printf("第七行 - a 的值为 %d\n", a )
    
   // c = a++	// 编译错误：a++不能作为赋值语句的右值
   // c = a--	// 编译错误：a--不能作为复制语句的右值
}

4.3 关系运算符

关系运算符对两个数值进行比较，其结果是布尔类型（true/false）。

下表列出了Go语言的所有关系运算符。

运算符	描述
==	比较是否相等
!=	比较是否不等
>	比较是否大于
<	比较是否小于
>=	比较是否大于或等于
<=	比较是否小于或等于

实例：

package main

import "fmt"

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

   if( a == b ) {
      fmt.Printf("第一行 - a 等于 b\n" )
   } else {
      fmt.Printf("第一行 - a 不等于 b\n" )
   }
   if ( a < b ) {
      fmt.Printf("第二行 - a 小于 b\n" )
   } else {
      fmt.Printf("第二行 - a 不小于 b\n" )
   }
   
   if ( a > b ) {
      fmt.Printf("第三行 - a 大于 b\n" )
   } else {
      fmt.Printf("第三行 - a 不大于 b\n" )
   }
   /* Lets change value of a and b */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("第四行 - a 小于等于 b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("第五行 - b 大于等于 a\n" )
   }
}

4.4 逻辑运算符

逻辑运算符对布尔型变量进行运算，结果还是布尔型。

下表列出了Go语言中的所有逻辑运算符。

运算符	描述
&&	逻辑与。真真得真，否则为假。
||	逻辑或。假假得假，否则为真。
!	逻辑非。真变假，假变真。

实例：

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("第一行 - 条件为 true\n" )
   }
   if ( a || b ) {
      fmt.Printf("第二行 - 条件为 true\n" )
   }
   /* 修改 a 和 b 的值 */
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("第三行 - 条件为 true\n" )
   } else {
      fmt.Printf("第三行 - 条件为 false\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("第四行 - 条件为 true\n" )
   }
}

逻辑运算符的短路特性：

对于&&：如果第一个表达式为假，第二个表达式不会被执行。

对于||：如果第一个表达式为真，第二个表达式不会被执行。

package main

import "fmt"

func main() {
    var apple int = 6
    
    fmt.Println("------------------ 1")
    
    if apple > 10 && getNumber(apple) > 0 {
        fmt.Println("进入了if")
    }
    
    fmt.Println("------------------ 2")
    
    if apple > 0 && getNumber(apple) > 0 {
        fmt.Println("进入了if")
    }
    
    fmt.Println("------------------ 3")
    
    if apple > 10 || getNumber(apple) > 0 {
        fmt.Println("进入了if")
    }
    
    fmt.Println("------------------ 4")
    
    if apple > 0 || getNumber(apple) > 0 {
        fmt.Println("进入了if")
    }
}

func getNumber(a int) int {
    fmt.Println("调用了getNumber")
    return a - 5
}

4.5 位运算符

位运算符对整数的二进制位进行操作，结果仍是整数类型。

下表列出了Go语言支持的位运算符。

运算符	描述
&	按位与
|	按位或
^	按位异或
&^	按位清除
<<	左移运算符
>>	右移运算符

实例：

package main

import "fmt"

func main() {

   var a uint = 60      /* 60 = 0011 1100 */  
   var b uint = 13      /* 13 = 0000 1101 */
   var c uint = 0          

   c = a & b       /* 12 = 0000 1100 */
   fmt.Printf("第一行 - c 的值为 %d\n", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("第二行 - c 的值为 %d\n", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("第三行 - c 的值为 %d\n", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("第四行 - c 的值为 %d\n", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值为 %d\n", c )
}

4.6 赋值运算符

下表列出了Go语言的所有赋值运算符。

运算符	描述	解释
=	简单的赋值运算符	A = B，将B的值送入A
+=	相加后再赋值	A += B，将A+B的值送入A
-=	相减后再赋值	A -= B，将A-B的值送入A
*=	相乘后再赋值	A *= B，将A*B的值送入A
/=	相除后再赋值	A /= B，将A/B的值送入A
%=	求余后再赋值	A %= B，将A%B的值送入A
<<=	左移后赋值	A <<= B，将A<<B的值送入A
>>=	右移后赋值	A >>= B，将A>>B的值送入A
&=	按位与后赋值	A &= B，将A&B的值送入A
^=	按位异或后赋值	A ^= B，将A^B的值送入A
|=	按位或后赋值	A |= B，将A|B的值送入A

实例：

package main

import "fmt"

func main() {
   var a int = 21
   var c int

   c =  a
   fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %d\n", c )

   c +=  a
   fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c )

   c -=  a
   fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c )

   c *=  a
   fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c )

   c /=  a
   fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c )

   c  = 200;

   c <<=  2
   fmt.Printf("第 6行  - <<= 运算符实例，c 值为 = %d\n", c )

   c >>=  2
   fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )

   c &=  2
   fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c )

   c ^=  2
   fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c )

   c |=  2
   fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c )

}

4.7 其他运算符

运算符	描述	解释
&	取得变量的地址	&a =》得到变量a的地址
*	指针解引用	*a =》得到指针a指向的对象

实例：

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

   /*  & 和 * 运算符实例 */
   ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}

4.7 运算符优先级

下表列出了所有运算符的优先级，由上至下代表由高到低：

分类	描述	关联性
后缀	() [] -> . ++ –	左到右
单目	+ - ! ~ (type) * & sizeof	右到左
乘法	* / %	左到右
加法	+ -	左到右
移位	<< >>	左到右
关系	< <= > >=	左到右
相等	== !=	左到右
按位AND	&	左到右
按位XOR	^	左到右
按位OR	|	左到右
逻辑AND	&&	左到右
逻辑OR	||	左到右
赋值运算符	= += -= *= /= %= >>= <<= &= ^= |=	右到左
逗号	,	左到右

不必强行记忆运算符优先级，我们可以通过括号来设定哪些运算先执行，而且可读性更好。

实例：

package main

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 );  
}