Comment utiliser les opérateurs dans Golang

Les opérateurs sont la base de tout langage de programmation. Par conséquent, la fonctionnalité du langage Golang est incomplète sans l’utilisation d’opérateurs. Les opérateurs nous permettent d’effectuer différents types d’opérations sur les opérandes. Dans le langage Go, les opérateurs peuvent être classés en fonction de leurs différentes fonctions .

Opérateurs arithmétiques

Ces opérateurs sont utilisés pour effectuer des opérations sur les opérandes en langage Go :

• Addition : « + » ajoute deux opérandes. Par exemple : x+y.
• Soustraction : « - » soustrait deux opérandes. Exemple : xy.
• Multiplication : « * » multiplie deux opérandes. Par exemple : x*y.
• Division : '/' divise le premier opérande par le deuxième opérande. Par exemple : x/y.
• Reste : l'opérateur « % » renvoie le reste lorsque le premier opérande est divisé par le deuxième opérande. Par exemple : x%y.

 Remarque : -, +, !, &, *, <- et ^ sont également appelés opérateurs unaires et la priorité des opérateurs unaires est plus élevée. Les opérateurs ++ et — proviennent d'instructions, ce ne sont pas des expressions, ils se situent donc en dehors de la hiérarchie des opérateurs.

Par exemple:

//Minh họa chương trình Go dùng toán tử số học
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// Phép cộng
result1:= p + q 
fmt.Printf("Result of p + q = %d", result1) 
	
// Phép trừ
result2:= p - q 
fmt.Printf("\nResult of p - q = %d", result2) 
	
// Phép nhân
result3:= p * q 
fmt.Printf("\nResult of p * q = %d", result3) 
	
// Division 
result4:= p / q 
fmt.Printf("\nResult of p / q = %d", result4) 
	
// Modulus 
result5:= p % q 
fmt.Printf("\nResult of p %% q = %d", result5) 
} 

Résultat:

Kết quả của p + q = 54
Kết quả của p - q = 14
Kết quả của p * q = 680
Kết quả của p / q = 1
Kết quả của p % q = 14

Opérateurs relationnels

Les opérateurs relationnels sont utilisés pour comparer deux valeurs. Regardons chaque opérateur un par un :

• L'opérateur '=='(Égal) vérifie si les deux opérandes donnés sont égaux ou non. Si égal, il renvoie vrai. Sinon, il renvoie false. Par exemple, 5==5 renverra vrai.
• L'opérateur '!='(Pas égal à) vérifie si les deux opérandes donnés sont égaux ou non. Sinon, il renvoie vrai. Sinon, il renvoie false. Il s'agit du complément booléen exact de l'opérateur '=='. Par exemple, 5!=5 renverra false.
• L'opérateur '>' (supérieur à) vérifie si le premier opérande est supérieur au deuxième opérande. Si elle est supérieure, elle renvoie vrai. Si moins, cela renvoie faux. Par exemple, 6>5 renverra vrai.
• L'opérateur '<' (inférieur à) vérifie si le premier opérande est inférieur au deuxième opérande. Si c'est moins, cela renvoie vrai. Sinon, il renvoie false. Par exemple, <5 renverra
• L'opérateur '>=' (supérieur à égal) vérifie si le premier opérande est supérieur ou égal au deuxième opérande. Si supérieur ou égal, il renvoie vrai. Si inférieur ou égal, il renvoie faux. Par exemple : 5>=5 renverra vrai.
• L'opérateur '<='(inférieur ou égal à) vérifie si le premier opérande est inférieur ou égal au deuxième opérande. S'il est supérieur ou égal, il renvoie vrai. Si elle est inférieure ou égale, elle renvoie false. Par exemple : <=5 renverra également

Par exemple:

// Minh họa chương trình Go dùng toán tử quan hệ
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// ‘=='(Equal To) 
result1:= p == q 
fmt.Println(result1) 
	
// ‘!='(Not Equal To) 
result2:= p != q 
fmt.Println(result2) 
	
// ‘<‘(less than)="" result3:="p">< q="" fmt.println(result3)="" ‘="">'(Greater Than) 
result4:= p > q 
fmt.Println(result4) 
	
