Datenverarbeitung mit Operatoren in Golang

Einführung

Nachdem Daten in einer Programmiersprache in Variablen gespeichert wurden, stellt sich die Frage: Wie verarbeiten wir diese weiter?

An dieser Stelle kommen Operatoren ins Spiel, um Berechnungen mit den gespeicherten Daten durchzuführen. In diesem Abschnitt werden wir folgende Themen behandeln:

Lernziele:

• Arithmetische Operatoren
• Vergleichsoperatoren (Relationale Operatoren)
• Logische Operatoren
• Zuweisungsoperatoren

Grundformen

Arithmetische Operatoren sind die elementarsten Operatoren und repräsentieren die grundlegenden Rechenarten.

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

cd ~/project
touch opePractice.go

Schreiben Sie den 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 der Division von Ganzzahlen (Integers) abgerundet.
    fmt.Println("a / b =", a/b)
    // Bei Fließkommazahlen tritt dieses Problem hingegen nicht auf.
    fmt.Println("10.0 / 3 =", 10.0/3)

    // Modulo-Berechnung: Allgemeine Form
    fmt.Println("a % b =", a%b)
    // Modulo-Berechnung mit negativen Zahlen
    // Berechnungsmethode: 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 darauf, wie der negative Rest berechnet wird.

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 Dekrement-Operatoren

In Go sind ++ (Inkrement) und -- (Dekrement) eigenständige Anweisungen und können nur unabhängig verwendet werden; sie fungieren nicht als Teil eines komplexeren Ausdrucks.

Der folgende Code ist fehlerhaft:

var a int = 5
var i int = 0
a = i++ // Falsche Verwendung, Inkrement kann nur eigenständig stehen
a = i-- // Falsche Verwendung, Dekrement kann nur eigenständig stehen
a = ++i // Falsche Verwendung, Go unterstützt kein Prä-Inkrement
a = --i // Falsche Verwendung, Go unterstützt kein Prä-Dekrement

Die korrekte Syntax lautet:

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

Schreiben Sie den folgenden Code in opePractice.go:

Vervollständigen Sie den Code. Ändern Sie den Wert der Variable i mithilfe des Inkrement-Operators so, dass der Wert der Variable a am Ende 16 ergibt:

package main

import "fmt"

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

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

Vergleichsoperatoren

Was sind Vergleichsoperatoren?

Vergleichsoperatoren (auch relationale Operatoren genannt) dienen dem Vergleich von Werten und beschreiben die Beziehung zwischen zwei Operanden. Sie stellen fest, ob zwei Werte gleich sind oder ob ein Wert größer oder kleiner als der andere ist.

Die oben genannten Operatoren geben true zurück, wenn die Bedingung erfüllt ist, andernfalls false.

Schreiben Sie den folgenden Code in opePractice.go:

package main

import "fmt"

func main() {
    // Verwendung von Vergleichsoperatoren
    var a int = 7
    var b int = 6
    // Auf Gleichheit prüfen
    fmt.Println(a == b)  // false
    // Auf Ungleichheit prüfen
    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.

Sie können die Variablenwerte ändern, um die Vergleichsergebnisse zu beeinflussen und ein tieferes Verständnis für Vergleichsoperatoren zu erlangen.

Logische Operatoren

Was sind logische Operatoren?

Logische Operatoren sind eine Erweiterung der Vergleichsoperatoren. Sie werden primär dazu verwendet, mehrere Vergleichsausdrücke miteinander zu verknüpfen, um komplexere Bedingungen auszuwerten.

Schreiben Sie den 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("Alter liegt zwischen 15 und 30")
    }
    if age > 30 && age < 80 {
        fmt.Println("Alter liegt zwischen 30 und 80")
    }
    // Demonstration des logischen ODER-Operators ||
    if age > 15 || age < 30 {
        fmt.Println("Alter ist größer als 15 oder kleiner als 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("Alter ist größer als 30 oder kleiner als 40")
    }
    // Demonstration des logischen NICHT-Operators !
    if age > 30 {
        fmt.Println("Alter ist größer als 30")
    }
    if !(age > 30) {
        fmt.Println("Alter ist nicht größer als 30")
    }
}

