Comment faire des maths en ligne avec des opérateurs

introduction

Les nombres sont courants dans la programmation. Ils sont utilisés pour représenter des éléments tels que: dimensions de la taille de l’écran, emplacements géographiques, argent et points, durée de la vidéo, positions des avatars du jeu, couleurs par l’attribution de codes numériques, etc.

Effectuer efficacement des opérations mathématiques en programmation est une compétence importante à développer en raison de la fréquence à laquelle vous travaillez avec des nombres. Bien qu’une connaissance approfondie des mathématiques puisse certainement vous aider à devenir un meilleur programmeur, ce n’est pas une condition préalable. Si vous n’avez pas de formation en mathématiques, essayez de penser aux mathématiques en tant qu’outil permettant d’accomplir ce que vous souhaitez accomplir et d’améliorer votre pensée logique.

Nous allons travailler avec deux desdata types numériques,integers etfloats les plus utilisés de Go:

Integers sont des nombres entiers qui peuvent être positifs, négatifs ou 0 (…,-1,0,1,…).
Floats sont des nombres réels contenant un point décimal, comme9.0 ou-2.25 ..

Ce didacticiel présentera les opérateurs que nous pouvons utiliser avec les types de données numériques dans Go.

Les opérateurs

Unoperator est un symbole ou une fonction qui indique une opération. Par exemple, en mathématiques, le signe plus ou+ est l'opérateur qui indique l'addition.

Dans Go, nous verrons des opérateurs familiers issus des mathématiques. Cependant, d'autres opérateurs que nous utiliserons sont spécifiques à la programmation informatique.

Voici un tableau de référence rapide des opérateurs liés aux mathématiques dans Go. Nous allons couvrir toutes les opérations suivantes dans ce tutoriel.

Opération Ce qu'il retourne

Opération	Ce qu'il retourne
`x + y`	Somme de`x` et`y`
`x - y`	Différence de`x` et`y`
`-x`	Changement du signe de`x`
`+x`	Identité de`x`
`x * y`	Produit de`x` et`y`
`x / y`	Quotient de`x` et`y`
`x % y`	Reste de`x` /`y`

x + y

Somme dex ety

x - y

Différence dex ety

-x

Changement du signe dex

+x

Identité dex

x * y

Produit dex ety

x / y

Quotient dex ety

x % y

Reste dex /y

Nous couvrirons également les opérateurs d'assignation composés, y compris+= et*=, qui combinent un opérateur arithmétique avec l'opérateur=.

Addition et soustraction

Dans Go, les opérateurs d'addition et de soustraction fonctionnent comme en mathématiques. En fait, vous pouvez utiliser le langage de programmation Go comme calculatrice.

Voyons quelques exemples, en commençant par les entiers:

fmt.Println(1 + 5)

Output6

Au lieu de passer des entiers directement dans l'instructionfmt.Println, nous pouvons initialiser des variables pour qu'elles représentent des valeurs entières en utilisant une syntaxe comme celle-ci:

a := 88
b := 103

fmt.Println(a + b)

Output191

Comme les entiers peuvent être à la fois des nombres positifs et négatifs (et 0 également), nous pouvons ajouter un nombre négatif avec un nombre positif:

c := -36
d := 25

fmt.Println(c + d)

Output-11

L'addition se comportera de la même manière avec les flotteurs:

e := 5.5
f := 2.5

fmt.Println(e + f)

Output8

Comme nous avons ajouté deux flottants ensemble, Go a renvoyé une valeur de flottant avec une décimale. Cependant, puisque la décimale est zéro dans ce cas,fmt.Println a supprimé la mise en forme décimale. Pour formater correctement la sortie, nous pouvons utiliserfmt.Printf et le verbe%.2f, qui se formateront à deux décimales, comme cet exemple:

fmt.Printf("%.2f", e + f)

Output8.00

La syntaxe de la soustraction est la même que celle de l'addition, sauf que nous changeons notre opérateur du signe plus (+) au signe moins (-):

