Wie man mit Operatoren rechnet

Einführung

Zahlen sind in der Programmierung üblich. Sie werden verwendet, um Dinge wie Bildschirmgrößen, geografische Standorte, Geld und Punkte, die in einem Video verstrichene Zeit, Positionen von Spielavataren, Farben durch Zuweisen numerischer Codes usw. darzustellen.

Das effektive Ausführen mathematischer Operationen in der Programmierung ist eine wichtige Fähigkeit, die Sie entwickeln müssen, da Sie häufig mit Zahlen arbeiten. Ein höheres Verständnis der Mathematik kann Ihnen sicherlich dabei helfen, ein besserer Programmierer zu werden, ist jedoch keine Voraussetzung. Wenn Sie keinen mathematischen Hintergrund haben, stellen Sie sich Mathematik als Werkzeug vor, um das zu erreichen, was Sie erreichen möchten, und um Ihr logisches Denken zu verbessern.

Wir arbeiten mit zwei der am häufigsten verwendeten numerischen data types, integers und floats:

Integers sind ganze Zahlen, die positiv, negativ oder 0 sein können (…, + -1 +, + 0 +, + 1 +,…).
Floats sind reelle Zahlen, die einen Dezimalpunkt enthalten, z. B. "+ 9.0 " oder "" -2,25 + `..

In diesem Lernprogramm werden die Operatoren beschrieben, die wir in Go mit Nummerndatentypen verwenden können.

Betreiber

Ein Operator ist ein Symbol oder eine Funktion, die eine Operation angibt. In Mathematik ist beispielsweise das Pluszeichen oder "+" der Operator, der die Addition angibt.

In Go werden wir einige bekannte Operatoren sehen, die aus der Mathematik übernommen wurden. Andere Operatoren, die wir verwenden, sind jedoch spezifisch für die Computerprogrammierung.

Hier ist eine kurze Referenztabelle mit mathematischen Operatoren in Go. In diesem Lernprogramm werden alle folgenden Vorgänge behandelt.

Operation What it returns

Operation	What it returns
`x + y`	Sum of `x` and `y`
`x - y`	Difference of `x` and `y`
`-x`	Changed sign of `x`
`+x`	Identity of `x`
`x * y`	Product of `x` and `y`
`x / y`	Quotient of `x` and `y`
`x % y`	Remainder of `x` / `y`

x + y

Sum of x and y

x - y

Difference of x and y

-x

Changed sign of x

+x

Identity of x

x * y

Product of x and y

x / y

Quotient of x and y

x % y

Remainder of x / y

Wir werden auch zusammengesetzte Zuweisungsoperatoren behandeln, einschließlich "+ = +" und " * = ", die einen arithmetischen Operator mit dem " = +" - Operator kombinieren.

Addition und Subtraktion

In Go verhalten sich Additions- und Subtraktionsoperatoren genauso wie in der Mathematik. Tatsächlich können Sie die Programmiersprache Go als Taschenrechner verwenden.

Schauen wir uns einige Beispiele an, beginnend mit ganzen Zahlen:

fmt.Println(1 + 5)

Output6

Anstatt ganze Zahlen direkt an die Anweisung + fmt.Println + zu übergeben, können wir Variablen mit der folgenden Syntax so initialisieren, dass sie für ganzzahlige Werte stehen:

a := 88
b := 103

fmt.Println(a + b)

Output191

Da ganze Zahlen sowohl positive als auch negative Zahlen sein können (und auch 0), können wir eine negative Zahl mit einer positiven Zahl hinzufügen:

c := -36
d := 25

fmt.Println(c + d)

Output-11

Die Addition verhält sich bei Floats ähnlich:

e := 5.5
f := 2.5

fmt.Println(e + f)

Output8

Da wir zwei Floats zusammenaddiert haben, hat Go einen Float-Wert mit einer Dezimalstelle zurückgegeben. Da die Dezimalstelle in diesem Fall jedoch Null ist, hat + fmt.Println + die Dezimalformatierung verworfen. Um die Ausgabe richtig zu formatieren, können wir + fmt.Printf + und das Verb +%. 2f + verwenden, das auf zwei Dezimalstellen formatiert wird, wie in diesem Beispiel:

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

Output8.00

Die Syntax für die Subtraktion ist dieselbe wie für die Addition, außer dass wir unseren Operator vom Pluszeichen (+) zum Minuszeichen (+ - +) ändern:

g := 75.67
h := 32.0

fmt.Println(g - h)

Output43.67

In Go können wir nur Operatoren für dieselben Datentypen verwenden. Wir können kein + int + und kein https://www.digitalocean.com/community/tutorials/understanding-data-types-in-go#sizes-of-numeric-types [+ float64 +] hinzufügen:

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

Outputi + j (mismatched types int and float64)

Der Versuch, Operatoren für nicht identische Datentypen zu verwenden, führt zu einem Compilerfehler.

Unäre Rechenoperationen

Ein unärer mathematischer Ausdruck besteht nur aus einer Komponente oder einem Element. In Go können wir die Plus- und Minuszeichen als einzelnes Element in Kombination mit einem Wert verwenden, um: die Identität des Werts zurückzugeben (+) oder das Vorzeichen des Werts zu ändern (+ - +).

Das Pluszeichen gibt die Identität des Werts an, obwohl es nicht häufig verwendet wird. Wir können das Pluszeichen mit positiven Werten verwenden:

i := 3.3
fmt.Println(+i)

Output3.3

Wenn wir das Pluszeichen mit einem negativen Wert verwenden, wird auch die Identität dieses Werts zurückgegeben, und in diesem Fall wäre es ein negativer Wert:

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

Output-19

Bei einem negativen Wert gibt das Pluszeichen den gleichen negativen Wert zurück.

Das Minuszeichen ändert jedoch das Vorzeichen eines Werts. Wenn wir also einen positiven Wert übergeben, wird das Minuszeichen vor dem Wert einen negativen Wert zurückgeben:

k := 3.3
fmt.Println(-k)

Output-3.3

Wenn wir alternativ den unären Operator mit Minuszeichen und negativem Wert verwenden, wird ein positiver Wert zurückgegeben:

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

Output19

Die unären arithmetischen Operationen, die durch das Plus- und das Minuszeichen angezeigt werden, geben entweder die Identität des Werts im Fall von "+ i +" oder das entgegengesetzte Vorzeichen des Werts wie in " -i +" zurück.

Multiplikation und Division

Wie Addition und Subtraktion werden Multiplikation und Division sehr ähnlich aussehen wie in der Mathematik. Das Zeichen, das wir in Go für die Multiplikation verwenden, ist "+ * " und das Zeichen, das wir für die Division verwenden, ist " / +".

Hier ist ein Beispiel für die Multiplikation in Go mit zwei Float-Werten:

k := 100.2
l := 10.2

fmt.Println(k * l)

Output1022.04

In Go weist die Division je nach dem zu teilenden numerischen Typ unterschiedliche Merkmale auf.

Wenn wir Ganzzahlen teilen, führt der Go-Operator "+ / +" eine Unterteilung durch, wobei für den Quotienten * x * die zurückgegebene Zahl die größte Ganzzahl ist, die kleiner oder gleich * x * ist.

Wenn Sie das folgende Beispiel für das Teilen von "80 / 6 +" ausführen, erhalten Sie " 13 " als Ausgabe, und der Datentyp lautet " int +":

package main

import (
   "fmt"
)

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

   fmt.Println(m / n)
}

Output13

Wenn die gewünschte Ausgabe ein Gleitkomma ist, müssen Sie die Werte vor dem Teilen explizit konvertieren.

Sie können dies tun, indem Sie den gewünschten float-Typ "+ float32 () " oder " float64 () +" um Ihre Werte wickeln:

package main

import (
   "fmt"
)

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

Output13.333333333333334

Modulo

Der Operator "+% +" ist das modulo, das den Rest und nicht den Quotienten nach der Division zurückgibt. Dies ist nützlich, um Zahlen zu finden, die ein Vielfaches derselben Zahl sind.

Schauen wir uns ein Beispiel für das Modulo an:

o := 85
p := 15

fmt.Println(o % p)

Output10

Um dies aufzuschlüsseln, gibt "+ 85 " geteilt durch " 15 " den Quotienten von " 5 " mit einem Rest von " 10 " zurück. Unser Programm gibt hier den Wert " 10 +" zurück, da der Modulo-Operator den Rest eines Divisionsausdrucks zurückgibt.

Um Modul-Mathematik mit den Datentypen "+ float64 " durchzuführen, verwenden Sie die Funktion " Mod " aus dem Paket " math +":

package main

import (
   "fmt"

)

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

   s :=

   fmt.Println(s)
}

Output4

Operator-Vorrang

In Go müssen wir wie in der Mathematik berücksichtigen, dass Operatoren in der Rangfolge bewertet werden, nicht von links nach rechts oder von rechts nach links.

Betrachten wir den folgenden mathematischen Ausdruck:

u = 10 + 10 * 5

Wir können es von links nach rechts lesen, aber die Multiplikation wird zuerst durchgeführt. Wenn wir also "+ u +" drucken würden, würden wir den folgenden Wert erhalten:

Output60

Dies liegt daran, dass "10 * 5 +" zu " 50 " ausgewertet wird und wir dann " 10 " addieren, um " 60 +" als Endergebnis zurückzugeben.

Wenn wir stattdessen den Wert "+ 10 " zu " 10 " addieren möchten, dann multiplizieren wir diese Summe mit " 5 +". Wir verwenden Klammern in Go, so wie wir es in Mathe tun würden:

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

Output100

Eine Möglichkeit, sich an die Reihenfolge der Operationen zu erinnern, ist das Akronym * PEMDAS *:

Order	Letter	Stands for
1	P	Parentheses
2	E	Exponent
3	M	Multiplication
4	D	Division
5	A	Addition
6	S	Subtraction

Order

Letter

Stands for

Parentheses

Exponent

Multiplication

Division

Addition

Subtraction

Möglicherweise kennen Sie ein anderes Akronym für die Reihenfolge der Operationen, z. B. * BEDMAS * oder * BODMAS *. Unabhängig davon, welches Akronym für Sie am besten geeignet ist, sollten Sie es bei der Ausführung von mathematischen Operationen in Go berücksichtigen, damit die erwarteten Ergebnisse zurückgegeben werden.

Zuweisungsoperatoren

Der am häufigsten verwendete Zuweisungsoperator ist einer, den Sie bereits verwendet haben: das Gleichheitszeichen "+ = ". Der Zuweisungsoperator " = " weist den Wert rechts einer Variablen links zu. Zum Beispiel weist ` v = 23 ` der Variablen ` v ` den Wert der ganzen Zahl ` 23 +` zu.

Beim Programmieren werden häufig zusammengesetzte Zuweisungsoperatoren verwendet, die eine Operation mit dem Wert einer Variablen ausführen und dann den resultierenden neuen Wert dieser Variablen zuweisen. Diese zusammengesetzten Operatoren kombinieren einen arithmetischen Operator mit dem Operator "+ = +". Daher werden wir zum Hinzufügen "+" mit "+ = +" kombinieren, um den zusammengesetzten Operator " = +" zu erhalten. Mal sehen, wie das aussieht:

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

Output6

Zuerst setzen wir die Variable + w + gleich dem Wert von + 5 +, dann verwenden wir den zusammengesetzten Zuweisungsoperator ++ = +, um die rechte Zahl zum Wert der linken Variablen hinzuzufügen, und weisen dann zu das Ergebnis zu + w +.

Verknüpfungszuweisungsoperatoren werden häufig im Fall von "+ für +" - Schleifen verwendet, die Sie verwenden, wenn Sie einen Prozess mehrmals wiederholen möchten:

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

Indem Sie eine "+ für" -Schleife verwenden, um über das Segment mit dem Namen "+ Werte " zu iterieren, konnten Sie den Vorgang des Operators " * = " automatisieren, der die Variable " w +" mit der Zahl "+2 +" multiplizierte und ordnete das Ergebnis dann wieder der Variablen + w + `zu.

Go hat für jeden der in diesem Lernprogramm behandelten arithmetischen Operatoren einen zusammengesetzten Zuweisungsoperator.

So fügen Sie den Wert hinzu und weisen ihn zu:

y += 1

Um zu subtrahieren, weisen Sie dann den Wert zu:

y -= 1

Um dann zu multiplizieren, weisen Sie dann Wert zu:

y *= 2

Teilen und dann den Wert zuweisen:

y /= 3

Um den Rest zurückzugeben, weisen Sie den Wert zu:

y %= 3

Verknüpfungszuweisungsoperatoren können nützlich sein, wenn Dinge schrittweise erhöht oder verringert werden müssen oder wenn Sie bestimmte Prozesse in Ihrem Programm automatisieren müssen.

Fazit

In diesem Lernprogramm wurden viele der Operatoren behandelt, die Sie mit den numerischen Datentypen "Integer" und "Float" verwenden werden. Weitere Informationen zu verschiedenen Datentypen finden Sie unter Understanding Data Types in Go und https://www.digitalocean.com/ Community / Tutorials / Konvertieren von Datentypen in Go [Konvertieren von Datentypen].

TOC