围棋运算符

运算符是任何编程语言的基础。因此，如果不使用运算符，Go 语言的功能是不完整的。运算符允许我们对操作数执行不同类型的操作。在 Go 语言中，运算符可以根据其不同的功能进行分类：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 按位运算符
• 赋值运算符
• 杂项操作员

算术运算符

这些用于在 Go 语言中对操作数执行算术/数学运算：

• 加法： ‘+’运算符将两个操作数相加。例如，x+y。
• 减法： “-”运算符减去两个操作数。例如，xy。
• 乘法： ‘*’运算符将两个操作数相乘。例如，x*y。
• 除法： “/”运算符将第一个操作数除以第二个操作数。例如，x/y。
• 模数：当第一个操作数除以第二个操作数时，’%’运算符返回余数。例如，x%y。

注： – ，+， – ，*，< -和^也被称为一元运算运算符和一元运算运算符的优先级要高！ ++ 和 —运算符来自语句，它们不是表达式，因此它们不在运算符层次结构中。

例子：

Go

// Go program to illustrate the
// use of arithmetic operators
package main
  
import "fmt"
  
func main() {
   p:= 34
   q:= 20
     
   // Addition
   result1:= p + q
   fmt.Printf("Result of p + q = %d", result1)
     
   // Subtraction
   result2:= p - q
   fmt.Printf("\nResult of p - q = %d", result2)
     
   // Multiplication
   result3:= p * q
   fmt.Printf("\nResult of p * q = %d", result3)
     
   // Division
   result4:= p / q
   fmt.Printf("\nResult of p / q = %d", result4)
     
   // Modulus
   result5:= p % q
   fmt.Printf("\nResult of p %% q = %d", result5)
}

输出：

Result of p + q = 54
Result of p - q = 14
Result of p * q = 680
Result of p / q = 1
Result of p % q = 14

关系运算符

关系运算符用于比较两个值。让我们一一看看：

• ‘=='(Equal To)运算符检查两个给定的操作数是否相等。如果是，则返回 true。否则返回false。例如，5==5 将返回 true。
• ‘!='(Not Equal To)运算符检查两个给定的操作数是否相等。如果不是，则返回 true。否则返回false。它是 ‘==’运算符的精确布尔补码。例如，5!=5 将返回 false。
• ‘>'(Greater Than)运算符检查第一个操作数是否大于第二个操作数。如果是，则返回 true。否则返回false。例如，6>5 将返回 true。
• ‘<‘(Less Than)运算符检查第一个操作数是否小于第二个操作数。如果是，则返回 true。否则返回false。例如，6<5 将返回 false。
• ‘>='(Greater Than Equal To)运算符检查第一个操作数是否大于或等于第二个操作数。如果是，则返回 true。否则返回false。例如，5>=5 将返回 true。
• ‘<='(Less Than Equal To)运算符检查第一个操作数是否小于或等于第二个操作数。如果是，则返回 true。否则返回false。例如， 5<=5 也将返回 true。

例子：

去

// Go program to illustrate the
// use of relational operators
package main
  
import "fmt"
  
func main() {
   p:= 34
   q:= 20
     
   // ‘=='(Equal To)
   result1:= p == q
   fmt.Println(result1)
     
   // ‘!='(Not Equal To)
   result2:= p != q
   fmt.Println(result2)
     
   // ‘<‘(Less Than)
   result3:= p < q
   fmt.Println(result3)
     
   // ‘>'(Greater Than)
   result4:= p > q
   fmt.Println(result4)
     
   // ‘>='(Greater Than Equal To)
   result5:= p >= q
   fmt.Println(result5)
     
   // ‘<='(Less Than Equal To)
   result6:= p <= q
   fmt.Println(result6)
     
     
}

输出：

false
true
false
true
true
false

逻辑运算符

它们用于组合两个或多个条件/约束或补充考虑的原始条件的评估。

• 逻辑与：当考虑的两个条件都满足时，’&&’运算符返回 true。否则返回false。例如，当 a 和 b 都为真（即非零）时，a && b 返回真。
• 逻辑或： ‘||’当满足一个（或两个）所考虑的条件时，运算符返回 true。否则返回false。例如，一个 ||如果 a 或 b 之一为真（即非零），则 b 返回真。当然，当 a 和 b 都为真时，它返回真。
• 逻辑非： ‘!’运算符返回 true 考虑的条件不满足。否则返回false。例如，如果 a 为假，即当 a=0 时，!a 返回真。

例子：

去

// Go program to illustrate the
// use of logical operators
package main
import "fmt"
func main() {
    var p int = 23
    var q int = 60
       
    if(p!=q && p<=q){
        fmt.Println("True")
    }
       
    if(p!=q || p<=q){
        fmt.Println("True")
    }
       
    if(!(p==q)){
        fmt.Println("True")
    }
       
}

输出：

True
True
True

按位运算符

在 Go 语言中，有 6 个按位运算运算符，它们在位级别工作或用于执行逐位运算。以下是按位运算运算符：