g := 75.67
h := 32.0

fmt.Println(g - h)

Output43.67

Dans Go, nous ne pouvons utiliser des opérateurs que sur les mêmesdata types. Nous ne pouvons pas ajouter unint et unfloat64:

i := 7
j := 7.0
fmt.Println(i + j)

Outputi + j (mismatched types int and float64)

Si vous essayez d'utiliser des opérateurs sur des types de données différents, vous obtiendrez une erreur du compilateur.

Opérations arithmétiques unaires

Une expression mathématique unaire consiste en un seul composant ou élément. Dans Go, nous pouvons utiliser les signes plus et moins comme un élément unique associé à une valeur pour: renvoyer l'identité de la valeur (+) ou changer le signe de la valeur (-).

Bien que cela ne soit pas couramment utilisé, le signe plus indique l'identité de la valeur. Nous pouvons utiliser le signe plus avec des valeurs positives:

i := 3.3
fmt.Println(+i)

Output3.3

Lorsque nous utilisons le signe plus avec une valeur négative, il retournera également l'identité de cette valeur et, dans ce cas, ce serait une valeur négative:

j := -19
fmt.Println(+j)

Output-19

Avec une valeur négative, le signe plus renvoie la même valeur négative.

Le signe moins, cependant, change le signe d'une valeur. Ainsi, lorsque nous passons une valeur positive, nous constatons que le signe moins avant la valeur renvoie une valeur négative:

k := 3.3
fmt.Println(-k)

Output-3.3

Sinon, lorsque nous utilisons l'opérateur unaire de signe moins avec une valeur négative, une valeur positive est renvoyée:

j := -19
fmt.Println(-j)

Output19

Les opérations arithmétiques unaires indiquées par le signe plus et le signe moins renverront soit l’identité de la valeur dans le cas de+i, soit le signe opposé de la valeur comme dans-i.

Multiplication et division

Tout comme l'addition et la soustraction, la multiplication et la division ressembleront beaucoup à ce qu'elles sont en mathématiques. Le signe que nous utiliserons dans Go pour la multiplication est* et le signe que nous utiliserons pour la division est/.

Voici un exemple de multiplication en Go avec deux valeurs float:

k := 100.2
l := 10.2

fmt.Println(k * l)

Output1022.04

En Go, la division a des caractéristiques différentes selon le type numérique que nous divisons.

Si nous divisons des entiers, l'opérateur/ de Go effectue la division par étage, où pour le quotientx, le nombre renvoyé est le plus grand entier inférieur ou égal àx.

Si vous exécutez l'exemple suivant de division de80 / 6, vous recevrez13 en sortie et le type de données seraint:

package main

import (
    "fmt"
)

func main() {
    m := 80
    n := 6

    fmt.Println(m / n)
}

Output13

Si la sortie souhaitée est un float, vous devez convertir explicitement les valeurs avant de les diviser.

Vous pouvez le faire en enveloppant le type de flottant souhaité defloat32() oufloat64() autour de vos valeurs:

package main

import (
    "fmt"
)

func main() {
    s := 80
    t := 6
    r := float64(s) / float64(t)
    fmt.Println(r)
}

Output13.333333333333334

Modulo

L'opérateur% est lemodulo, qui renvoie le reste plutôt que le quotient après la division. Ceci est utile pour rechercher des nombres qui sont des multiples du même nombre.

Regardons un exemple du modulo:

o := 85
p := 15

fmt.Println(o % p)

Output10

Pour décomposer cela,85 divisé par15 renvoie le quotient de5 avec un reste de10. Notre programme renvoie ici la valeur10, car l'opérateur modulo renvoie le reste d'une expression de division.

Pour faire des calculs de module avec les types de donnéesfloat64, vous utiliserez la fonctionMod du packagemath:

package main

import (
    "fmt"
    "math"
)

func main() {
    q := 36.0
    r := 8.0

    s := math.Mod(q, r)

    fmt.Println(s)
}

Output4

Préséance de l'opérateur

