Opérateurs du langage Go

Les opérateurs sont utilisés pour effectuer des opérations mathématiques ou logiques pendant l'exécution du programme.

Les opérateurs intégrés du langage Go sont :

Opérateurs arithmétiques
Opérateurs relationnels
Opérateurs logiques
Opérateurs bit à bit
Opérateurs d'affectation
Autres opérateurs

Examinons maintenant en détail la présentation de chaque opérateur.

Opérateurs arithmétiques

Le tableau suivant répertorie tous les opérateurs arithmétiques du langage Go. Supposons A = 10, B = 20.

Opérateurs	Description	Exemple
+	Addition	A + B donne comme résultat 30
-	Soustraction	A - B donne comme résultat -10
*	Multiplication	A * B donne comme résultat 200
/	Division	B / A résultat de sortie 2
%	Reste	B % A résultat de sortie 0
++	Incrémentation	A++ résultat de sortie 11
--	Décrémentation	A-- résultat de sortie 9

Les exemples suivants démontrent l'utilisation des opérateurs arithmétiques :

Exemple

package main

import "fmt"

func main() {

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

c = a + b
fmt.Printf("Ligne 1 - la valeur de c est %d\n", c )
c = a - b
fmt.Printf("Ligne 2 - la valeur de c est %d\n", c )
c = a * b
fmt.Printf("Ligne 3 - la valeur de c est %d\n", c )
c = a / b
fmt.Printf("Ligne 4 - la valeur de c est %d\n", c )
c = a % b
fmt.Printf("Ligne 5 - la valeur de c est %d\n", c )
a++
fmt.Printf("Ligne 6 - la valeur de a est %d\n", a )
a=21 // Pour faciliter les tests, a est réaffecté à 21 ici
a--
fmt.Printf("Ligne 7 - la valeur de a est %d\n", a )
}

Résultat d'exécution de l'exemple ci-dessus :

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

Opérateurs relationnels

Le tableau suivant liste tous les opérateurs relationnels du langage Go. Supposons A = 10, B = 20.

Opérateurs	Description	Exemple
==	Vérifie si deux valeurs sont égales. Si elles sont égales, renvoie True ; sinon renvoie False.	(A == B) est False
!=	Vérifie si deux valeurs ne sont pas égales. Si elles ne sont pas égales, renvoie True ; sinon renvoie False.	(A != B) est True
>	Vérifie si la valeur de gauche est supérieure à la valeur de droite. Si c'est le cas, renvoie True ; sinon renvoie False.	(A > B) est False
<	Vérifie si la valeur de gauche est inférieure à la valeur de droite. Si c'est le cas, renvoie True ; sinon, renvoie False.	(A < B) est True
>=	Vérifie si la valeur de gauche est supérieure ou égale à la valeur de droite. Si c'est le cas, renvoie True ; sinon, renvoie False.	(A >= B) est False
<=	Vérifie si la valeur de gauche est inférieure ou égale à la valeur de droite. Si c'est le cas, renvoie True ; sinon, renvoie False.	(A <= B) est True

Les exemples suivants illustrent l'utilisation des opérateurs relationnels :

Exemple

package main

import "fmt"

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

if( a == b ) {
fmt.Printf("Ligne 1 - a est égal à b\n" )
} else {
fmt.Printf("Ligne 1 - a n'est pas égal à b\n" )
}
if ( a < b ) {
fmt.Printf("Ligne 2 - a est inférieur à b\n" )
} else {
fmt.Printf("Ligne 2 - a n'est pas inférieur à b\n" )
}

if ( a > b ) {
fmt.Printf("Ligne 3 - a est supérieur à b\n" )
} else {
fmt.Printf("Ligne 3 - a n'est pas supérieur à b"\n" )
}
/* Changeons la valeur de a et b */
a = 5
b = 20
if ( a <= b ) {
fmt.Printf("Ligne 4 - a est inférieur ou égal à b\n" )
}
if ( b >= a ) {
fmt.Printf("Ligne 5 - b est supérieur ou égal à a\n" )
}
}

Résultat d'exécution de l'exemple ci-dessus :

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

Opérateurs logiques

Le tableau suivant liste tous les opérateurs logiques du langage Go. Supposons A = Vrai, B = Faux.

