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

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

Встроенные операторы в языке Go:

Арифметические операторы
Операторы отношения
Логические операторы
Побитовые операторы
Операторы присваивания
Другие операторы

Теперь подробно рассмотрим описание каждого оператора.

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

В следующей таблице перечислены все арифметические операторы в языке Go. Предположим, A = 10, B = 20.

Операторы	Описание	Пример
+	Сложение	A + B выводит результат 30
-	Вычитание	A - B выводит результат -10
*	Умножение	A * B выводит результат 200
/	Деление	B / A результат вывода 2
%	Остаток	B % A результат вывода 0
++	Инкремент	A++ результат вывода 11
--	Декремент	A-- результат вывода 9

Следующие примеры демонстрируют использование арифметических операторов:

Пример

package main

import "fmt"

func main() {

var a int = 21
var b int = 10
var c int

c = a + b
fmt.Printf("Line 1 - the value of c is %d\n", c )
c = a - b
fmt.Printf("Line 2 - the value of c is %d\n", c )
c = a * b
fmt.Printf("Line 3 - the value of c is %d\n", c )
c = a / b
fmt.Printf("Line 4 - the value of c is %d\n", c )
c = a % b
fmt.Printf("Строка 5 - значение c равно %d\n", c )
a++
fmt.Printf("Строка 6 - значение a равно %d\n", a )
a=21 // Для удобства тестирования здесь переменной a присваивается значение 21
a--
fmt.Printf("Строка 7 - значение a равно %d\n", a )
}

Результат выполнения приведённого выше примера:

第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - a 的值为 22
第七行 - a 的值为 20

Операторы отношения

В следующей таблице перечислены все операторы сравнения в языке Go. Предположим, A = 10, B = 20.

Операторы	Описание	Пример
==	Проверяет, равны ли два значения. Если они равны, возвращает True; в противном случае возвращает False.	(A == B) имеет значение False
!=	Проверяет, не равны ли два значения. Если они не равны, возвращает True; в противном случае возвращает False.	(A != B) имеет значение True
>	Проверяет, больше ли значение слева, чем значение справа. Если да, возвращает True; в противном случае возвращает False.	(A > B) имеет значение False
<	Проверяет, является ли значение слева меньшим, чем значение справа. Если да, возвращает True; в противном случае возвращает False.	(A < B) равно True
>=	Проверяет, является ли значение слева большим или равным значению справа. Если да, возвращает True; в противном случае возвращает False.	(A >= B) равно False
<=	Проверяет, является ли значение слева меньшим или равным значению справа. Если да, возвращает True; в противном случае возвращает False.	(A <= B) равно True

Следующие примеры демонстрируют использование операторов отношения:

Пример

package main

import "fmt"

func main() {
var a int = 21
var b int = 10

if( a == b ) {
fmt.Printf("Строка 1 - a равно b\n" )
} else {
fmt.Printf("Строка 1 - a не равно b\n" )
}
if ( a < b ) {
fmt.Printf("Строка 2 - a меньше b\n" )
} else {
fmt.Printf("Строка 2 - a не меньше b\n" )
}

if ( a > b ) {
fmt.Printf("Строка 3 - a больше b\n" )
} else {
fmt.Printf("Строка 3 - a не больше b\n" )
}
/* Давайте изменим значения a и b */
a = 5
b = 20
if ( a <= b ) {
fmt.Printf("Строка 4 - a меньше или равно b\n" )
}
if ( b >= a ) {
fmt.Printf("Строка 5 - b больше или равно a\n" )
}
}

Результат выполнения приведённого выше примера:

第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于 b
第五行 - b 大于等于 a

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

В следующей таблице перечислены все логические операторы в языке Go. Предположим, A = Истина, B = Ложь.

Операторы	Описание	Пример
&&	Логический оператор AND. Если оба операнда истинны, условие истинно; в противном случае — ложно.	(A && B) ложно
\|\|	Логический оператор OR. Если хотя бы один операнд истинен, условие истинно; в противном случае — ложно.	(A \|\| B) истинно
!	Логический оператор NOT. Если условие истинно, результат логического NOT ложен; в противном случае — истинно.	!(A && B) истинно

Следующие примеры демонстрируют использование логических операторов:

Пример

package main

import "fmt"

