Golang 中的运算符

在本教程中，您将学习 Go 编程语言中使用的各种类型的运算符。
我们将进一步讨论这些运算符如何用于创建构成 Go 代码的简单易懂的表达式。

Golang 中的运算符是什么？

运算符是每种编程语言的基本组成部分。任何编程语言中的运算符都是一个符号，表示执行一些数学计算或函数。运算符用于对操作数（变量和值）执行特定操作。操作数是运算符接受的输入或参数之一。例如，20 + 30 =? 的加法是一个由操作数和运算符组成的表达式，数字 20 和 30 代表输入或操作数，而符号“+”、“=”构成运算符？

运算符可以根据操作数参与操作的类型分为一元和二元。

•     一元运算符：- 作用于一个操作数的运算符。
•    二元运算符：- 作用于两个操作数的运算符。

Golang 中运算符的类型有哪些？

Golang 支持与其他编程语言类似的运算符，例如：

1. 符号运算符
2. 赋值运算符
3. 递增和递减运算符
4. 算术运算符
5. 布尔运算符
6. 比较运算符
7. 位运算符  

在接下来的几节中，我们将单独讨论每个运算符。

Golang 中的符号运算符

符号运算符表示 Go 编程语言中值的符号。主要有两种类型的符号运算符。

正号（“+”）和负号（“-”）运算符表示 Golang 中声明的变量的整数值的符号，无论是正数还是负数。让我们通过下面的简单 Go 程序来理解这一点。

示例

package main
import "fmt"

func main() {

 var s = 1
// -(-1)= +1
fmt.Println(" + sign operator prints positive numbers ")
 fmt.Println(-(-s))
// -1 = -1 
fmt.Println(" - sign operator prints negative numbers ")
   fmt.Println(-s)
}

输出

+ sign operator prints positive numbers 
1
 - sign operator prints negative numbers 
-1

在上面的程序中，变量 s 使用 var 关键字声明，负号表示整数的符号是正数还是负数。

递增和递减运算符

Go 支持递增和递减操作，与许多其他编程语言一样，用于增加（递增）或减少（递减）值。表示递增运算符的符号是“++”，递减运算符是“--”。假设变量 x 声明并赋值为 10。即 var x = 10。

让我们通过一个例子来理解这个概念

示例

package main
import "fmt"

func main() {

    x := 10

    x++  //increment operator x=x+1=10+1=11
    x++    //increment operator  x=11+1=12

    fmt.Println("The varaiable x is incremented two times ",x)

    x--      // decrement  operator x=12,x-1=12-1=11
    fmt.Println("The variable x is decremented one time ", x)
}

输出

The varaiable x is incremented two times  12
The variable x is decremented one time  11

算术运算符

算术运算符用于在操作数之间执行算术运算。

package main
import ("fmt")
func main() {
  x:= 10
  y:= 2
  fmt.Println("Addition:",x+y)
  fmt.Println("Subtraction:",x-y)
  fmt.Println("Multiplication:",x*y)
  fmt.Println("Division:",x/y)
  fmt.Println("Modulus:",x%y)
}

输出

Addition: 12
Subtraction: 8
Multiplication:20
Division:5
Modulus:0

比较运算符

比较运算符将其左侧值（或表达式）与右侧值（或表达式）进行比较。比较运算符也称为关系运算符。使用比较运算符的操作输出将是布尔值，即 true 或 false。

使用比较运算符的示例程序

• 等于 (==)

  Go 程序，用于检查两个数字是否相等

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x==y) 
  }
  
  

  输出

  
  false
  

• 不等于 (!=)

  Go 程序，用于检查数字是否不相等

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x!=y) 
  }
  
  

  输出

  
  true
  

• 大于 (>)

  Go 程序，用于检查 'x' 是否大于 'y'

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x>y) 
  }
  
  

  输出

  
  true
  

• 大于或等于 (>=)

  Go 程序，用于检查 'x' 是否大于或等于 'y'

  
  package main
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x>=y) 
  }
  
  

  输出

  
  true
  

• 小于 (<)

  Go 程序，用于检查 'x' 是否小于 'y'

  
  package main
  import ("fmt")
  func main() {
    var x = 3
    var y = 2
    fmt.Println(x<y)}

  输出

  
  false
  

• 小于或等于 (<=)

  Go 程序，用于检查 'x' 是否小于或等于 'y'

  
  packagemain
  import ("fmt")
  func main() {
  
    var x = 3
    var y = 2
  
    fmt.Println(x<=y) 
  }
  
  

  输出

  
  false
  

逻辑运算符

逻辑运算符用于执行逻辑运算 AND、OR 和 NOT。使用逻辑运算符的操作输出将是布尔值，即 true 或 false。