Opérateurs	Description	Exemple
&&	Opérateur ET logique. Si les deux opérandes sont vrais, la condition est vraie ; sinon, elle est fausse.	(A && B) est faux
\|\|	Opérateur OU logique. Si l'un des opérandes est vrai, la condition est vraie ; sinon, elle est fausse.	(A \|\| B) est vrai
!	Opérateur NON logique. Si la condition est vraie, la condition NON logique est fausse ; sinon, elle est vraie.	!(A && B) est vrai

Les exemples suivants démontrent l'utilisation des opérateurs logiques :

Exemple

package main

import "fmt"

func main() {
var a bool = true
var b bool = false
if ( a && b ) {
fmt.Printf("Ligne 1 - la condition est vraie\n" )
}
if ( a || b ) {
fmt.Printf("Ligne 2 - la condition est vraie\n" )
}
/* Modifier les valeurs de a et b */
a = false
b = vrai
if ( a && b ) {
fmt.Printf("Ligne 3 - la condition est vraie\n" )
} else {
fmt.Printf("Ligne 3 - la condition est fausse\n" )
}
if ( !(a && b) ) {
fmt.Printf("Ligne 4 - la condition est vraie\n" )
}
}

Résultat d'exécution de l'exemple ci-dessus :

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

Opérateurs bit à bit

Les opérateurs bit à bit opèrent sur les bits binaires des entiers en mémoire.

Le tableau suivant répertorie les calculs des opérateurs bit à bit &, | et ^ :

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

Supposons A = 60 ; B = 13 ; leurs nombres binaires sont convertis en :

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

Les opérateurs bit à bit pris en charge par le langage Go sont présentés dans le tableau suivant. Supposons A = 60, B = 13 :

Opérateurs	Description	Exemple
&	L'opérateur ET bit à bit « & » est un opérateur binaire. Sa fonction est d'effectuer un ET bit à bit sur les bits binaires correspondants des deux nombres impliqués dans l'opération.	(A & B) donne 12, en binaire 0000 1100
\|	L'opérateur OU bit à bit « \| » est un opérateur binaire. Sa fonction est d'effectuer un OU bit à bit sur les bits binaires correspondants des deux nombres impliqués dans l'opération.	(A \| B) donne 61, en binaire 0011 1101
^	L'opérateur OU exclusif bit à bit « ^ » est un opérateur binaire. Sa fonction est d'effectuer un OU exclusif sur les bits binaires correspondants des deux nombres impliqués dans l'opération. Lorsque les bits binaires correspondants sont différents, le résultat est 1.	(A ^ B) donne 49, en binaire 0011 0001
<<	L'opérateur de décalage à gauche « << » est un opérateur binaire. Un décalage à gauche de n bits équivaut à une multiplication par 2 à la puissance n. Sa fonction est de décaler tous les bits binaires de l'opérande à gauche de « << » vers la gauche d'un nombre de bits spécifié par l'opérande à droite de « << » ; les bits de poids fort sont perdus, et les bits de poids faible sont remplis avec 0.	A << 2 donne 240, en binaire 1111 0000
>>	L'opérateur de décalage à droite « >> » est un opérateur binaire. Un décalage à droite de n bits équivaut à une division par 2 à la puissance n. Sa fonction est de décaler tous les bits binaires de l'opérande à gauche de « >> » vers la droite d'un nombre de bits spécifié par l'opérande à droite de « >> ».	A >> 2 donne 15, en binaire 0000 1111

L'exemple suivant illustre l'utilisation des opérateurs bit à bit :

Exemple

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("Ligne 1 - la valeur de c est %d\n", c )

c = a | b /* 61 = 0011 1101 */
fmt.Printf("Ligne 2 - la valeur de c est %d\n", c )

c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("Ligne 3 - la valeur de c est %d\n", c )

c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("Ligne 4 - la valeur de c est %d\n", c )

c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("Ligne 5 - la valeur de c est %d\n", c )
}

Résultat d'exécution de l'exemple ci-dessus :

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

Opérateurs d'affectation

Le tableau suivant liste tous les opérateurs d'affectation du langage Go.

