Datenverarbeitung mit Operatoren in Golang

Einführung

Nachdem Daten in einer Programmiersprache in Variablen gespeichert wurden, wie sollten wir sie verarbeiten?

Genau hier kommen die Operatoren ins Spiel, mit denen wir Berechnungen an den gespeicherten Daten durchführen können. In diesem Abschnitt werden wir Folgendes lernen:

Wissenspunkte:

• Arithmetische Operatoren
• Relationale Operatoren
• Logische Operatoren
• Zuweisungsoperatoren

Grundlegende Form

Arithmetische Operatoren sind die grundlegendsten Operatoren und repräsentieren die grundlegenden Rechenmethoden.

Erstellen Sie eine Datei namens opePractice.go im Verzeichnis home/project/:

cd ~/project
touch opePractice.go

Schreiben Sie folgenden Code hinein:

package main

import "fmt"

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

    // Addition, Subtraktion und Multiplikation
    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
    // In Go wird bei einer Ganzzahldivision abgerundet.
    fmt.Println("a / b =", a/b)
    // Bei einer Division von Fließkommazahlen gibt es dieses Problem nicht.
    fmt.Println("10.0 / 3 =", 10.0/3)

    // Modulo-Rechnung: allgemeine Form
    fmt.Println("a % b =", a%b)
    // Modulo-Rechnung mit negativen Zahlen
    // Rechenmethode: Rest = Dividend - (Dividend / Divisor) * Divisor
    fmt.Println("10 % -3 =", 10%-3)
    fmt.Println("-10 % 3 =", -10%3)
    fmt.Println("-10 % -3 =", -10%-3)
}

Führen Sie den Code aus und achten Sie besonders auf die Berechnung des negativen Restes.

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

Inkrement- und Dekrementoperatoren

In Go sind ++ (Inkrement) und -- (Dekrement) eigenständige Anweisungen und können nur unabhängig verwendet werden; sie sind keine Operatoren.

Der folgende Code ist falsch:

var a int = 5
var i int = 0
a = i++ // Falsche Verwendung, Inkrement kann nur unabhängig verwendet werden
a = i-- // Falsche Verwendung, Dekrement kann nur unabhängig verwendet werden
a = ++i // Falsche Verwendung, Go hat kein Prä-Inkrement
a = --i // Falsche Verwendung, Go hat kein Prä-Dekrement

Die richtige Syntax ist:

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

Schreiben Sie folgenden Code in opePractice.go:

Vervollständigen Sie den Code. Ändern Sie den Wert der Variablen i mit dem Inkrementoperator, sodass der Wert der Variablen a 16 wird:

package main

import "fmt"

func main() {
    var a int = 15
    var i int = 0
    /* Schreiben Sie den Code hier */

    a = a + i
    fmt.Println(a)
    // Vervollständigen Sie den Code, damit die Ausgabe von a gleich 16 ist
}

Relationale Operatoren

Was sind relationale Operatoren?

Relationale Operatoren sind eine Form des Vergleichs und beschreiben die Beziehung zwischen zwei Werten. Sie bestimmen, ob zwei Werte gleich sind, ob einer größer oder kleiner als der andere ist.

Die obigen Operatoren geben true zurück, wenn die Bedingung erfüllt ist, und false sonst.

Schreiben Sie folgenden Code in opePractice.go:

package main

import "fmt"

func main() {
    // Verwendung von relationalen Operatoren
    var a int = 7
    var b int = 6
    // Prüfen, ob gleich
    fmt.Println(a == b)  //false
    // Prüfen, ob ungleich
    fmt.Println(a!= b)  //true
    // Prüfen, ob a größer als b ist
    fmt.Println(a > b)   //true
    // Prüfen, ob a größer oder gleich b ist
    fmt.Println(a >= b)  //true
    // Prüfen, ob a kleiner als b ist
    fmt.Println(a < b)   //false
    // Prüfen, ob a kleiner oder gleich b ist
    fmt.Println(a <= b)  //false
    // Prüfen, ob 1 gleich 1 ist
    judgeValue := 1 == 1 //true
    fmt.Println(judgeValue)
}

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

Im obigen Code haben wir relationale Vergleiche basierend auf den Variablen a und b durchgeführt.

Schüler können die Variablenwerte ändern, um die Vergleichsergebnisse zu verändern und ein tieferes Verständnis von relationalen Operatoren zu erlangen.