Dans Go, comme en mathématiques, il ne faut pas oublier que les opérateurs seront évalués par ordre de priorité, et non de gauche à droite ou de droite à gauche.

Si nous regardons l'expression mathématique suivante:

u = 10 + 10 * 5

Nous pouvons le lire de gauche à droite, mais la multiplication sera effectuée en premier, donc si nous devions imprimeru, nous recevrions la valeur suivante:

Output60

Ceci est dû au fait que10 * 5 est évalué à50, puis nous ajoutons10 pour renvoyer60 comme résultat final.

Si à la place nous souhaitons ajouter la valeur10 à10, puis multiplier cette somme par5, nous utilisons des parenthèses dans Go comme nous le ferions en mathématiques:

u := (10 + 10) * 5
fmt.Println(u)

Output100

Une façon de se souvenir de l'ordre des opérations consiste à utiliser l'acronymePEMDAS:

Commande	Lettre	Représente
1	P	Parenthèses
2	E	Exposant
3	M	Multiplication
4	D	Division
5	A	Une addition
6	S	Soustraction

Commande

Lettre

Représente

Parenthèses

Exposant

Multiplication

Division

Une addition

Soustraction

Vous connaissez peut-être un autre acronyme pour l'ordre des opérations, commeBEDMAS ouBODMAS. Quel que soit l'acronyme qui vous convient le mieux, essayez de le garder à l'esprit lorsque vous effectuez des opérations mathématiques dans Go, afin que les résultats escomptés soient renvoyés.

Opérateurs d'assignation

L'opérateur d'affectation le plus courant est celui que vous avez déjà utilisé: le signe égal=. L'opérateur d'affectation= affecte la valeur de droite à une variable de gauche. Par exemple,v = 23 affecte la valeur de l'entier23 à la variablev.

Lors de la programmation, il est courant d’utiliser des opérateurs d’assignation composés qui effectuent une opération sur la valeur d’une variable, puis attribuent la nouvelle valeur obtenue à cette variable. Ces opérateurs composés combinent un opérateur arithmétique avec l'opérateur=. Par conséquent, pour l’addition, nous combinerons+` with `+=+` to get the compound operator `=+. Voyons à quoi ça ressemble:

w := 5
w += 1
fmt.Println(w)

Output6

Tout d'abord, nous définissons la variablew égale à la valeur de5, puis nous utilisons l'opérateur d'affectation composé+= pour ajouter le nombre de droite à la valeur de la variable de gauche, puis attribuer le résultat àw.

Les opérateurs d'affectation composés sont fréquemment utilisés dans le cas des bouclesfor, que vous utiliserez lorsque vous souhaitez répéter un processus plusieurs fois:

package main

import "fmt"

func main() {

    values := []int{0, 1, 2, 3, 4, 5, 6}

    for _, x := range values {

        w := x

        w *= 2

        fmt.Println(w)
    }

}

Output0
2
4
6
8
10
12

En utilisant une bouclefor pour itérer sur la tranche appeléevalues, vous avez pu automatiser le processus de l'opérateur*= qui multipliait la variablew par le nombre2, puis réassigner le résultat dans la variablew.

Go a un opérateur d'assignation composé pour chacun des opérateurs arithmétiques décrits dans ce tutoriel.

Pour ajouter puis assigner la valeur:

y += 1

Pour soustraire alors assigner la valeur:

y -= 1

Pour multiplier, attribuez ensuite valeur:

y *= 2

Pour diviser, assignez la valeur:

y /= 3

Pour retourner le reste, assignez la valeur:

y %= 3

Les opérateurs d'affectation de composés peuvent être utiles lorsque des éléments doivent être augmentés ou diminués progressivement, ou lorsque vous devez automatiser certains processus de votre programme.

Conclusion

Ce didacticiel couvre la plupart des opérateurs que vous utiliserez avec les types de données numériques entier et flottant. Vous pouvez en savoir plus sur les différents types de données dansUnderstanding Data Types in Go etHow To Convert Data Types.

TOC