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

Introduction

Une fois que les données sont enregistrées dans des variables dans un langage de programmation, comment devons-nous les traiter?

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

Points de connaissance :

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

Skills Graph

Forme de base

Les opérateurs arithmétiques sont les opérateurs les plus fondamentaux, représentant les méthodes de calcul de base.

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

cd ~/project
touch opePractice.go

Écrivez le code suivant dans ce fichier :

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 une division d'entiers est effectuée, le résultat est arrondi à l'entier inférieur.
    fmt.Println("a / b =", a/b)
    // Mais si une division de nombres à virgule flottante est effectuée, il n'y a pas de problème de ce genre.
    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 faites particulièrement attention à la façon 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 que de manière indépendante ; ce ne sont pas des opérateurs.

Le code suivant est incorrect :

var a int = 5
var i int = 0
a = i++ // Utilisation incorrecte, l'incrémentation ne peut être utilisée que de manière indépendante
a = i-- // Utilisation incorrecte, la décrémentation ne peut être utilisée que de manière indépendante
a = ++i // Utilisation incorrecte, Go n'a pas d'incrémentation préfixée
a = --i // Utilisation incorrecte, Go n'a pas de décrémentation préfixée

La syntaxe correcte est la suivante :

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

Qu'est-ce que les opérateurs relationnels?

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

Les opérateurs ci-dessus retournent true si la condition est vérifiée et false sinon.

É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 en fonction des variables a et b.

Les étudiants peuvent modifier les valeurs des variables pour changer les résultats de comparaison et mieux comprendre les opérateurs relationnels.

Opérateurs logiques

Qu'est-ce que les opérateurs logiques?

Les opérateurs logiques sont une forme avancée d'opérateurs relationnels. Ils sont principalement utilisés pour combiner des opérateurs relationnels afin d'effectuer des évaluations supplémentaires.

É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("Age is between 15 and 30")
    }
    if age > 30 && age < 80 {
        fmt.Println("Age is between 30 and 80")
    }
    // Démonstration de l'opérateur logique OU ||
    if age > 15 || age < 30 {
        fmt.Println("Age is greater than 15 or less than 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("Age is greater than 30 or less than 40")
    }
    // Démonstration de l'opérateur logique NON!
    if age > 30 {
        fmt.Println("Age is greater than 30")
    }
    if!(age > 30) {
        fmt.Println("Age is not greater than 30")
    }
}

Dans le code ci-dessus, nous avons effectué une série d'évaluations logiques en fonction de la valeur de la variable age, qui est de 18.

Exécutez le code :

cd ~/project
go run opePractice.go

Les étudiants peuvent 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("Left function is called!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Right function is called!")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("Evaluation is complete")
    }
}

Exécutez le code :

cd ~/project
go run opePractice.go

Left function is called!
Right function is called!
Evaluation is complete

Il n'est pas difficile de constater que dans l'opération logique ET, l'opérande de gauche est évalué en premier, puis l'opérande de droite est évalué.

Et que se passe-t-il dans l'opération logique OU? Écrivez le code suivant dans opePractice.go :

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Left function is called!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Right function is called!")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("Logical OR evaluation is complete")
    }
}

Exécutez le code :

cd ~/project
go run opePractice.go

Left function is called!
Logical OR evaluation is complete

L'ordre d'évaluation des opérations logiques ET et OU est de gauche à droite.

Cependant, dans l'opération logique OU, si l'opérande de gauche est vrai, l'opérande de droite n'est pas évalué.

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

Opérateurs d'affectation

Dans les laboratoires précédents, nous avons souvent utilisé les opérateurs d'affectation. La fonction principale des opérateurs d'affectation 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.

Dans le développement réel, nous avons souvent besoin d'ajouter ou de soustraire une variable à une autre.

D'après ce que nous avons appris, nous pourrions écrire un code comme celui-ci :

x = x + 1

Mais ce type de code est très courant dans le développement réel, donc nous en proposons une forme abrégée :

x += 1

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

Écrivez le code suivant dans opePractice.go :

package main

import "fmt"

func main() {
    x := 11
    fmt.Println("The initial value of x:", x)
    x += 5 // x = x + 5
    fmt.Println("Value after x += 5:", x)
    x -= 5 // x = x - 5
    fmt.Println("Value after x -= 5:", x)
    x *= 5 // x = x * 5
    fmt.Println("Value after x *= 5:", x)
    x /= 5
    fmt.Println("Value after x /= 5:", x)
    x %= 3
    fmt.Println("Value after x %= 3:", x)
}

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

Exécutez le code :

cd ~/project
go run opePractice.go

Vous pouvez modifier la valeur de la variable pour voir comment fonctionnent les opérateurs d'affectation.

Résumé

Revoyons ce que nous avons appris dans ce laboratoire :

• 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 laboratoire, nous avons discuté de la manière d'utiliser les opérateurs en Go. Nous avons démontré divers opérateurs et leur utilisation.