上一节:
下一节:

  Go语言 运算符

  • 运算符

    运算符是一个符号，告诉编译器执行特定的数学或逻辑操作。Go语言包含丰富的内置运算符，并提供以下类型的运算符-
    • 算术运算符
    • 关系运算符
    • 逻辑运算符
    • 按位运算符
    • 赋值运算符
    • 杂项运算符
    本教程逐一说明算术，关系，逻辑，按位，赋值和杂项运算符。

  • 算术运算符

    下表显示了Go语言支持的所有算术运算符。假设变量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

import "fmt"

func main() {

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

   c = a + b
   fmt.Printf("Line 1 - Value of c is %d\n", c )
   
   c = a - b
   fmt.Printf("Line 2 - Value of c is %d\n", c )
   
   c = a * b
   fmt.Printf("Line 3 - Value of c is %d\n", c )
   
   c = a / b
   fmt.Printf("Line 4 - Value of c is %d\n", c )
   
   c = a % b
   fmt.Printf("Line 5 - Value of c is %d\n", c )
   
   a++
   fmt.Printf("Line 6 - Value of a is %d\n", a )
   
   a--
   fmt.Printf("Line 7 - Value of a is %d\n", a )
}
    尝试一下

  • 关系运算符

    下表列出了Go语言支持的所有关系运算符。假设变量A持有10，变量B持有20，则-
    操作符 描述 例子
    == 它检查两个操作数的值是否相等。如果是，则条件成立。 （A == B）为假。
    != 它检查两个操作数的值是否相等。如果值不相等，则条件为真。 （A！= B）为真。
    > 它检查左操作数的值是否大于右操作数的值；如果是，则条件成立。 （A> B）为假。
    < 它检查左操作数的值是否小于右操作数的值；如果是，则条件成立。 （A < B）为真。
    >= 它检查左操作数的值是否大于或等于右操作数的值；如果是，则条件成立。 （A> = B）为假。
    <= 它检查左操作数的值是否小于或等于右操作数的值；如果是，则条件成立。 （A <= B）为真。
    示例：： 
    
package main

import "fmt"

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

   if( a == b ) {
      fmt.Printf("Line 1 - a is equal to b\n" )
   } else {
      fmt.Printf("Line 1 - a is not equal to b\n" )
   }
   if ( a < b ) {
      fmt.Printf("Line 2 - a is less than b\n" )
   } else {
      fmt.Printf("Line 2 - a is not less than b\n" )
   } 
   if ( a > b ) {
      fmt.Printf("Line 3 - a is greater than b\n" )
   } else {
      fmt.Printf("Line 3 - a is not greater than b\n" )
   }
   
   /* Lets change value of a and b */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("Line 4 - a is either less than or equal to  b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("Line 5 - b is either greater than  or equal to b\n" )
   }
}
    尝试一下

  • 逻辑运算符

    下表列出了Go语言支持的所有逻辑运算符。假设变量A为1，变量B为0，则-
    操作符 描述 例子
    && 称为逻辑AND运算符。如果两个操作数都不为零，则条件为true。 （A && B）为false。
    || 称为逻辑或运算符。如果两个操作数中的任何一个都不为零，则条件为true。 （A || B）为true。
    ！ 称为逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为true，则逻辑非运算符将为false。 ！（A && B）为true。
    示例：： 
    
package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("Line 1 - Condition is true\n" )
   }
   if ( a || b ) {
      fmt.Printf("Line 2 - Condition is true\n" )
   }
   
   /* lets change the value of  a and b */
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("Line 3 - Condition is true\n" )
   } else {
      fmt.Printf("Line 3 - Condition is not true\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("Line 4 - Condition is true\n" )
   }
}
    尝试一下

  • 按位运算符

    按位运算符对位进行运算并执行逐位操作。＆，| 和 ^ 的真值表如下-
    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
    假设A = 60; 和B =13。以二进制格式，它们将如下所示- 
    
A = 0011 1100

B = 0000 1101

-----------------

A＆B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