func main() {
var a bool = true
var b bool = false
if ( a && b ) {
fmt.Printf("Строка 1 - условие истинно\n" )
}
if ( a || b ) {
fmt.Printf("Строка 2 - условие истинно\n" )
}
/* Измените значения a и b */
a = false
b = истина
if ( a && b ) {
fmt.Printf("Строка 3 - условие истинно\n" )
} else {
fmt.Printf("Строка 3 - условие ложно\n" )
}
if ( !(a && b) ) {
fmt.Printf("Строка 4 - условие истинно\n" )
}
}

Результат выполнения приведённого выше примера:

第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true

Побитовые операторы

Побитовые операторы работают с двоичными битами целых чисел в памяти.

В следующей таблице перечислены вычисления побитовых операторов &, | и ^:

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Предположим, A = 60; B = 13; их двоичные числа преобразуются в:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

Побитовые операторы, поддерживаемые языком Go, показаны в следующей таблице. Предположим, A = 60, B = 13:

Операторы	Описание	Пример
&	Оператор побитового И "&" является бинарным оператором. Его функция — выполнять побитовое И над соответствующими двоичными битами двух чисел, участвующих в операции.	(A & B) даёт 12, в двоичном виде 0000 1100
\|	Оператор побитового ИЛИ "\|" является бинарным оператором. Его функция — выполнять побитовое ИЛИ над соответствующими двоичными битами двух чисел, участвующих в операции.	(A \| B) даёт 61, в двоичном виде 0011 1101
^	Оператор побитового исключающего ИЛИ "^" является бинарным оператором. Его функция — выполнять исключающее ИЛИ над соответствующими двоичными битами двух чисел, участвующих в операции. Когда соответствующие двоичные биты различаются, результат равен 1.	(A ^ B) даёт 49, в двоичном виде 0011 0001
<<	Оператор сдвига влево "<<" является бинарным оператором. Сдвиг влево на n бит эквивалентен умножению на 2 в n-й степени. Его функция — сдвинуть все двоичные биты операнда слева от "<<" влево на количество бит, указанное операндом справа от "<<"; старшие биты отбрасываются, а младшие биты заполняются 0.	A << 2 даёт 240, в двоичном виде 1111 0000
>>	Оператор сдвига вправо ">>" является бинарным оператором. Сдвиг вправо на n бит эквивалентен делению на 2 в n-й степени. Его функция — сдвинуть все двоичные биты операнда слева от ">>" вправо на количество бит, указанное операндом справа от ">>".	A >> 2 даёт 15, в двоичном виде 0000 1111

Следующий пример демонстрирует использование побитовых операторов:

Пример

package main

import "fmt"

func main() {

var a uint = 60 /* 60 = 0011 1100 */
var b uint = 13 /* 13 = 0000 1101 */
var c uint = 0

c = a & b /* 12 = 0000 1100 */
fmt.Printf("Line 1 - the value of c is %d\n", c )

c = a | b /* 61 = 0011 1101 */
fmt.Printf("Line 2 - the value of c is %d\n", c )

c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("Line 3 - the value of c is %d\n", c )

c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("Line 4 - the value of c is %d\n", c )

c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("Строка 5 - значение c равно %d\n", c )
}

Результат выполнения приведённого выше примера:

第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

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

В следующей таблице перечислены все операторы присваивания в языке Go.

Операторы	Описание	Пример
=	Простой оператор присваивания, который присваивает значение выражения lvalue.	C = A + B присваивает результат выражения A + B переменной C
+=	Сложение с присваиванием	C += A эквивалентно C = C + A
-=	Вычитание с присваиванием	C -= A эквивалентно C = C - A
*=	Умножение с присваиванием	C = A эквивалентно C = C A
/=	Деление с присваиванием	C /= A эквивалентно C = C / A
%=	Взятие остатка с присваиванием	C %= A эквивалентно C = C % A
<<=	Присваивание сдвига влево	C <<= 2 эквивалентно C = C << 2
>>=	Присваивание сдвига вправо	C >>= 2 эквивалентно C = C >> 2
&=	Побитовое И с присваиванием	C &= 2 эквивалентно C = C & 2
^=	Побитовое исключающее ИЛИ с присваиванием	C ^= 2 эквивалентно C = C ^ 2
\|=	Побитовое ИЛИ с присваиванием	C \|= 2 эквивалентно C = C \| 2

