Операторы языка Go

Операторы являются основой любого языков программирования. Поэтому функциональность языка Go без использования операторов является неполной. Операторы позволяют выполнять различные операции с операндами. В языке Go операторы можно классифицировать по их различным функциям:

• Арифметические операторы

• Реляционные операторы

• Логические операторы

• Битовые операторы

• Оператор присвоения

• Разные операторы

Арифметические операторы

Эти операторы используются для выполнения арифметических/математических операций с операндами в языке Go:

• Сложение: Оператор '+' сложит два операнда. Например, x + y.

• Вычитание: Оператор '-' вычитает два операнда. Например, x - y.

• Умножение: '*' оператор умножает два операнда. Например, x * y.

• Вычисление деления: Оператор '/' делит первый операнд на второй. Например, x / y.

• Вычисление модуля:Когда первый операнд делится на второй операнд, оператор '%%' возвращает остаток. Например, x %% y.

Внимание: -, +, !, &, *amp;, <- и ^ также называются односторонними операторами, приоритет односторонних операторов выше. Операторы ++ и -- происходят из выражений, они не являются выражениями, поэтому не входят в структуру операторов.

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. Это точный булевый дополнение к оператору '=='.

• '>' (больше)Оператор проверяет, является ли первый операнд больше второго операнда. Если больше, то возвращает true. В противном случае, он возвращает false. Например, 6 > 5 вернет true.

• '<' (меньше)Оператор проверяет, является ли первый операнд меньше второго операнда. Если меньше, то возвращает true. В противном случае, он возвращает false. Например, 6 < 5 вернет false.

• '> ='< (больше или равно)Оператор проверяет, является ли первый операнд больше или равен второму операнду. Если больше или равен, то возвращает 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 < q
　　　　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
true
false

Логические операторы

• Логическое И:Оператор "&&" возвращает true, когда оба условия, которые учитываются, удовлетворяются. В противном случае возвращается false. Например, когда a и b истины (т.е. не ноль), a && b возвращает true.

• Логическое ИЛИ: Оператор "||" возвращает 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
True

Битовые операторы

В языке Go есть 6 битовых операторов, которые работают по битам или используются для операций по битам. Вот битовые операторы:

• ＆(битовое И): передачаДва числа в качестве операндов и выполнение операции "и" по每一位 чисел. Результат AND равен 1 только в том случае, если оба разряда равны 1.

• | (битовое OR):Два числа в качестве операндов, и для каждого бита двух чисел выполняется “или” операция. Если любой бит равен 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 << 1
　　　　fmt.Printf("\nРезультат вычисления p << 1 = %d", result4)
　　　　// >> (правый сдвиг)
　　　　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 << 1 = 268
Результат вычисления 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
70
4900
70
0

Разные операторы

• &:Этот оператор возвращает адрес переменной.

• *:Этот оператор предоставляет указатель на переменную.

• <-:Это оператор名叫 прием. Он используется для получения значений из канала.

package main　
　　　　
import "fmt"
　　　　
func main() {　
　　a := 94
　　　　　
//使用运算符（＆）和
//指针间接（*）运算符
　　b := &a　　
　　fmt.Println(*b)　　
　　*b = 67　
　　fmt.Println(a)　　
}

Вывод:

94
67