使用逻辑运算符的示例程序

• AND (&&)

  Go 程序，用于检查“x”的值是否大于 4 且小于 6

  
  package main
  import ("fmt")
  func main() {
    var x = 5
    fmt.Println(x > 4 &&  x < 6) 
  }
  
  

  输出

  
  true
  

• OR (||)

  Go 程序，用于检查“x”的值是否小于 10 或大于 20

  
  package main
  import ("fmt")
  func main() { 
  
    var x = 5
  
    fmt.Println(x < 10 || x > 20) 
  }
  
  

  输出

  
  true
  

• NOT (!)

  Go 程序，如果“x”的值大于 4，则打印“true”

  
  package main
  import ("fmt")
  func main() {
  
    var x = 5
  
    fmt.Println(!(x > 4))
  }
  
  

  输出

  
  false
  

位运算符

位运算符用于对二进制数执行位运算。首先，整数被转换为二进制格式，然后逐位执行操作。

使用位运算符的示例程序

• 按位 AND (&), 按位 OR (|), 按位 XOR (^)

  按位 AND、OR、XOR 的示例

  
  package main
  import ("fmt")
  func main() {
  
    var x = 10
    var y = 11
  
    fmt.Printf("x = %b\n",x)
    fmt.Printf("y = %b\n",y)
      
    fmt.Printf("x & y is %b\n",x & y)
    fmt.Printf("x | y is %b\n",x | y)
    fmt.Printf("x ^ y is %b\n",x ^ y)
  }
  
  

  输出

  
  x = 11
  y = 10
  x & y is 10
  x | y is 11
  x ^ y is 1
  

• 左移 (<<)

  示例程序

  
  package main
  import ("fmt")
  func main() {
  
    var x = 10
    fmt.Printf("x = %b\n",x)
  
    fmt.Printf("x << 2 is %b\n",x << 2)
  }
  
  

  输出

  
  x = 1010
  x << 2 is 101000
  

• 右移 (>>)

  示例程序

  
  package main
  import ("fmt")
  func main() {
  
    var x = 10
    fmt.Printf("x = %b\n",x)
   
    fmt.Printf("x >> 2 is %b\n",x >> 2)
  }
  
  

  输出

  
  x = 1010
  x >> 2 is 10
  

• AND NOT ($^)

  示例程序

  
  package main
  import ("fmt")
  func main() {
  
    var x = 5
    var y = 2
  
    fmt.Printf("x = %b\n",x)
    fmt.Printf("y = %b\n",y)
  
    fmt.Printf("x &^ y = %b\n",x &^ y)
  }
  
  

  输出

  
  x = 101
  y = 10
  x & y is 101
  

赋值运算符

变量是一个占位符，用于在 Go 程序中存储值以供后续使用。这些值通过称为赋值运算符的运算符分配给变量。

var 关键字使用运算符“=”将值 4 分配给变量 a。

package main
import ("fmt")
func main() {

  var x = 2
  var a = 3
  var s = 3
  var m = 3
  var d = 3
  var md = 3
  a += 2
  s -=2
  m *= 2
  d /= 2
  md %= 2

  fmt.Println("Using Asignment operator :",x)
  fmt.Println("Using Add assignment operator :",a) 
  fmt.Println("Using Subtract assignment operator :",s) 
  fmt.Println("Using Multiply assignment operator :",m) 
  fmt.Println("Using Division assignment operator :",d) 
  fmt.Println("Using Modulus assignment operator :",md) 
}

输出

Using asignment operator : 2
Using Add assignment operator : 5
Using Subtract assignment operator : 1
Using Multiply assignment operator : 6
Using Division assignment operator : 1
Using Modulus assignment operator  : 1

package main
import ("fmt")
func main() {

  var x = 3
  var y = 2
  fmt.Printf("x = %b\n",x)
  fmt.Printf("y = %b\n",y)
 x &= y
  fmt.Printf("x &= y = %b\n",x)
}

输出

x = 11
y = 10
x &= y = 10

package main
import ("fmt")
func main() {

  var x = 3
  var y = 2
  fmt.Printf("x = %b\n",x)
  fmt.Printf("y = %b\n",y)
 x |= y
  fmt.Printf("x |= y = %b\n",x)
}

输出

x = 11
y = 10
x |= y = 11

package main
import ("fmt")
func main() {

  var x = 5
  var y = 8
  fmt.Printf("x = %b\n",x)
  fmt.Printf("y = %b\n",y)
  x ^= y
  fmt.Printf("x ^= y = %b\n",x)
}

输出

x = 101
y = 1000
x ^= y = 1101