Opérateurs et expressions

Opérateurs et expressions : les actions et les phrases de go

En go, comme dans tous les langages de programmation, les opérateurs sont des symboles spéciaux qui vous permettent de réaliser des actions sur vos données (les variables et les constantes que nous avons vues précédemment). Imaginez les opérateurs comme des verbes dans une phrase : ils indiquent ce qu'il faut faire.

Une expression est une combinaison de variables, de constantes et d'opérateurs qui, ensemble, forment une "phrase" de code et produisent une nouvelle valeur. C'est comme une phrase en français : elle a un sens et un résultat. Par exemple, age + 10 est une expression qui utilise l'opérateur + (addition) pour combiner la variable age et la constante 10 et produire une nouvelle valeur (l'âge dans 10 ans).

Maîtriser les opérateurs et les expressions est crucial car c'est grâce à eux que vous allez pouvoir manipuler vos données, effectuer des calculs, prendre des décisions logiques et rendre vos programmes dynamiques et interactifs. Sans opérateurs et expressions, vos programmes seraient très limités et ne feraient pas grand-chose !

Dans ce chapitre, nous allons explorer les principaux types d'opérateurs en go : les opérateurs arithmétiques (pour les calculs), les opérateurs de comparaison (pour comparer des valeurs), les opérateurs logiques (pour combiner des conditions), les opérateurs d'affectation (pour donner des valeurs aux variables) et quelques autres opérateurs utiles. Nous verrons comment les combiner pour former des expressions de plus en plus complexes et comment go évalue ces expressions pour produire des résultats.

Opérateurs arithmétiques : les outils de calcul

Les opérateurs arithmétiques sont utilisés pour effectuer des calculs mathématiques sur des nombres (entiers et flottants). Go propose les opérateurs arithmétiques de base :

• Addition : + (ex: 5 + 3 donne 8)
• Soustraction : - (ex: 10 - 2 donne 8)
• Multiplication : * (ex: 4 * 6 donne 24)
• Division : / (ex: 15 / 4 donne 3 en division entière, 15.0 / 4.0 donne 3.75 en division flottante)
• Modulo (reste de la division entière) : % (ex: 15 % 4 donne 3, car le reste de 15 divisé par 4 est 3)

Exemples de code avec les opérateurs arithmétiques :

package main

import "fmt"

func main() {
    nombre1 := 10
    nombre2 := 3

    somme := nombre1 + nombre2         // Addition
    difference := nombre1 - nombre2    // Soustraction
    produit := nombre1 * nombre2       // Multiplication
    quotient := nombre1 / nombre2      // Division entière
    reste := nombre1 % nombre2         // Modulo
    quotientFlottant := float64(nombre1) / float64(nombre2) // Division flottante (conversion en float64)

    fmt.Println("Addition :", somme)       // Affiche : Addition : 13
    fmt.Println("Soustraction :", difference)  // Affiche : Soustraction : 7
    fmt.Println("Multiplication :", produit)   // Affiche : Multiplication : 30
    fmt.Println("Division entière :", quotient) // Affiche : Division entière : 3
    fmt.Println("Modulo :", reste)          // Affiche : Modulo : 1
    fmt.Println("Division flottante :", quotientFlottant) // Affiche : Division flottante : 3.333...
}

Exercice pratique : Calculs arithmétiques simples

Ecrivez un programme go qui déclare deux variables flottantes (float64), prixArticle et quantite. Calculez et affichez le prix total (prixArticle * quantite), la moitié du prix total (prixTotal / 2) et le prix total augmenté de 10% (prixTotal * 1.10).

Opérateurs de comparaison : vérifier les relations

Les opérateurs de comparaison servent à comparer deux valeurs et à déterminer si une relation est vraie ou fausse. Ils renvoient toujours une valeur de type booléen (true ou false). Go propose les opérateurs de comparaison suivants :

• Egalité : == (ex: 5 == 5 donne true, 5 == 6 donne false)
• Différence : != (ex: 5 != 6 donne true, 5 != 5 donne false)
• Supérieur à : > (ex: 6 > 5 donne true, 5 > 6 donne false)
• Inférieur à : < (ex: 5 < 6 donne true, 6 < 5 donne false)
• Supérieur ou égal à : >= (ex: 5 >= 5 donne true, 5 >= 4 donne true, 5 >= 6 donne false)
• Inférieur ou égal à : <= (ex: 5 <= 5 donne true, 5 <= 6 donne true, 5 <= 4 donne false)

Exemples de code avec les opérateurs de comparaison :

package main

import "fmt"