Logische Operatoren

Was sind logische Operatoren?

Logische Operatoren sind eine fortgeschrittene Form von relationalen Operatoren. Sie werden hauptsächlich verwendet, um relationale Operatoren zu kombinieren und weitere Auswertungen durchzuführen.

| Operator | Beziehung | Erklärung |
| -------- | --------- | --------------------------------------------------------- | ---- | --------------------------------------------------------------- |
| && | Und | Wenn beide Operanden true sind, ist das Ergebnis true |
| | | | Oder | Wenn mindestens ein Operand true ist, ist das Ergebnis true |
| ! | Nicht | Wenn die Bedingung false ist, ist das Ergebnis true |

Schreiben Sie folgenden Code in opePractice.go:

package main

import (
    "fmt"
)

func main() {
    // Demonstration des logischen UND-Operators &&
    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")
    }
    // Demonstration des logischen ODER-Operators ||
    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")
    }
    // Demonstration des logischen NICHT-Operators!
    if age > 30 {
        fmt.Println("Age is greater than 30")
    }
    if!(age > 30) {
        fmt.Println("Age is not greater than 30")
    }
}

Im obigen Code haben wir eine Reihe von logischen Auswertungen basierend auf dem Wert 18 der Variablen age durchgeführt.

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

Schüler können den Wert der age-Variable ändern und den Code ausführen, um die Änderungen in der Ausgabe zu beobachten.

Ausführungsreihenfolge logischer Operatoren

Beim Verwenden von logischen UND- und logischen ODER-Operatoren muss Go die booleschen Werte auf beiden Seiten des Operators bestimmen. Aber welche Seite wird zuerst ausgewertet?

Lassen Sie uns das gemeinsam untersuchen.

Schreiben Sie folgenden Code in 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")
    }
}

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

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

Es fällt nicht schwer zu erkennen, dass bei der logischen UND-Operation zuerst der linke Operand ausgewertet wird und dann der rechte Operand.

Wie sieht es bei der logischen ODER-Operation aus? Schreiben Sie folgenden Code in 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")
    }
}

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

Left function is called!
Logical OR evaluation is complete

Die Auswertungsreihenfolge sowohl bei logischen UND- als auch bei logischen ODER-Operationen erfolgt von links nach rechts.

Jedoch wird bei der logischen ODER-Operation, wenn der linke Operand true ist, der rechte Operand nicht ausgewertet.

Daher sollten wir in der praktischen Entwicklung die Bedingungen, die wahrscheinlicher true sind, auf die linke Seite des logischen ODER-Operators setzen, um die Ausführungszeit des Programms zu verkürzen.

Zuweisungsoperatoren

In früheren Labs haben wir oft Zuweisungsoperatoren verwendet. Die Kernfunktion von Zuweisungsoperatoren besteht darin, den Wert eines Ausdrucks einem linken Operanden zuzuweisen.

Linker Operand: Der Ausdruck oder die Variable links vom Zuweisungsoperator (=), in den geschrieben werden kann.

In der praktischen Entwicklung müssen wir oft eine Variable von einer anderen addieren oder subtrahieren.

Basierend auf dem, was wir gelernt haben, könnten wir Code wie diesen schreiben:

x = x + 1

Aber dieser Art von Code ist in der praktischen Entwicklung sehr üblich, daher bieten wir eine Abkürzungsform dafür an:

x += 1

Ähnlich sind die gängigen Zuweisungsoperatoren:

Schreiben Sie folgenden Code in 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)
}

Im obigen Code weisen wir der Variable x einen Anfangswert von 11 zu und führen grundlegende arithmetische (Addition, Subtraktion, Multiplikation), Divisions- und Modulo-Berechnungen durch.

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

Sie können den Wert der Variablen ändern, um zu sehen, wie die Zuweisungsoperatoren funktionieren.

Zusammenfassung

Lassen Sie uns zusammenfassen, was wir in diesem Lab gelernt haben:

• Die Verwendung von arithmetischen Operatoren
• Die Verwendung von relationalen Operatoren
• Die Verwendung von logischen Operatoren
• Die Verwendung von Zuweisungsoperatoren

In diesem Lab haben wir besprochen, wie man Operatoren in Go verwendet. Wir haben verschiedene Operatoren und ihre Verwendung demonstriert.