〜A = 1100 0011
    下表列出了go语言支持的按位运算符。假设变量A为60，变量B为13，则-
    操作符 描述 例子
    & 如果两个操作数中都存在二进制AND运算符，则会将一位复制到结果中。 （A＆B）将得到12，即0000 1100
    | 如果任一操作数中存在二进制或运算符，则会对其进行复制。 （A | B）将得到61，即0011 1101
    ^ 如果在一个操作数中设置了该位，但不是在两个操作数中都设置了位，则二进制XOR运算符将复制该位。 （A ^ B）将得到49，即0011 0001
    << 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 A << 2 将得到240，即1111 0000
    >> 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 A >> 2将得到15，即0000 1111
    示例：： 
    
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("Line 1 - Value of c is %d\n", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("Line 2 - Value of c is %d\n", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("Line 3 - Value of c is %d\n", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("Line 4 - Value of c is %d\n", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("Line 5 - Value of c is %d\n", c )
}
    尝试一下

  • 赋值运算符

    下表列出了Go语言支持的所有赋值运算符-
    操作符 描述 例子
    = 简单的赋值运算符，将值从右侧操作数分配到左侧操作数 C = A + B将A + B的值赋给C
    += 添加AND赋值运算符，它将右操作数添加到左操作数并将结果分配给左操作数 C + = A等于C = C + A
    -= 减去AND赋值运算符，它从左操作数中减去右操作数，并将结果分配给左操作数 C -= A等于C = C-A
    *= 将AND运算符相乘，将右操作数与左操作数相乘，并将结果分配给左操作数 C *= A等效于C = C * A
    /= 除法AND赋值运算符，它将左操作数除以右操作数，并将结果分配给左操作数 C /= A等于C = C / A
    ％= 模AND赋值运算符，它使用两个操作数取模并将结果赋给左操作数 C％= A等于C = C％A
    <<= 左移AND赋值运算符 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"

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

   c =  a
   fmt.Printf("Line 1 - =  Operator Example, Value of c = %d\n", c )

   c +=  a
   fmt.Printf("Line 2 - += Operator Example, Value of c = %d\n", c )

   c -=  a
   fmt.Printf("Line 3 - -= Operator Example, Value of c = %d\n", c )

   c *=  a
   fmt.Printf("Line 4 - *= Operator Example, Value of c = %d\n", c )

   c /=  a
   fmt.Printf("Line 5 - /= Operator Example, Value of c = %d\n", c )

   c  = 200; 

   c <<=  2
   fmt.Printf("Line 6 - <<= Operator Example, Value of c = %d\n", c )

   c >>=  2
   fmt.Printf("Line 7 - >>= Operator Example, Value of c = %d\n", c )

   c &=  2
   fmt.Printf("Line 8 - &= Operator Example, Value of c = %d\n", c )

   c ^=  2
   fmt.Printf("Line 9 - ^= Operator Example, Value of c = %d\n", c )

   c |=  2
   fmt.Printf("Line 10 - |= Operator Example, Value of c = %d\n", c )
}
    尝试一下

  • 杂项运算符

    Go语言还支持其他一些重要的运算符，包括sizeof和？：
    操作符 描述 例子
    & 返回变量的地址。 ＆a; 提供变量的实际地址。
    * 指向变量的指针。 *a; 提供指向变量的指针。
    示例：： 
    
package main

import "fmt"

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

   /* example of type operator */
   fmt.Printf("Line 1 - Type of variable a = %T\n", a );
   fmt.Printf("Line 2 - Type of variable b = %T\n", b );
   fmt.Printf("Line 3 - Type of variable c= %T\n", c );

   /* example of & and * operators */
   ptr = &a /* 'ptr' now contains the address of 'a'*/
   fmt.Printf("value of a is  %d\n", a);
   fmt.Printf("*ptr is %d.\n", *ptr);
}
    尝试一下

  • Go中的运算符优先级

    运算符优先级确定表达式中术语的分组。这会影响表达式的计算方式。某些运算符的优先级比其他运算符高；例如，乘法运算符的优先级高于加法运算符。例如x = 7 + 3 * 2; 在这里，x被赋值为13，而不是20，因为运算符*的优先级比+高，因此它首先与3 * 2相乘，然后加到7。在这里，优先级最高的运算符出现在表格的顶部，而优先级最低的运算符出现在表格的底部。在表达式中，优先级较高的运算符将首先被计算。
    类别 运算符 关联性
    后缀 () [] ->. ++ -- 左到右
    一元 +- ! ~ ++ --（type）*＆sizeof 右到左
    乘除模 * / ％ 左到右
    加减 + - 左到右
    位移 << >> 左到右
    关系型 <<=>> = 左到右
    平等 ==！= 左到右
    按位与 & 左到右
    按位异或 ^ 左到右
    按位或 | 左到右
    逻辑与 && 左到右
    逻辑或 || 左到右
    赋值 = += -= *= /= ％= >>= <<= ＆= ^= |= 右到左
    逗号 , 左到右
    示例：： 
    
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("Value of (a + b) * c / d is : %d\n",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("Value of ((a + b) * c) / d is  : %d\n" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("Value of (a + b) * (c / d) is  : %d\n",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("Value of a + (b * c) / d is  : %d\n" ,  e );  
}
    尝试一下
上一节:
下一节: