Traitement des données avec les opérateurs en Golang

Introduction

Une fois que les données sont sauvegardées dans des variables au sein d'un langage de programmation, comment devons-nous les traiter ?

C'est là que nous avons besoin des opérateurs pour effectuer des calculs sur les données enregistrées. Dans cette section, nous allons aborder les points suivants :

Points de connaissances :

Opérateurs arithmétiques
Opérateurs relationnels
Opérateurs logiques
Opérateurs d'affectation

Formes de base

Les opérateurs arithmétiques sont les plus fondamentaux et représentent les méthodes de calcul classiques.

Opérateur	Fonction
`+`	Addition
`-`	Soustraction
`*`	Multiplication
`/`	Division
`%`	Modulo (Reste)

Créez un fichier nommé opePractice.go dans le répertoire home/project/ :

cd ~/project
touch opePractice.go

Écrivez-y le code suivant :

package main

import "fmt"

func main() {
    a := 10
    b := 3
    fmt.Println("a =", a, "b =", b)
    fmt.Println("-----")

    // Addition, soustraction et multiplication
    fmt.Println("a + b =", a+b)
    fmt.Println("a - b =", a-b)
    fmt.Println("b - a =", b-a)
    fmt.Println("a * b =", a*b)

    // Division
    // En Go, si un entier est divisé, le résultat est arrondi à l'inférieur.
    fmt.Println("a / b =", a/b)
    // Mais si un nombre à virgule flottante est divisé, ce problème ne se pose pas.
    fmt.Println("10.0 / 3 =", 10.0/3)

    // Calcul du modulo : forme générale
    fmt.Println("a % b =", a%b)
    // Calcul du modulo avec des nombres négatifs
    // Méthode de calcul : reste = dividende - (dividende / diviseur) * diviseur
    fmt.Println("10 % -3 =", 10%-3)
    fmt.Println("-10 % 3 =", -10%3)
    fmt.Println("-10 % -3 =", -10%-3)
}

Exécutez le code et portez une attention particulière à la manière dont le reste négatif est calculé.

cd ~/project
go run opePractice.go

a = 10 b = 3
-----
a + b = 13
a - b = 7
b - a = -7
a * b = 30
a / b = 3
10.0 / 3 = 3.3333333333333335
a % b = 1
10 % -3 = 1
-10 % 3 = -1
-10 % -3 = -1

Opérateurs d'incrémentation et de décrémentation

En Go, ++ (incrémentation) et -- (décrémentation) sont des instructions autonomes et ne peuvent être utilisées qu'indépendamment ; ce ne sont pas des opérateurs au sens expressionnel du terme.

Le code suivant est incorrect :

var a int = 5
var i int = 0
a = i++ // Usage incorrect, l'incrémentation ne peut être utilisée qu'indépendamment
a = i-- // Usage incorrect, la décrémentation ne peut être utilisée qu'indépendamment
a = ++i // Usage incorrect, Go ne possède pas de pré-incrémentation
a = --i // Usage incorrect, Go ne possède pas de pré-décrémentation

La syntaxe correcte est :

var i = 0
i++
i++
fmt.Println(i)

Écrivez le code suivant dans opePractice.go :

Complétez le code. Modifiez la valeur de la variable i en utilisant l'opérateur d'incrémentation, de sorte que la valeur de la variable a devienne 16 :

package main

import "fmt"

func main() {
    var a int = 15
    var i int = 0
    /* Écrivez le code ci-dessous */

    a = a + i
    fmt.Println(a)
    // Complétez le code pour que la sortie de a soit égale à 16
}

Opérateurs relationnels

Que sont les opérateurs relationnels ?

Les opérateurs relationnels sont une forme de comparaison décrivant la relation entre deux valeurs. Ils déterminent si deux valeurs sont égales, ou si l'une est supérieure ou inférieure à l'autre.

Opérateur	Relation
`==`	Égal à
`!=`	Différent de
`>`	Supérieur à
`>=`	Supérieur ou égal à
`<`	Inférieur à
`<=`	Inférieur ou égal à

Les opérateurs ci-dessus renvoient true si la condition est remplie et false dans le cas contraire.

Écrivez le code suivant dans opePractice.go :

package main

import "fmt"

func main() {
    // Utilisation des opérateurs relationnels
    var a int = 7
    var b int = 6
    // Vérifier si égal
    fmt.Println(a == b)  //false
    // Vérifier si différent
    fmt.Println(a != b)  //true
    // Vérifier si a est supérieur à b
    fmt.Println(a > b)   //true
    // Vérifier si a est supérieur ou égal à b
    fmt.Println(a >= b)  //true
    // Vérifier si a est inférieur à b
    fmt.Println(a < b)   //false
    // Vérifier si a est inférieur ou égal à b
    fmt.Println(a <= b)  //false
    // Vérifier si 1 est égal à 1
    judgeValue := 1 == 1 //true
    fmt.Println(judgeValue)
}

Exécutez le code :

cd ~/project
go run opePractice.go

Dans le code ci-dessus, nous avons effectué des comparaisons relationnelles basées sur les variables a et b.

Vous pouvez modifier les valeurs des variables pour changer les résultats des comparaisons et approfondir votre compréhension des opérateurs relationnels.

Opérateurs logiques

Que sont les opérateurs logiques ?

Les opérateurs logiques sont une forme avancée d'opérateurs relationnels. Ils sont principalement utilisés pour combiner plusieurs comparaisons relationnelles afin d'obtenir une évaluation globale.