func main() {
    age := 25
    ageMajorite := 18

    estMajeur := age >= ageMajorite    // Supérieur ou égal
    estMineur := age < ageMajorite     // Inférieur à
    estVingtCinq := age == 25         // Egalité
    estDifferentDixHuit := age != 18  // Différence

    fmt.Println("Est majeur :", estMajeur)           // Affiche : Est majeur : true
    fmt.Println("Est mineur :", estMineur)           // Affiche : Est mineur : false
    fmt.Println("Est égal à 25 :", estVingtCinq)     // Affiche : Est égal à 25 : true
    fmt.Println("Est différent de 18 :", estDifferentDixHuit) // Affiche : Est différent de 18 : true
}

Exercice pratique : Comparaisons d'âges

Ecrivez un programme go qui demande à l'utilisateur de saisir son âge (entier). Déclarez une variable ageUtilisateur et stockez l'âge saisi. Utilisez les opérateurs de comparaison pour vérifier et afficher (avec fmt.Println et des messages clairs) :

• Si l'âge de l'utilisateur est égal à 18 ans.
• Si l'âge de l'utilisateur est inférieur à 18 ans.
• Si l'âge de l'utilisateur est supérieur ou égal à 60 ans.

Opérateurs logiques : combiner des conditions

Les opérateurs logiques permettent de combiner plusieurs expressions booléennes (conditions) pour créer des conditions plus complexes. Ils opèrent sur des valeurs booléennes et renvoient également une valeur booléenne.

Go propose trois opérateurs logiques principaux :

• ET logique (AND) : && (vrai si les deux conditions sont vraies, sinon faux)
• OU logique (OR) : || (vrai si au moins une des conditions est vraie, faux seulement si les deux sont fausses)
• NON logique (NOT) : ! (inverse la valeur booléenne : !true donne false, !false donne true)

Exemples de code avec les opérateurs logiques :

package main

import "fmt"

func main() {
    a := true
    b := false

    etLogique := a && b  // ET logique
    ouLogique := a || b  // OU logique
    nonA := !a          // NON logique sur a
    nonB := !b          // NON logique sur b

    fmt.Println("a ET b :", etLogique)   // Affiche : a ET b : false
    fmt.Println("a OU b :", ouLogique)   // Affiche : a OU b : true
    fmt.Println("NON a :", nonA)       // Affiche : NON a : false
    fmt.Println("NON b :", nonB)       // Affiche : NON b : true

    age := 25
    estEtudiant := true
    reductionValide := age < 26 && estEtudiant // Réduction si moins de 26 ans ET étudiant
    fmt.Println("Réduction valide :", reductionValide) // Affiche : Réduction valide : true
}

Exercice pratique : Conditions avec opérateurs logiques

Ecrivez un programme go qui demande à l'utilisateur de saisir son âge (entier) et s'il est étudiant (booléen : true pour oui, false pour non). Utilisez les opérateurs logiques pour vérifier et afficher (avec fmt.Println et des messages clairs) :

• Si l'utilisateur a moins de 18 ans OU est étudiant (au moins une des deux conditions est vraie).
• Si l'utilisateur a plus de 65 ans ET n'est pas étudiant (les deux conditions doivent être vraies).

Opérateurs d'affectation : donner des valeurs aux variables

L'opérateur d'affectation de base en go est le signe égal =. Il sert à donner une valeur à une variable. L'expression à droite du signe égal est évaluée, et le résultat est stocké dans la variable à gauche.

Go propose également des opérateurs d'affectation composés qui combinent une opération arithmétique ou logique avec une affectation. Ils permettent d'écrire du code plus concis et plus lisible lorsqu'on veut modifier la valeur d'une variable en fonction de sa valeur actuelle.

Opérateurs d'affectation composés :

• Addition et affectation : += (ex: x += 5 est équivalent à x = x + 5)
• Soustraction et affectation : -= (ex: x -= 3 est équivalent à x = x - 3)
• Multiplication et affectation : *= (ex: x *= 2 est équivalent à x = x * 2)
• Division et affectation : /= (ex: x /= 4 est équivalent à x = x / 4)
• Modulo et affectation : %= (ex: x %= 7 est équivalent à x = x % 7)

Exemples de code avec les opérateurs d'affectation :

package main

import "fmt"

func main() {
    compteur := 0
    compteur = 5         // Affectation simple
    fmt.Println("Compteur :", compteur) // Affiche : Compteur : 5

    compteur += 2        // Addition et affectation (compteur = compteur + 2)
    fmt.Println("Compteur += 2 :", compteur) // Affiche : Compteur += 2 : 7

    compteur -= 1        // Soustraction et affectation (compteur = compteur - 1)
    fmt.Println("Compteur -= 1 :", compteur) // Affiche : Compteur -= 1 : 6

    compteur *= 3        // Multiplication et affectation (compteur = compteur * 3)
    fmt.Println("Compteur *= 3 :", compteur) // Affiche : Compteur *= 3 : 18

    compteur /= 2        // Division et affectation (compteur = compteur / 2)
    fmt.Println("Compteur /= 2 :", compteur) // Affiche : Compteur /= 2 : 9

    compteur %= 5        // Modulo et affectation (compteur = compteur % 5)
    fmt.Println("Compteur %= 5 :", compteur) // Affiche : Compteur %= 5 : 4
}

