Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Apprendre Notions de Base des Opérateurs et des Expressions | Commencer
Introduction à Golang
course content

Contenu du cours

Introduction à Golang

Introduction à Golang

1. Commencer
2. Types de Données
3. Structures de Contrôle
4. Fonctions
5. Tableaux et Tranches
6. Introduction aux Structs et Maps

book
Notions de Base des Opérateurs et des Expressions

En programmation Go, les opérateurs sont des symboles ou des combinaisons de symboles qui effectuent diverses opérations sur des valeurs ou des variables.

Une expression est une combinaison de valeurs et d'opérateurs qui donne une valeur évaluée. Par exemple, 7 + 9 est une expression qui donne 16, et 7 * 9 est une expression qui donne 63, car l'opérateur * représente la multiplication.

Dans ce chapitre, nous explorerons les opérateurs arithmétiques. La plupart des autres opérateurs seront abordés dans les sections suivantes, selon leur pertinence.

OpérateurFonction
+Addition
-Soustraction
*Multiplication
/Division
%Reste(Mod)
++Incrément
--Décrément

Étudier le code suivant et ses sorties correspondantes peut être un exercice précieux pour la compréhension du code. Tous les opérateurs arithmétiques sont expliqués dans le code à l'aide de commentaires, ainsi que la sortie respective.

go

index

copy
123456789101112131415161718192021222324252627282930313233343536
package main import "fmt" func main() { // Addition fmt.Println("Addition (7 + 9):", 7+9) // Outputs 16 // Subtraction fmt.Println("Subtraction (7 - 9):", 7-9) // Outputs -2 // Multiplication fmt.Println("Multiplication (7 * 9):", 7*9) // Outputs 63 // Division fmt.Println("Division (10 / 2):", 10/2) // Outputs 5 fmt.Println("Division (7 / 9):", 7/9) // Outputs 0, reason will be explained in the next section // Remainder (Modulus) fmt.Println("Mod (10 % 2)", 10%2) // Outputs 0 fmt.Println("Mod (10 % 3)", 10%3) // Outputs 1 fmt.Println("Mod (10 % 4)", 10%4) // Outputs 2 var myVar = 1 fmt.Println("Value:", myVar) // Outputs 1 // Increment Operator (++) // Increases a variable's value by 1 myVar++ fmt.Println("Value (after ++):", myVar) // Outputs 2 // Decrement Operator (--) // Decreases a variable's value by 1 myVar-- fmt.Println("Value (after --)", myVar) // Outputs 1 }

Par défaut, en Go, les expressions sont évaluées en utilisant la règle BODMAS (également connue sous le nom de PEMDAS). Selon cette règle, une expression est évaluée dans l'ordre suivant :

  1. Parenthèses;
  2. Exposants;
  3. Division;
  4. Multiplication;
  5. Addition;
  6. Soustraction;

Considérons l'expression 1 + 3 * 4 / 2. L'ordre d'évaluation et le résultat sont les suivants :

1 + 3 * 4 / 21 + 3 * 21 + 67

Ainsi, fmt.Println(1 + 3 * 4 / 2) affiche 7.

Nous pouvons utiliser des parenthèses pour changer l'ordre des opérations et, par conséquent, le résultat :

(1 + 3) * 4 / 24 * 4 / 24 * 28

Les parenthèses peuvent également être imbriquées pour un contrôle plus précis des opérations :

((1 - 3) + 4) / 2(-2 + 4) / 22 / 21

Dans le cas ci-dessus, la soustraction a été effectuée en premier, suivie de l'addition, puis de la division.

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 1. Chapitre 7
We're sorry to hear that something went wrong. What happened?
some-alt