Opérateur	Relation	Explication
`&&`	ET	Si les deux opérandes sont `true`, le résultat est `true`
`\|\|`	OU	Si l'un des deux opérandes est `true`, le résultat est `true`
`!`	NON	Si la condition est `false`, le résultat est `true`

Écrivez le code suivant dans opePractice.go :

package main

import (
    "fmt"
)

func main() {
    // Démonstration de l'opérateur logique ET (&&)
    var age int = 18
    if age > 15 && age < 30 {
        fmt.Println("L'âge est compris entre 15 et 30")
    }
    if age > 30 && age < 80 {
        fmt.Println("L'âge est compris entre 30 et 80")
    }
    // Démonstration de l'opérateur logique OU (||)
    if age > 15 || age < 30 {
        fmt.Println("L'âge est supérieur à 15 ou inférieur à 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("L'âge est supérieur à 30 ou inférieur à 40")
    }
    // Démonstration de l'opérateur logique NON (!)
    if age > 30 {
        fmt.Println("L'âge est supérieur à 30")
    }
    if !(age > 30) {
        fmt.Println("L'âge n'est pas supérieur à 30")
    }
}

Dans le code ci-dessus, nous avons effectué une série d'évaluations logiques basées sur la valeur 18 de la variable age.

Exécutez le code :

cd ~/project
go run opePractice.go

Vous pouvez modifier la valeur de la variable age et exécuter le code pour observer les changements dans la sortie.

Ordre d'exécution des opérateurs logiques

Lors de l'utilisation des opérateurs logiques ET et OU, Go doit déterminer les valeurs booléennes des deux côtés de l'opérateur. Mais quel côté est évalué en premier ?

Explorons cela ensemble.

Écrivez le code suivant dans opePractice.go :

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("La fonction de gauche est appelée !")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("La fonction de droite est appelée !")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("L'évaluation est terminée")
    }
}

Exécutez le code :

cd ~/project
go run opePractice.go

La fonction de gauche est appelée !
La fonction de droite est appelée !
L'évaluation est terminée

Il est facile de constater que dans l'opération ET logique, l'opérande de gauche est évalué en premier, suivi de l'opérande de droite.

Qu'en est-il de l'opération OU logique ? Écrivez le code suivant dans opePractice.go :

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("La fonction de gauche est appelée !")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("La fonction de droite est appelée !")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("L'évaluation du OU logique est terminée")
    }
}

Exécutez le code :

cd ~/project
go run opePractice.go

La fonction de gauche est appelée !
L'évaluation du OU logique est terminée

L'ordre d'évaluation des opérations ET logique et OU logique se fait de gauche à droite.

Cependant, dans l'opération OU logique, si l'opérande de gauche est vrai, l'opérande de droite n'est pas évalué. C'est ce qu'on appelle l'évaluation en court-circuit.

Par conséquent, dans le développement réel, il est recommandé de placer les conditions les plus susceptibles d'être vraies sur le côté gauche de l'opérateur OU logique afin de réduire le temps d'exécution du programme.

Opérateurs d'affectation

Dans les labs précédents, nous avons souvent utilisé des opérateurs d'affectation. La fonction principale de ces opérateurs est d'attribuer la valeur d'une expression à un opérande de gauche.

Opérande de gauche : L'expression ou la variable située à gauche de l'opérateur d'affectation (=) dans laquelle on peut écrire une valeur.

En développement, il est fréquent de devoir ajouter ou soustraire une valeur à une variable existante.

D'après ce que nous avons appris, nous pourrions écrire le code ainsi :

x = x + 1

Comme ce type de code est très courant, Go propose une forme abrégée :

x += 1

De même, les opérateurs d'affectation couramment utilisés incluent :

Opérateur	Description
`=`	Opérateur d'affectation de base
`+=`	Additionner puis affecter
`-=`	Soustraire puis affecter
`*=`	Multiplier puis affecter
`/=`	Diviser puis affecter
`%=`	Calculer le modulo puis affecter

Écrivez le code suivant dans opePractice.go :

package main

import "fmt"

func main() {
    x := 11
    fmt.Println("Valeur initiale de x :", x)
    x += 5 // x = x + 5
    fmt.Println("Valeur après x += 5 :", x)
    x -= 5 // x = x - 5
    fmt.Println("Valeur après x -= 5 :", x)
    x *= 5 // x = x * 5
    fmt.Println("Valeur après x *= 5 :", x)
    x /= 5
    fmt.Println("Valeur après x /= 5 :", x)
    x %= 3
    fmt.Println("Valeur après x %= 3 :", x)
}

Dans le code ci-dessus, nous attribuons une valeur initiale de 11 à la variable x et effectuons des opérations arithmétiques de base (addition, soustraction, multiplication), ainsi que des divisions et des calculs de modulo.

Exécutez le code :

cd ~/project
go run opePractice.go

Vous pouvez modifier la valeur de la variable pour observer le fonctionnement des opérateurs d'affectation.

Résumé

Récapitulons ce que nous avons appris dans ce lab :

L'utilisation des opérateurs arithmétiques
L'utilisation des opérateurs relationnels
L'utilisation des opérateurs logiques
L'utilisation des opérateurs d'affectation

Dans ce lab, nous avons exploré l'utilisation des opérateurs en Go. Nous avons démontré les différents types d'opérateurs et leurs cas d'usage respectifs.