Go 语言运算符

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

• 算术运算符

• 关系运算符

• 逻辑运算符

• 按位运算符

• 赋值运算符

• 杂项运算符

算术运算符

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

• 加法： “ +”运算符将两个操作数相加。例如，x + y。

• 减法： “-”运算符减去两个操作数。例如，x-y。

• 乘法： '*' 运算符将两个操作数相乘。例如，x * y。

• 除法： '/' 运算符将第一个操作数除以第二个。例如，x / y。

• 求模：当第一个操作数除以第二个操作数时，'％'运算符返回余数。例如，x％y。

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

package main

import "fmt"

func main() {
    p := 34
    q := 20

    // 加法
    result1 := p + q
    fmt.Printf("计算结果 p + q = %d", result1)

    // 减法
    result2 := p - q
    fmt.Printf("\n计算结果 p - q = %d", result2)

    // 乘法
    result3 := p * q
    fmt.Printf("\n计算结果 p * q = %d", result3)

    // 除法
    result4 := p / q
    fmt.Printf("\n计算结果 p / q = %d", result4)

    // 求模
    result5 := p % q
    fmt.Printf("\n计算结果 p %% q = %d", result5)
}

输出：

计算结果 p + q = 54
计算结果 p - q = 14
计算结果 p * q = 680
计算结果 p / q = 1
计算结果 p % q = 14

关系运算符

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

• '=='（等于）运算符检查两个给定的操作数是否相等。如果相等，则返回true。否则，它返回false。例如，5 == 5将返回true。

• '!='（不等于）运算符检查两个给定的操作数是否相等。如果不相等，则返回true。否则，它返回false。它是'=='运算符的精确布尔补码。例如，5!= 5将返回false。

• '>'（大于）运算符检查第一个操作数是否大于第二个操作数。如果大于，则返回true。否则，它返回false。例如，6> 5将返回true。

• '<'（小于）运算符检查第一个操作数是否小于第二个操作数。如果小于，则返回true。否则，它返回false。例如，6 <5将返回false。

• '> ='（大于等于）运算符检查第一个操作数是否大于或等于第二个操作数。如果大于等于，则返回true。否则，它返回false。例如，5> = 5将返回true。

• “ <=”（小于等于）运算符检查第一个操作数是否小于或等于第二个操作数。如果小于等于，则返回true。否则，它返回false。例如，5 <= 5也将返回true。

package main

import "fmt"

func main() {
    p := 34
    q := 20

    // ‘=='(相等)
    result1 := p == q
    fmt.Println(result1)

    // ‘!='(不等于)
    result2 := p != q
    fmt.Println(result2)

    // ‘<‘(小于)
    result3 := p < q
    fmt.Println(result3)

    // ‘>'(大于)
    result4 := p > q
    fmt.Println(result4)

    // ‘>='(大于等于)
    result5 := p >= q
    fmt.Println(result5)

    // ‘<='(小于等于)
    result6 := p <= q
    fmt.Println(result6)

}

输出：

false
true
false
true
true
false

逻辑运算符

• 逻辑AND：当考虑的两个条件都满足时，&&操作符返回true。否则返回false。例如，当a和b都为真(即非零)时，a && b返回真。

• 逻辑或： 当其中一个(或两个)条件满足时，“||”操作符返回true。否则返回false。例如，如果a或b中的一个为真(即非零)，|| b返回true。当然，当a和b都为真时，它返回true。

• 逻辑非： 即不满足考虑条件，“!” 运算符返回true。否则，它返回false。例如，如果a为假，即a = 0，则!a返回true。

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个按位运算符可按位工作或用于逐位操作。以下是按位运算符：

• ＆（按位与）：将两个数字作为操作数，并对两个数字的每一位进行“与”运算。仅当两个位均为1时，AND的结果才为1。

• | （按位或）：将两个数字作为操作数，并对两个数字的每一位进行“或”运算。两个位中的任何一个为1，OR的结果为1。

• ^（按位XOR）：将两个数字作为操作数，并对两个数字的每一位进行XOR。如果两个位不同，则XOR的结果为1。