Im obigen Code haben wir eine Reihe logischer Auswertungen basierend auf dem Wert 18 der Variable age durchgeführt.

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

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

Auswertungsreihenfolge logischer Operatoren

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

Lassen Sie uns dies gemeinsam untersuchen.

Schreiben Sie den folgenden Code in opePractice.go:

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Linke Funktion aufgerufen!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Rechte Funktion aufgerufen!")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("Auswertung abgeschlossen")
    }
}

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

Linke Funktion aufgerufen!
Rechte Funktion aufgerufen!
Auswertung abgeschlossen

Es ist unschwer zu erkennen, dass bei der logischen UND-Operation zuerst der linke Operand und anschließend der rechte Operand ausgewertet wird.

Wie sieht es bei der logischen ODER-Operation aus? Schreiben Sie den folgenden Code in opePractice.go:

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Linke Funktion aufgerufen!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Rechte Funktion aufgerufen!")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("Logische ODER-Auswertung abgeschlossen")
    }
}

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

Linke Funktion aufgerufen!
Logische ODER-Auswertung abgeschlossen

Die Auswertungsreihenfolge ist sowohl bei UND als auch bei ODER von links nach rechts.

Allerdings gibt es bei der logischen ODER-Operation eine Besonderheit: Wenn der linke Operand bereits true ist, wird der rechte Operand gar nicht mehr ausgewertet (Kurzschlussauswertung).

Daher ist es in der Praxis sinnvoll, Bedingungen, die mit höherer Wahrscheinlichkeit true ergeben, auf die linke Seite des ODER-Operators zu setzen, um die Ausführungszeit des Programms zu optimieren.

Zuweisungsoperatoren

In den vorangegangenen Labs haben wir bereits häufig Zuweisungsoperatoren verwendet. Die Kernfunktion eines Zuweisungsoperators besteht darin, den Wert eines Ausdrucks einem Operanden auf der linken Seite zuzuweisen.

Linksseitiger Operand (L-Value): Der Ausdruck oder die Variable links vom Zuweisungsoperator (=), in die geschrieben werden kann.

In der Softwareentwicklung ist es oft notwendig, einen Wert zu einer bestehenden Variable zu addieren oder davon zu subtrahieren.

Basierend auf dem bisher Gelernten könnten wir schreiben:

x = x + 1

Da dieses Muster extrem häufig vorkommt, bietet Go eine Kurzschreibweise dafür an:

x += 1

Hier sind die gängigsten Zuweisungsoperatoren im Überblick:

Schreiben Sie den folgenden Code in opePractice.go:

package main

import "fmt"

func main() {
    x := 11
    fmt.Println("Initialwert von x:", x)
    x += 5 // x = x + 5
    fmt.Println("Wert nach x += 5:", x)
    x -= 5 // x = x - 5
    fmt.Println("Wert nach x -= 5:", x)
    x *= 5 // x = x * 5
    fmt.Println("Wert nach x *= 5:", x)
    x /= 5
    fmt.Println("Wert nach x /= 5:", x)
    x %= 3
    fmt.Println("Wert nach x %= 3:", x)
}

In diesem Beispiel weisen wir der Variable x den Initialwert 11 zu und führen nacheinander grundlegende arithmetische Operationen sowie Division und Modulo-Berechnungen in der Kurzschreibweise durch.

Führen Sie den Code aus:

cd ~/project
go run opePractice.go

Sie können die Werte experimentell ändern, um zu sehen, wie sich die Zuweisungsoperatoren verhalten.

Zusammenfassung

Lassen Sie uns Revue passieren lassen, was wir in diesem Lab gelernt haben:

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

In diesem Lab haben wir die Anwendung verschiedener Operatoren in Go besprochen und deren Funktionsweise anhand praktischer Beispiele demonstriert.