Exercice pratique : Incrémentation et décrémentation

Ecrivez un programme go qui déclare une variable entière score et l'initialise à 0. Simulez un jeu où le joueur gagne des points et en perd. Utilisez les opérateurs d'affectation composés += et -= pour :

• Ajouter 10 points au score.
• Retirer 5 points au score.
• Ajouter 20 points au score.
• Retirer 3 points au score.

Après chaque opération, affichez le score actuel avec fmt.Println et un message clair.

Ordre des opérations (priorité des opérateurs)

Lorsque vous construisez des expressions complexes avec plusieurs opérateurs, go suit un ordre de priorité des opérateurs pour déterminer dans quel ordre les opérations sont effectuées. C'est comme les règles de priorité des opérations en mathématiques (PEMDAS/BODMAS).

Priorité des opérateurs en go (de la plus haute à la plus basse) :

1. Opérateurs unaires : ! (NON logique), + (unaire plus), - (unaire moins), ++ (incrémentation), -- (décrémentation)
2. Opérateurs multiplicatifs : * (multiplication), / (division), % (modulo)
3. Opérateurs additifs : + (addition), - (soustraction)
4. Opérateurs de comparaison : ==, !=, <, <=, >, >=
5. Opérateur ET logique : &&
6. Opérateur OU logique : ||

Les opérateurs de même priorité sont évalués de gauche à droite.

Pour modifier l'ordre de priorité, vous pouvez utiliser des parenthèses (). Les expressions entre parenthèses sont toujours évaluées en premier.

Exemples d'ordre des opérations :

package main

import "fmt"

func main() {
    resultat1 := 10 + 2 * 5   // Multiplication avant addition (priorité)
    fmt.Println("10 + 2 * 5 =", resultat1) // Affiche : 10 + 2 * 5 = 20 (car 2*5=10 puis 10+10=20)

    resultat2 := (10 + 2) * 5 // Parenthèses forcent l'addition en premier
    fmt.Println("(10 + 2) * 5 =", resultat2) // Affiche : (10 + 2) * 5 = 60 (car 10+2=12 puis 12*5=60)

    condition1 := true
    condition2 := false
    resultatLogique := condition1 || condition2 && condition1 // ET logique avant OU logique (priorité)
    fmt.Println("true || false && true =", resultatLogique) // Affiche : true || false && true = true (car false && true = false puis true || false = true)

    resultatLogiqueParentheses := (condition1 || condition2) && condition1 // Parenthèses forcent le OU logique en premier
    fmt.Println("(true || false) && true =", resultatLogiqueParentheses) // Affiche : (true || false) && true = true (car true || false = true puis true && true = true)
}

Conseil : Pour rendre vos expressions plus claires et éviter les erreurs liées à la priorité des opérateurs, utilisez des parenthèses même lorsque ce n'est pas strictement nécessaire. Cela améliore la lisibilité et assure que l'ordre des opérations est bien celui que vous souhaitez.

Exercice pratique : expressions complexes et ordre des opérations

Exercice : Ecrivez un programme go qui calcule le résultat des expressions suivantes et affiche le résultat de chaque expression avec fmt.Println. Essayez de prédire le résultat avant d'exécuter le programme et vérifiez si votre prédiction est correcte.

1. 20 - 5 * 2 + 3
2. (20 - 5) * (2 + 3)
3. true && false || true
4. !(true && false) || false
5. 10 % 3 + 4 * 2 - 1

Pour chaque expression, ajoutez des commentaires dans votre code pour expliquer pourquoi vous pensez que le résultat est celui que vous avez prédit, en tenant compte de la priorité des opérateurs et des parenthèses.

En résumé : opérateurs et expressions - la puissance de la manipulation des données

Félicitations ! Vous avez maintenant découvert les opérateurs et les expressions en go, les outils essentiels pour manipuler vos données et construire des programmes dynamiques et intelligents. Vous avez appris à utiliser :

• Les opérateurs arithmétiques pour effectuer des calculs.
• Les opérateurs de comparaison pour vérifier des relations entre les valeurs.
• Les opérateurs logiques pour combiner des conditions.
• Les opérateurs d'affectation pour donner et modifier les valeurs des variables.
• L'ordre de priorité des opérateurs et comment le contrôler avec des parenthèses.

Les opérateurs et les expressions sont au coeur de la programmation. En les maîtrisant, vous pouvez commencer à écrire des programmes go qui prennent des décisions, effectuent des tâches complexes et interagissent avec le monde extérieur. Continuez à pratiquer, à expérimenter et à explorer les chapitres suivants pour devenir un développeur go de plus en plus compétent !