// ‘>='(Greater Than Equal To) 
result5:= p >= q 
fmt.Println(result5) 
	
// ‘<='(less than="" equal="" to)="" result6:="p"><= q="" fmt.println(result6)="" }="">

Résultat:

false
true
false
true
true
false

Opérateurs logiques

Elles sont utilisées pour combiner deux ou plusieurs conditions/contraintes ou pour compléter l'évaluation de la condition initiale considérée.

• ET : L'opérateur « && » renvoie vrai lorsque les deux conditions considérées sont satisfaites. Sinon, il renvoie false. Par exemple, a && b renvoie vrai lorsque a et b sont tous deux vrais (c'est-à-dire différents de zéro).
• OU : Opérateur '||' Renvoie vrai lorsque l'une (ou les deux) des conditions considérées sont satisfaites. Sinon, il renvoie false. Par exemple : un || b renvoie vrai si a ou b est vrai (c'est-à-dire différent de zéro). Bien sûr, cela renvoie vrai lorsque a et b sont tous deux vrais.
• NON logique : Le « ! » opérateur Renvoie vrai lorsque la condition considérée n'est pas satisfaite. Sinon, il renvoie false. Par exemple : !a renvoie vrai si a est faux, c'est-à-dire lorsque a = 0.

Par exemple:

// Minh họa chương trình Go dùng toán tử logic
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" ||=""><=q){ fmt.println("true")="" }="" if(!(p="=q)){" fmt.println("true")="" }="" }="">

Résultat:

True
True
True

Opérateurs au niveau du bit

Dans le langage Go, il existe 6 opérateurs bit à bit qui fonctionnent au niveau du bit ou sont utilisés pour effectuer des opérations bit par bit. Voici les opérateurs au niveau du bit :

• & (ET au niveau du bit) : prend deux nombres comme opérandes et exécute ET sur chaque bit des deux nombres. Le résultat de AND n'est 1 que si les deux bits sont à 1.
• | (OU au niveau du bit) : prend deux nombres comme opérandes et effectue un OU sur chaque bit des deux nombres. Le résultat de OR est 1 si l'un des deux bits est 1.
• ^ (XOR au niveau du bit) : prend deux nombres comme opérandes et effectue un XOR sur chaque bit des deux nombres. Le résultat de XOR est 1 si les deux bits sont différents.
• < (décalage vers la gauche) : prend deux nombres, décale les bits du premier opérande vers la gauche, le deuxième opérande détermine le nombre de positions à décaler
• >> (décalage vers la droite) : Prenez deux nombres, décalez les bits du premier opérande vers la droite, le deuxième opérande détermine le nombre de positions à décaler.
• &^ (ET NON) : Il s'agit d'un opérateur binaire explicite.

Par exemple:

// Minh họa chương trình Go dùng toán tử bitwise
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// & (bitwise AND) 
result1:= p & q 
fmt.Printf("Result of p & q = %d", result1) 
	
// | (bitwise OR) 
result2:= p | q 
fmt.Printf("\nResult of p | q = %d", result2) 
	
// ^ (bitwise XOR) 
result3:= p ^ q 
fmt.Printf("\nResult of p ^ q = %d", result3) 
	
// < (left="" shift)="" result4:="p">< 1="" fmt.printf("\nresult="" of="" p="">< 1="%d" ,"="" result4)="">> (right shift) 
result5:= p >> 1
fmt.Printf("\nResult of p >> 1 = %d", result5) 
	
// &^ (AND NOT) 
result6:= p &^ q 
fmt.Printf("\nResult of p &^ q = %d", result6) 
	
	
} 

Résultat:

Kết quả của p & q = 0
Kết quả của p | q = 54
Kết quả của p ^ q = 54
Kết quả của p < 1="68" kết="" quả="" của="" p="">> 1 = 17
Kết quả của p &^ q = 34

Opérateur d'affectation

L'opérateur d'affectation est utilisé pour attribuer une valeur à une variable. L'opérande gauche de l'opérateur d'affectation est une variable et l'opérande droit de l'opérateur d'affectation est une valeur. La valeur de droite doit avoir le même type de données que la variable de gauche, sinon le compilateur renverra une erreur. Les différents types d’opérateurs d’affectation sont présentés ci-dessous :