Следующие примеры демонстрируют использование операторов присваивания:

Пример

package main

import "fmt"

func main() {
var a int = 21
var c int

c = a
fmt.Printf(Строка 1 — пример оператора =, значение c = %d\n", c )

c += a
fmt.Printf(Строка 2 — пример оператора +=, значение c = %d\n", c )

c -= a
fmt.Printf(Строка 3 — пример оператора -=, значение c = %d\n", c )

c *= a
fmt.Printf(Строка 4 — пример оператора *=, значение c = %d\n", c )

c /= a
fmt.Printf(Строка 5 — пример оператора /=, значение c = %d\n", c )

c = 200;

c <<= 2
fmt.Printf(Строка 6 — пример оператора <<=, значение c = %d\n", c )

c >>= 2
fmt.Printf(Строка 7 — пример оператора >>=, значение c = %d\n", c )

c &= 2
fmt.Printf(Строка 8 — пример оператора &=, значение c = %d\n", c )

c ^= 2
fmt.Printf(Строка 9 — пример оператора ^=, значение c = %d\n", c )

c |= 2
fmt.Printf(Строка 10 — пример оператора |=, значение c = %d\n", c )

}

Результат выполнения приведённого выше примера:

第 1 行 - =  运算符实例，c 值为 = 21
第 2 行 - += 运算符实例，c 值为 = 42
第 3 行 - -= 运算符实例，c 值为 = 21
第 4 行 - *= 运算符实例，c 值为 = 441
第 5 行 - /= 运算符实例，c 值为 = 21
第 6行  - <<= 运算符实例，c 值为 = 800
第 7 行 - >>= 运算符实例，c 值为 = 200
第 8 行 - &= 运算符实例，c 值为 = 0
第 9 行 - ^= 运算符实例，c 值为 = 2
第 10 行 - |= 运算符实例，c 值为 = 2

Другие операторы

В следующей таблице перечислены другие операторы в языке Go.

Операторы	Описание	Пример
&	Возвращает адрес хранения переменной	&a; выдаст фактический адрес переменной.
*	Переменная-указатель.	*a; — это переменная-указатель

В следующих примерах демонстрируется использование других операторов:

Пример

package main

import "fmt"

func main() {
var a int = 4
var b int32
var c float32
var ptr *int

/* Пример оператора */
fmt.Printf("Строка 1 - тип переменной a = %T\n", a );
fmt.Printf("Строка 2 - тип переменной b = %T\n", b );
fmt.Printf("Строка 3 - тип переменной c = %T\n", c );

/* Пример операторов & и * */
ptr = &a /* 'ptr' содержит адрес переменной 'a' */
fmt.Printf("Значение a равно %d\n", a);
fmt.Printf("*ptr равно %d\n", *ptr);
}

Результат выполнения приведённого выше примера:

第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

Приоритет операторов

Некоторые операторы имеют более высокий приоритет. Направление вычисления бинарных операторов всегда слева направо. В следующей таблице перечислены все операторы и их приоритет; сверху вниз приоритет убывает:

Приоритет	Операторы
5	* / % << >> & &^
4	+ - \| ^
3	== != < <= > >=
2	&&
1	\|\|

Конечно, вы можете использовать круглые скобки, чтобы временно повысить общий приоритет операций в выражении.

Результат выполнения приведённого выше примера:

Пример

package main

import "fmt"

func main() {
var a int = 20
var b int = 10
var c int = 15
var d int = 5
var e int;

e = (a + b) * c / d; // ( 30 * 15 ) / 5
fmt.Printf("Значение (a + b) * c / d равно : %d"\n", e );

e = ((a + b) * c) / d; // (30 * 15 ) / 5
fmt.Printf("Значение ((a + b) * c) / d равно : %d"\n" , e );

e = (a + b) * (c / d); // (30) * (15/5)
fmt.Printf("Значение (a + b) * (c / d) равно : %d"\n", e );

e = a + (b * c) / d; // 20 + (150/5)
fmt.Printf("Значение a + (b * c) / d равно : %d"\n" , e );
}

Результат выполнения приведённого выше примера:

(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50

Другие расширения