# Operators of Go language

## 1, Basic classification of operators

• Arithmetic operator
• Assignment Operators
• Comparison operator
• Logical operator
• Bitwise Operators
• Other Operators

## 2, Arithmetic operator

Arithmetic operator is an operator that operates on numeric type variables.

### (1) List of arithmetic operators

 operator operation example result + Plus sign +8 8 - minus sign -8 -8 + plus 8+9 17 - reduce 8-2 6 * ride 8 * 2 16 / except 8 / 2 4 % Take mold 8 % 3 2 ++ Self increasing x = 3  x++ 4 -- Self subtraction x = 3  x-- 2 + String addition "x" + "y" "xy"

### (2) Case demonstration

```package main
import "fmt"

func main() {
// + - * / % ++ --case

var a int = 12
var b int = 7

fmt.Println(a + b) // 19
fmt.Println(a - b) // 5
fmt.Println(a * b) // 84
fmt.Println(a / b) // 1 Redefine if you need to be a floating point number a Floating point number 12.0 var a float32 = 12.0
fmt.Println(a % b) // 5
a++
fmt.Println(a) // 13
a--
fmt.Println(a) //12

}```

### (3) Precautions

• The division sign "/". There is a difference between integer division and decimal division. The division between integers only retains the integer part and discards the decimal part
• When modulo a number, it can be equivalent to a% B = a - A / b * B
• In Go, self increasing and self decreasing can only be used as an independent language, not c = a + +, but only a++
• The + + and -- in Go can only be written after the variable, not in front of the variable, that is, there is only a + +, but no + + a

## 3, Assignment operator

Assignment operator is to assign the value of an operation to a specified variable.

### (1) List of assignment operators

 operator describe example = Assign the value of an expression to an lvalue c=a+b, assign the value of a+b to c += Add and assign c+=a equals c=c+a -= Subtraction before assignment c-=a equals c=c-a *= Multiply and assign c*=a equals c=c*a /= Divide and assign c/=a equals c=c/a %= Assign value after remainder c%=a equals c=c%a <<= Left shift assignment C < < = 2 equals C = C < < 2 >>= Assignment after shift right c> > = 2 equals C = C > > 2 &= Bitwise and post assignment C & = 2 equals C = C & 2 ^= Assignment after bitwise XOR c^=2 equals c=c^2 |= Bitwise or post assignment c|=2 equals c=c|2

### (2) Case demonstration

```package main

import "fmt"

func main() {
// exchange a,b Value of two numbers
a := 2
b := 5
fmt.Printf("Before exchange a=%v,b=%v",a,b) //Before exchange a=2,b=5
//Define an intermediate variable temp
temp := a
a = b
b = temp
fmt.Printf("After exchange a=%v,b=%v",a,b) //After exchange a=5,b=2

}```
• The assignment operator evaluates from right to left
• The left side of an assignment operator can only be a time variable, and the right side can be a time variable, expression, or constant value
```package main

import "fmt"

func main() {
//exchange a,b The value of two numbers. Intermediate variables are not allowed
a := 2
b := 5

a = a + b
b = a - b // b = a + b - b
a = a - b // a = a - (a-b)
fmt.Printf("After exchange a=%v,b=%v",a,b) //After exchange a=5,b=2

}```
```package main

import "fmt"

func main() {
// Find the maximum of the three numbers
// First find the maximum of the two numbers, and then find the third one

a := 10
b := 35
c := 25

var max int

if a > b {
max = a
} else {
max = b
}

fmt.Printf("The maximum value of the two numbers is%v", max) //35

if c > max {
max = c
}

fmt.Printf("The maximum value of the three numbers is%v", max) //35

}```

## 4, Relational operator

Relational operators are often used in conditional statements or loop structures of if structures, and their results are bool type (true/false).

### (1) List of relational operators

 operator operation Case list result == Equal to 5==3 false != Not equal to 5!=3 true < less than 5<3 false > greater than 5>3 true <= Less than or equal to 5<=3 false >= Greater than or equal to 5>=3 true

### (2) Case demonstration

```package main

import "fmt"

func main() {

var a int = 5
var b int = 3

fmt.Println(a==b) //false
fmt.Println(a!=b) //true
fmt.Println(a<b) //false
fmt.Println(a>b) //true
fmt.Println(a<=b) //false
fmt.Println(a>=b) //true

}```

## 5, Logical operator

It is used to connect multiple relational expressions, and the result is also a value of bool type.

### (1) List of logical operators

Suppose the value of A is true and the value of B is false:

 operator explain example && Logic and operators. If both sides are true, the result is true, otherwise it is false A & & B is false || Logical or operator. If one of the operands on both sides is true, it is true; otherwise, it is false A | B is true ! Logical non operator. false if the condition is true, otherwise true ! (A & & B) is true

### (2) Case demonstration

```package main

import "fmt"

func main() {

var A bool = true
var B bool = false

fmt.Println(A&&B) //false
fmt.Println(A||B) // true
fmt.Println(!(A&&B)) //true
}```

### (3) Precautions

• &&It is also called short circuit and. If the first condition is false, the second condition will not judge the final result as false
• ||It is also called short circuit or. If the first condition is true, the second condition will not be judged, and the final result is true

## 6, Bitwise operator

Bit operators involve binary related contents, which are listed as follows:

 operator describe & Bitwise and operator, the binary sum corresponding to each of the two numbers involved in the operation. The same is 1, the result is 1, otherwise it is 0 | Bitwise OR operator, the binary phase or corresponding to each of the two numbers involved in the operation. One result is 1, otherwise it is 0 ^ Bitwise XOR operator, the binary XOR corresponding to each of the two numbers involved in the operation. When the binary is different, the result is 1, otherwise it is 0 << Shift left operator, which shifts the binary of the operand on the left of "< <" to the left by several bits, discards the high bit and fills the low bit with 0. Shifting n bits to the left is multiplied by 2 to the nth power >> The shift left operator shifts the binary of the operand on the left of "> >" to the right by several bits, and the shift right by N bits is divided by the n power of 2

## 7, Other operators

### (1) Pointer correlation

 operator describe example & Return variable storage address &a. Gets the actual address of the variable * Pointer variable *a. Is a pointer variable

### (2) Ternary operator

Ternary operators are not supported in Go language. If you want to achieve the effect of ternary operators, you need to use conditional statements to implement them.

```if <condition> {
//...

} else {
//...

}```

## 8, Operator priority

 classification describe Relevance priority suffix () [] ++ -- From left to right high Monocular + - ! ~ (type) * & sizeof Right to left ........ multiplication * / % From left to right addition + - From left to right displacement <<  >> From left to right relationship < <= > >= From left to right equal == != From left to right Bitwise AND & From left to right Bitwise XOR ^ From left to right Bitwise OR | From left to right Logic and && From left to right Logical or || From left to right Assignment Operators = += -= *= /= %= >>= <<= &= ^= |= Right to left comma , From left to right low
• In the above table, the priority decreases in turn
• Only unary operators and assignment operators operate from right to left

Tags: Go

Posted on Sun, 07 Nov 2021 19:09:21 -0500 by Cereals