• « = » (Affectation simple) : Il s’agit de l’opérateur d’affectation le plus simple. Cet opérateur est utilisé pour affecter la valeur de droite à la variable de gauche.
• « += » (Affectation supplémentaire) : Cet opérateur est une combinaison des opérateurs « + » et « = ». Cet opérateur ajoute d'abord la valeur actuelle de la variable de gauche à la valeur de droite, puis attribue le résultat à la variable de gauche.
• « -= » (Affectation moins) : Cet opérateur est une combinaison des opérateurs « - » et « = ». Cet opérateur soustrait d'abord la valeur actuelle de la variable de gauche de la valeur de droite, puis attribue le résultat à la variable de gauche.
• « *= » (Affectation de multiplication) : cet opérateur est une combinaison des opérateurs « * » et « = ». Cet opérateur multiplie d'abord la valeur actuelle de la variable de gauche par la valeur de droite, puis attribue le résultat à la variable de gauche.
• « /= » (Affectation de division) : cet opérateur est une combinaison des opérateurs « / » et « = ». Cet opérateur divise d'abord la valeur actuelle de la variable de gauche par la valeur de droite, puis attribue le résultat à la variable de gauche.
• « %= » (Affectation du reste) : cet opérateur est une combinaison des opérateurs « % » et « = ». Cet opérateur prend d'abord le reste de la valeur actuelle de la variable de gauche étant donné la valeur de droite, puis attribue le résultat à la variable de gauche.
• « &= » (ET au niveau du bit) : cet opérateur est une combinaison des opérateurs « & » et « = ». Cet opérateur effectue d'abord un « ET au niveau du bit » entre la valeur actuelle de la variable de gauche et la valeur de droite, puis affecte le résultat à la variable de gauche.
• « ^= » (OU exclusif au niveau du bit) : cet opérateur est une combinaison des opérateurs « ^ » et « = ». Cet opérateur effectue d'abord un « OU exclusif au niveau du bit » entre la valeur actuelle de la variable de gauche et la valeur de la variable de droite, puis attribue le résultat à la variable de gauche.
• « |= » (OU inclusif au niveau du bit) : cet opérateur est une combinaison du « | » opérateurs et '='. Cet opérateur effectue d'abord un « OU inclusif au niveau du bit » de la valeur actuelle de la variable de gauche par la valeur de la variable de droite, puis attribue le résultat à la variable de gauche.
• « <= : cet opérateur est une combinaison des opérateurs < » et « =" ». Cet opérateur « décale » d'abord la valeur actuelle de la variable de gauche de la valeur de droite, puis affecte le résultat à la variable de droite.
• « >>= » : Cet opérateur est une combinaison des opérateurs « >> » et « = ». Cet opérateur effectue d'abord un « décalage vers la droite ET » de la valeur actuelle de la variable de gauche par la valeur de droite, puis affecte le résultat à la variable de gauche.

Par exemple:

// Minh họa chương trình Go dùng toán tử gán
package main 
	
import "fmt"
	
func main() { 
var p int = 45
	var q int = 50
	
// “=”(Simple Assignment) 
p = q 
fmt.Println(p) 
	
// “+=”(Add Assignment) 
	p += q 
fmt.Println(p) 
	
//“-=”(Subtract Assignment) 
p-=q 
fmt.Println(p) 
	
// “*=”(Multiply Assignment) 
p*= q 
fmt.Println(p) 
	
// “/=”(Division Assignment) 
	p /= q 
fmt.Println(p) 
	
	// “%=”(Modulus Assignment) 
	p %= q 
fmt.Println(p) 
	
} 

Résultat:

50
100
50
2500
50
0

Autres opérateurs

• &: Cet opérateur renvoie l'adresse d'une variable.
• *: Cet opérateur fournit un pointeur vers une variable.
• <-: Le nom de cet opérateur est receive. Il est utilisé pour recevoir une valeur de

// Minh họa chương trình sử dụng toán tử khác
package main 
	
import "fmt"
	
func main() { 
a := 4
	
// Dùng địa chỉ của toán tử (&) toán tử trỏ gián tiếp (*)

b := &a 
fmt.Println(*b) 
*b = 7
fmt.Println(a) 
} 

Résultat:

4
7