Opérateurs Go

1 Présentation des opérateurs de Golang

En langage Go, les opérateurs sont utilisés pour effectuer des opérations de code programme, y compris des opérations arithmétiques, des comparaisons relationnelles, des opérations logiques, et plus encore. Différents opérateurs correspondent à différentes fonctionnalités et scénarios d'utilisation. Comprendre et maîtriser ces opérateurs est la base d'une programmation efficace.

2 Opérateurs arithmétiques

Le langage Go fournit un ensemble d'opérateurs arithmétiques :

• Addition (+) : Opération d'addition
• Soustraction (-) : Opération de soustraction
• Multiplication (*) : Opération de multiplication
• Division (/) : Opération de division
• Reste (%) : Opération modulo

Exemples:

package main

import "fmt"

func main() {
    // Opération d'addition
    sum := 10 + 5
    fmt.Println("10 + 5 =", sum) // Affiche 15

    // Opération de soustraction
    diff := 10 - 5
    fmt.Println("10 - 5 =", diff) // Affiche 5

    // Opération de multiplication
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // Affiche 50

    // Opération de division
    quot := 10 / 5
    fmt.Println("10 / 5 =", quot) // Affiche 2

    // Opération modulo
    rem := 10 % 5
    fmt.Println("10 % 5 =", rem) // Affiche 0
}

3 Opérateurs logiques

Les opérateurs logiques en langage Go sont utilisés pour connecter plusieurs conditions (généralement utilisées pour des valeurs booléennes). Il comprend trois types : ET (&&), OU (||), et NON (!).

3.1 ET (&&)

Lorsque toutes les conditions sont vraies, le résultat de l'opération "ET" est vrai.

Exemples:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // Affiche vrai (true)
    fmt.Println(true && false)  // Affiche faux (false)
    fmt.Println(false && false) // Affiche faux (false)
    // Le résultat est vrai seulement lorsque les deux conditions sont vraies
}

3.2 OU (||)

Si au moins une condition est vraie, le résultat de l'opération "OU" est vrai.

Exemples:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // Affiche vrai (true)
    fmt.Println(true || false)  // Affiche vrai (true)
    fmt.Println(false || false) // Affiche faux (false)
    // Le résultat est vrai si au moins une condition est vraie
}

3.3 NON (!)

Utilisé pour inverser la valeur booléenne d'une condition.

Exemples:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // Affiche faux (false)
    fmt.Println(!false) // Affiche vrai (true)
    // Inverse la valeur booléenne
}

4 Opérateurs de comparaison

Les opérateurs de comparaison en langage Go sont utilisés pour comparer deux variables ou valeurs :

• Égal à (==)
• Différent de (!=)
• Supérieur à (>)
• Inférieur à (<)
• Supérieur ou égal à (>=)
• Inférieur ou égal à (<=)

Le résultat des opérations de comparaison est une valeur booléenne : true ou false.

5 Opérateurs logiques

En Go, les opérateurs bitwise nous permettent de manipuler directement les bits binaires des données :

• ET binaire (&)
• OU binaire (|)
• XOR binaire (^)
• Décalage binaire vers la gauche (<<)
• Décalage binaire vers la droite (>>)

Les opérateurs bitwise sont principalement utilisés en programmation de bas niveau, tels que les opérations directes sur le matériel, le chiffrement, et d'autres scénarios.

6 Opérateurs d'assignation

Les opérateurs d'assignation sont utilisés pour attribuer des valeurs aux variables. En langage Go, il existe plusieurs formes d'opérateurs d'assignation :

• Assignation simple (=)
• Assignation avec addition (+=)
• Assignation avec soustraction (-=)
• Assignation avec multiplication (*=)
• Assignation avec division (/=)
• Assignation avec modulo (%=)

Ces opérateurs rendent le code plus concis. Par exemple, x += 1 est équivalent à x = x + 1.

7 Opérateurs spéciaux

7.1 Opérateurs d'incrémentation (++) et de décrémentation (--)

L'opérateur d'incrémentation (++) et l'opérateur de décrémentation (--) sont utilisés pour ajouter 1 et soustraire 1 de la valeur d'une variable, respectivement. Ce sont les seuls opérateurs dans le langage Go qui peuvent agir directement sur la variable elle-même (pas sur une expression).

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // Affiche 2

    y := 10
    y--
    fmt.Println("y-- =", y) // Affiche 9
}

Notez qu'en langage Go, x++ ou x-- ne peut pas faire partie d'une expression. Par exemple, z := x++ n'est pas autorisé.

7.2 Conversion de type

Le langage Go est fortement typé, ce qui signifie qu'une fois qu'une variable est déclarée, son type ne peut pas être modifié. Par conséquent, il est parfois nécessaire de convertir une variable d'un type à un autre. Go n'a pas de conversion de type automatique ; une conversion de type explicite est nécessaire.

Exemple:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // Convertir int en float64

	var f float64 = 3.14
	fmt.Println(int(f)) // Convertir float64 en int, la partie décimale sera ignorée
}

Lors de la conversion de type, il est important de veiller à ce que les données soient sécurisées pendant le processus de conversion, comme le risque de perte de précision lors de la conversion d'un nombre à virgule flottante en un entier.