• <<（左移）：取两个数字，左移第一个操作数的位，第二个操作数决定移位的位数。

• >>（右移）：取两个数字，右移第一个操作数的位，第二个操作数决定移位的位数。

• ＆^（AND NOT）：(按位清除)运算符，该运算符的实际操作为&(^)操作。

package main

import "fmt"

func main() {
    p := 134
    q := 320

    // & (AND)
    result1 := p & q
    fmt.Printf("计算结果 p & q = %d", result1)

    // | (OR)
    result2 := p | q
    fmt.Printf("\n计算结果 p | q = %d", result2)

    // ^ (XOR)
    result3 := p ^ q
    fmt.Printf("\n计算结果 p ^ q = %d", result3)

    // << (左移)
    result4 := p << 1
    fmt.Printf("\n计算结果 p << 1 = %d", result4)

    // >> (右移)
    result5 := p >> 1
    fmt.Printf("\n计算结果 p >> 1 = %d", result5)

    // &^ (AND NOT)
    result6 := p &^ q
    fmt.Printf("\n计算结果 p &^ q = %d", result6)

}

输出：

计算结果 p & q = 0
计算结果 p | q = 454
计算结果 p ^ q = 454
计算结果 p << 1 = 268
计算结果 p >> 1 = 67
计算结果 p &^ q = 134

赋值运算符

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

• “ =”（简单赋值）：这是最简单的赋值运算符。该运算符用于将右侧的值分配给左侧的变量。

• “ + =”（加法赋值）：此运算符是'+'和'='运算符的组合。该运算符首先将左侧变量的当前值添加到右侧的值，然后将结果分配给左侧的变量。

• “-=”（减法赋值）：此运算符是'-'和'='运算符的组合。该运算符首先从右侧的值中减去左侧变量的当前值，然后将结果分配给左侧的变量。

• “ * =”（乘法赋值）：此运算符是'*'和'='运算符的组合。该运算符首先将左侧变量的当前值乘以右侧值，然后将结果分配给左侧变量。

• “ / =”（除法赋值）：此运算符是'/'和'='运算符的组合。该运算符首先将左侧变量的当前值除以右侧值，然后将结果分配给左侧变量。

• “％=”（模赋值）：此运算符是“％”和“ =”运算符的组合。该运算符首先对左侧变量的当前值乘以右侧变量的值，然后将结果赋给左侧变量。

• “＆=”（按位与赋值）：此运算符是'＆'和'='运算符的组合。该运算符首先将左侧变量的当前值与右侧变量进行“按位与”运算，然后将结果分配给左侧变量。

• “ ^ =”（按位异或）：此运算符是'^'和'='运算符的组合。该运算符首先将左侧变量的当前值与右侧变量进行“按位异或”，然后将结果分配给左侧变量。

• “ | =”（按位或）：此运算符是“ |”和'='运算符的组合。该运算符首先将左边变量的当前值与右边的值“按位或”，然后将结果分配给左边的变量。

package main 
    
import "fmt"
    
func main() { 
   var p int = 38
    var q int = 70
       
   // “=”(简单赋值) 
   p = q 
   fmt.Println(p) 
       
   // “+=”(加法赋值) 
    p += q 
   fmt.Println(p) 
       
   //“-=”(减法赋值) 
   p-=q 
   fmt.Println(p) 
       
   // “*=”(乘法赋值) 
   p*= q 
   fmt.Println(p) 
       
   // “/=”(除法赋值) 
    p /= q 
   fmt.Println(p) 
      
    // “%=”(求模赋值) 
    p %= q 
   fmt.Println(p) 
      
}

输出：

70
140
70
4900
70
0

杂项运算符

• ＆：此运算符返回变量的地址。

• *：此运算符提供指向变量的指针。

• <-：该运算符的名称为接收。它用于从通道接收值。

package main 
    
import "fmt"
    
func main() { 
  a := 94
     
//使用运算符（＆）和
//指针间接（*）运算符
  b := &a  
  fmt.Println(*b)  
  *b = 67 
  fmt.Println(a)  
}

输出：

94
67