• &（按位与）：将两个数作为操作数，对两个数的每一位进行 AND 运算。仅当两位都为 1 时，AND 的结果才为 1。
• | （按位或）：将两个数字作为操作数，并对两个数字的每一位进行 OR 运算。 OR 的结果为 1 两位中的任何一位为 1。
• ^（按位异或）：将两个数字作为操作数，并对两个数字的每一位进行异或。如果两位不同，则 XOR 的结果为 1。
• <<（左移）：取两个数，左移第一个操作数的位，第二个操作数决定移动的位数。
• >>（右移）：取两个数，第一个操作数的位右移，第二个操作数决定移位的位数。
• &^ (AND NOT)：这是一个有点明确的运算符。

例子：

去

// Go program to illustrate the
// use of bitwise operators
package main
  
import "fmt"
  
func main() {
   p:= 34
   q:= 20
     
   // & (bitwise AND)
   result1:= p & q
   fmt.Printf("Result of p & q = %d", result1)
     
   // | (bitwise OR)
   result2:= p | q
   fmt.Printf("\nResult of p | q = %d", result2)
     
   // ^ (bitwise XOR)
   result3:= p ^ q
   fmt.Printf("\nResult of p ^ q = %d", result3)
     
   // << (left shift)
   result4:= p << 1
   fmt.Printf("\nResult of p << 1 = %d", result4)
     
   // >> (right shift)
   result5:= p >> 1
   fmt.Printf("\nResult of p >> 1 = %d", result5)
     
   // &^ (AND NOT)
   result6:= p &^ q
   fmt.Printf("\nResult of p &^ q = %d", result6)
     
     
}

输出：

Result of p & q = 0
Result of p | q = 54
Result of p ^ q = 54
Result of p <> 1 = 17
Result of p &^ q = 34

赋值运算符

赋值运算符用于为变量赋值。赋值运算符左侧的操作数是赋值运算符的变量，右侧操作数的值。右侧的值必须与左侧的变量具有相同的数据类型，否则编译器将引发错误。不同类型的赋值运算符如下所示：

• “=”（简单赋值）：这是最简单的赋值运算符。此运算符用于将右侧的值分配给左侧的变量。
• “+=”（添加赋值）：这个运算符是 ‘+’ 和 ‘=’运算符。此运算符首先将左侧变量的当前值与右侧值相加，然后将结果赋给左侧变量。
• “-=”（减去赋值）：这个运算符是 ‘-‘ 和 ‘=’运算符。此运算符首先从右侧的值中减去左侧变量的当前值，然后将结果赋给左侧的变量。
• “*=”（乘法赋值）：这个运算符是 ‘*’ 和 ‘=’运算符。该运算符首先将左边变量的当前值乘以右边的值，然后将结果赋给左边的变量。
• “/=”（除法赋值）：这个运算符是 ‘/’ 和 ‘=’运算符。该运算符首先将左边变量的当前值除以右边的值，然后将结果赋给左边的变量。
• “%=”（模数赋值）：这个运算符是 ‘%’ 和 ‘=’运算符。此运算符首先将左侧变量的当前值与右侧的值相模，然后将结果赋给左侧的变量。
• “&=”（按位与赋值）：此运算符是 ‘&’ 和 ‘=’运算符。该运算符首先将左侧变量的当前值与右侧的值进行“按位与”运算，然后将结果赋给左侧的变量。
• “^=”（按位异或）：此运算符是 ‘^’ 和 ‘=’运算符。该运算符首先将左边变量的当前值与右边的值“按位异或”，然后将结果赋给左边的变量。
• “|=”（按位包含或）：此运算符是“|”的组合和 ‘=’运算符。该运算符首先将左侧变量的当前值与右侧的值进行“按位或”运算，然后将结果赋给左侧的变量。

例子：

去

// Go program to illustrate the
// use of assignment operators
package main
   
import "fmt"
   
func main() {
   var p int = 45
    var q int = 50
      
   // “=”(Simple Assignment)
   p = q
   fmt.Println(p)
      
   // “+=”(Add Assignment)
    p += q
   fmt.Println(p)
      
   //“-=”(Subtract Assignment)
   p-=q
   fmt.Println(p)
      
   // “*=”(Multiply Assignment)
   p*= q
   fmt.Println(p)
      
   // “/=”(Division Assignment)
    p /= q
   fmt.Println(p)
     
    // “%=”(Modulus Assignment)
    p %= q
   fmt.Println(p)
     
}

输出：

50
100
50
2500
50
0

杂项操作员

• &：此运算符返回变量的地址。
• *：此运算符提供指向变量的指针。
• <-：这个运算符的名字是receive。它用于从通道接收值。

例子：

去

// Go program to illustrate the
// use of Misc Operators
package main
   
import "fmt"
   
func main() {
  a := 4
    
  // Using address of operator(&) and
  // pointer indirection(*) operator
  b := &a
  fmt.Println(*b)
  *b = 7
  fmt.Println(a)
}

输出：

4
7