Go 运算符

在计算机编程中，运算符是用于对值或变量执行操作的符号。

例如，+ 是一个用于将两个数字相加的运算符。

Go 编程提供了各种运算符，这些运算符可分为以下几大类：

• 算术运算符
• 赋值运算符
• 关系运算符
• 逻辑运算符

算术运算符

我们使用算术运算符执行诸如加法、减法、乘法和除法之类的算术运算。

以下是 Go 中提供的各种算术运算符列表。

示例 1：加法、减法和乘法运算符

package main
import "fmt"

func main() {

  num1 := 6
  num2 := 2

  // + adds two variables
  sum := num1 + num2
  fmt.Printf("%d + %d = %d\n", num1, num2, sum)

  // - subtract two variables
  difference := num1 - num2
  fmt.Printf("%d - %d = %d\n",num1, num2,  difference)

  // * multiply two variables
  product := num1 * num2
  fmt.Printf("%d * %d is %d\n",num1, num2,  product)

}

输出

6 + 2 = 8
6 - 2 = 4
6 * 2 = 12

示例 2：Golang 除法运算符

package main
import "fmt"

func main() {

  num1 := 11
  num2 := 4

  // / divide two integer variables
  quotient := num1 / num2
  fmt.Printf(" %d / %d = %d\n", num1, num2, quotient)

}

输出

11 / 4 = 2

在上面的示例中，我们使用 / 运算符将两个数字：11 和 4 相除。在这里，我们得到的输出是 2。

但是，在常规计算中，11 / 4 的结果是 2.75。这是因为当我们将 / 运算符与整数值一起使用时，我们得到的是商而不是实际结果。

如果我们想要实际结果，则应始终将 / 运算符与浮点数一起使用。例如：

package main
import "fmt"

func main() {

  num1 := 11.0
  num2 := 4.0

  // / divide two floating point variables
  result := num1 / num2
  fmt.Printf(" %g / %g = %g\n", num1, num2, result)

}

输出

11 / 4 = 2.75  

在这里，我们得到了除法后的实际结果。

示例 3：Go 中的模运算符

package main
import "fmt"

func main() {

  num1 := 11
  num2 := 4

  // % modulo-divides two variables
  remainder := num1 % num2
  fmt.Println(remainder )

}

在上面的示例中，我们使用模运算符处理数字：11 和 4。在这里，我们得到的结果是 3。

这是因为在编程中，模运算符始终返回除法的余数。

注意：模运算符始终与整数值一起使用。

Go 中的递增和递减运算符

在 Golang 中，我们使用 ++（递增）和 --（递减）运算符分别将变量的值增加或减少 1。例如：

package main
import "fmt"

func main() {

  num := 5

  // increment of num by 1
  num++
  fmt.Println(num)  // 6

  // decrement of num by 1
  num--
  fmt.Println(num)  // 4

}

在上面的例子中：

• num++ - 将 num 的值增加 1，从 5 变为 6
• num-- - 将 num 的值减少 1，从 5 变为 4

Go 赋值运算符

我们使用赋值运算符将值赋给变量。例如：

var number = 34

在这里，= 运算符将右侧的值（34）赋给左侧的变量（number）。

示例：Go 中的赋值运算符

package main
import "fmt"

func main() {

  num := 6
  var result int

  // = operator to assign the value of num to result
  result = num
  fmt.Println(result)    // 6
}

在上面的示例中，我们使用赋值运算符将 num 变量的值赋给 result 变量。

复合赋值运算符

在 Go 中，我们也可以将赋值运算符与算术运算符一起使用。例如：

number := 2
number += 6

在这里，+= 是加法赋值运算符。它首先将 6 加到 number 的值（2）上，然后将最终结果（8）赋给 number。

以下是 Golang 中提供的各种复合赋值运算符列表。

Golang 中的关系运算符

我们使用关系运算符来比较两个值或变量。例如：

5 == 6

在这里，== 是一个关系运算符，用于检查 5 是否等于 6。

关系运算符返回

• 如果两个值之间的比较正确，则为 true
• 如果比较错误，则为 false

以下是 Go 中提供的各种关系运算符列表：

要了解更多信息，请访问Go 关系运算符。

Go 中的逻辑运算符

我们使用逻辑运算符执行逻辑运算。逻辑运算符根据条件返回 true 或 false。

要了解更多信息，请访问Go 逻辑运算符。

212 = 11010100 (In binary)
212 >> 3 = 00011010 = 26 (Right shift by 3 bits)
212 >> 7 = 00000001 = 1 (Right shift by 7 bits)
212 >> 0 = 11010100 = 212 (No Shift)

package main
import "fmt"

func main() {
  num := 212
  for i := 0; i <= 3; i++ {

    // right shift 212 by bits from 0 to 3
    fmt.Printf("Right Shift by %d: %d\n", i, num>>i)

  }
}

Right Shift by 0: 212
Right Shift by 1: 106
Right Shift by 2: 53
Right Shift by 3: 26

212 = 11010100 (In binary)
212 << 1 = 110101000 = 424 (Adds one 0 to the right)
212 << 3 = 11010100000 = 1696 (Adds three 0's to the right)
212 << 0 = 11010100 = 212 (No Shift)

package main
import "fmt"

func main() {
  num := 212
  for i := 0; i <= 3; i++ {

    // left shift 212 by bits from 0 to 3
    fmt.Printf("Left Shift by %d: %d\n", i, num<<i)

  }
}

Left Shift by 0: 212
Left Shift by 1: 424
Left Shift by 2: 848
Left Shift by 3: 1696

package main

import "fmt"

func main() {

  num := 20

  // &num prints the
  // memory address where 20 is stored
  fmt.Println(&num)

}

// Output: 0xc0000b8000

package main
import "fmt"

func main() {
  b := 20

  // pointer declaration
  var num *int = &b

  // gives the memory address
  fmt.Println(num)
}

// Output: 0xc00010a000

result := 32 / 8 + 2 * 9 -4