1. 首页
  2. 博客
  3. Go运算符

Go运算符

算术运算符

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

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

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

例子；

// 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 = 14
Result of p * q = 680
Result of p / q = 1
Result of 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。

例子：

// 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

逻辑运算符

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

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

例子：

// 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个按位运算符，它们工作在位级别或用于执行逐位运算。以下是按位运算符：

  • &（按位与）：将两个数作为操作数，对两个数的每一位进行与运算。仅当两位都为 1 时，AND 的结果才为 1。
  • | （按位或）：将两个数作为操作数，对两个数的每一位进行或运算。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 = 68
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

原文链接：codingdict.net

热门标签