Opérateurs	Description	Exemple
=	Opérateur d'affectation simple, qui affecte la valeur d'une expression à une lvalue.	C = A + B affecte le résultat de l'expression A + B à C
+=	Addition et affectation	C += A est équivalent à C = C + A
-=	Soustraction et affectation	C -= A est équivalent à C = C - A
*=	Multiplication et affectation	C = A est équivalent à C = C A
/=	Division et affectation	C /= A est équivalent à C = C / A
%=	Modulo et affectation	C %= A est équivalent à C = C % A
<<=	Affectation par décalage à gauche	C <<= 2 est équivalent à C = C << 2
>>=	Affectation par décalage à droite	C >>= 2 est équivalent à C = C >> 2
&=	ET bit à bit et affectation	C &= 2 est équivalent à C = C & 2
^=	OU exclusif bit à bit et affectation	C ^= 2 est équivalent à C = C ^ 2
\|=	OU bit à bit et affectation	C \|= 2 est équivalent à C = C \| 2

Les exemples suivants illustrent l'utilisation des opérateurs d'affectation :

Exemple

package main

import "fmt"

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

c = a
fmt.Printf(Ligne 1 - exemple de l'opérateur =, valeur de c = %d\n", c )

c += a
fmt.Printf(Ligne 2 - exemple de l'opérateur +=, valeur de c = %d\n", c )

c -= a
fmt.Printf(Ligne 3 - exemple de l'opérateur -=, valeur de c = %d\n", c )

c *= a
fmt.Printf(Ligne 4 - exemple de l'opérateur *=, valeur de c = %d\n", c )

c /= a
fmt.Printf(Ligne 5 - exemple de l'opérateur /=, valeur de c = %d\n", c )

c = 200;

c <<= 2
fmt.Printf(Ligne 6 - exemple de l'opérateur <<=, valeur de c = %d\n", c )

c >>= 2
fmt.Printf(Ligne 7 - exemple de l'opérateur >>=, valeur de c = %d\n", c )

c &= 2
fmt.Printf(Ligne 8 - exemple de l'opérateur &=, valeur de c = %d\n", c )

c ^= 2
fmt.Printf(Ligne 9 - exemple de l'opérateur ^=, valeur de c = %d\n", c )

c |= 2
fmt.Printf(Ligne 10 - exemple de l'opérateur |=, valeur de c = %d\n", c )

}

Résultat d'exécution de l'exemple ci-dessus :

第 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

Autres opérateurs

Le tableau suivant répertorie d'autres opérateurs dans le langage Go.

Opérateurs	Description	Exemple
&	Retourne l'adresse de stockage d'une variable	&a; donnera l'adresse réelle de la variable.
*	Variable pointeur.	*a; est une variable pointeur

Les exemples suivants démontrent l'utilisation d'autres opérateurs :

Exemple

package main

import "fmt"

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

/* Exemple d'opérateur */
fmt.Printf("Ligne 1 - type de la variable a = %T\n", a );
fmt.Printf("Ligne 2 - type de la variable b = %T\n", b );
fmt.Printf("Ligne 3 - type de la variable c = %T\n", c );

/* Exemple d'opérateurs & et * */
ptr = &a /* 'ptr' contient l'adresse de la variable 'a' */
fmt.Printf("La valeur de a est %d\n", a);
fmt.Printf("*ptr est %d\n", *ptr);
}

Résultat d'exécution de l'exemple ci-dessus :

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

Priorité des opérateurs

Certains opérateurs ont une priorité plus élevée. Le sens d'évaluation des opérateurs binaires est toujours de gauche à droite. Le tableau suivant répertorie tous les opérateurs et leur priorité, de haut en bas représentant une priorité décroissante :

Priorité	Opérateurs
5	* / % << >> & &^
4	+ - \| ^
3	== != < <= > >=
2	&&
1	\|\|

Bien sûr, vous pouvez utiliser des parenthèses pour augmenter temporairement la priorité globale des opérations d'une expression.

Résultat d'exécution de l'exemple ci-dessus :

Exemple

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("La valeur de (a + b) * c / d est : %d"\n", e );

e = ((a + b) * c) / d; // (30 * 15 ) / 5
fmt.Printf("La valeur de ((a + b) * c) / d est : %d"\n" , e );

e = (a + b) * (c / d); // (30) * (15/5)
fmt.Printf("La valeur de (a + b) * (c / d) est : %d"\n", e );

e = a + (b * c) / d; // 20 + (150/5)
fmt.Printf("La valeur de a + (b * c) / d est : %d"\n" , e );
}

Résultat d'exécution de l'exemple ci-dessus :

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

autres extensions