go语言运算符%3c-,Go 语言运算符-CSDN博客

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。例如，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

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

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

按位运算符

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

fmt.Printf("\n计算结果 p <

// >> (右移)

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 <

计算结果 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

4900

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

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

示例package main

import "fmt"

func main() {

a := 94

//使用运算符(＆)和

//指针间接(*)运算符

b := &a

fmt.Println(*b)

*b = 67

fmt.Println(a)

}

输出：94