Golang Operatoren

1 Übersicht der Golang-Operatoren

In der Go-Sprache werden Operatoren verwendet, um Programmcodeoperationen durchzuführen, einschließlich arithmetischer Operationen, relationaler Vergleiche, logischer Operationen und mehr. Unterschiedliche Operatoren entsprechen verschiedenen Funktionalitäten und Anwendungsszenarien. Das Verständnis und die Beherrschung dieser Operatoren ist die Grundlage für effektives Programmieren.

2 Arithmetische Operatoren

Die Go-Sprache bietet eine Reihe von arithmetischen Operatoren:

• Addition (+): Addition
• Subtraktion (-): Subtraktion
• Multiplikation (*): Multiplikation
• Division (/): Division
• Rest (%): Modulo-Operation

Beispiele:

package main

import "fmt"

func main() {
    // Addition
    sum := 10 + 5
    fmt.Println("10 + 5 =", sum) // Gibt 15 aus

    // Subtraktion
    diff := 10 - 5
    fmt.Println("10 - 5 =", diff) // Gibt 5 aus

    // Multiplikation
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // Gibt 50 aus

    // Division
    quot := 10 / 5
    fmt.Println("10 / 5 =", quot) // Gibt 2 aus

    // Modulo
    rem := 10 % 5
    fmt.Println("10 % 5 =", rem) // Gibt 0 aus
}

3 Logische Operatoren

Logische Operatoren in der Go-Sprache werden verwendet, um mehrere Bedingungen zu verknüpfen (in der Regel für boolesche Werte). Es gibt drei Typen: UND (&&), ODER (||) und NICHT (!).

3.1 UND (&&)

Wenn alle Bedingungen wahr sind, ist das Ergebnis der "UND"-Operation wahr.

Beispiele:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // Gibt true aus
    fmt.Println(true && false)  // Gibt false aus
    fmt.Println(false && false) // Gibt false aus
    // Ergebnis ist nur wahr, wenn beide Bedingungen wahr sind
}

3.2 ODER (||)

Wenn mindestens eine Bedingung wahr ist, ist das Ergebnis der "ODER"-Operation wahr.

Beispiele:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // Gibt true aus
    fmt.Println(true || false)  // Gibt true aus
    fmt.Println(false || false) // Gibt false aus
    // Ergebnis ist wahr, wenn mindestens eine Bedingung wahr ist
}

3.3 NICHT (!)

Wird verwendet, um den booleschen Wert einer Bedingung umzukehren.

Beispiele:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // Gibt false aus
    fmt.Println(!false) // Gibt true aus
    // Kehrt den booleschen Wert um
}

4 Vergleichsoperatoren

Vergleichsoperatoren in der Go-Sprache werden verwendet, um zwei Variablen oder Werte zu vergleichen:

• Gleich (==)
• Nicht gleich (!=)
• Größer als (>)
• Kleiner als (<)
• Größer oder gleich (>=)
• Kleiner oder gleich (<=)

Das Ergebnis von Vergleichsoperationen ist ein boolescher Wert: true oder false.

5 Bitweise Operatoren

In Go ermöglichen bitweise Operatoren die direkte Manipulation der binären Bits von Daten:

• Bitweise UND (&)
• Bitweise ODER (|)
• Bitweise XOR (^)
• Bitweise Linksverschiebung (<<)
• Bitweise Rechtsverschiebung (>>)

Bitweise Operatoren werden hauptsächlich in der Low-Level-Programmierung, wie direkten Hardwareoperationen, Verschlüsselung und anderen Szenarien, verwendet.

6 Zuweisungsoperatoren

Zuweisungsoperatoren werden verwendet, um Werte Variablen zuzuweisen. In der Go-Sprache gibt es mehrere Formen von Zuweisungsoperatoren:

• Einfache Zuweisung (=)
• Additionszuweisung (+=)
• Subtraktionszuweisung (-=)
• Multiplikationszuweisung (*=)
• Divisionszuweisung (/=)
• Moduluszuweisung (%=)

Diese Operatoren machen den Code prägnanter. Zum Beispiel ist x += 1 äquivalent zu x = x + 1.

7 Spezielle Operatoren

7.1 Inkrement (++) und Dekrement (--) Operatoren

Der Inkrementoperator (++) und Der Dekrementoperator (--) werden verwendet, um 1 zu einer Variablen hinzuzufügen bzw. abzuziehen. Sie sind die einzigen Operatoren in der Go-Sprache, die direkt auf die Variable selbst (nicht auf einen Ausdruck) wirken können.

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // Gibt 2 aus

    y := 10
    y--
    fmt.Println("y-- =", y) // Gibt 9 aus
}

Beachten Sie, dass in der Go-Sprache x++ oder x-- kein Teil eines Ausdrucks sein kann. Zum Beispiel ist z := x++ nicht erlaubt.

7.2 Typkonvertierung

Die Go-Sprache ist statisch typisiert, was bedeutet, dass sobald eine Variable deklariert ist, ihr Typ nicht geändert werden kann. Daher ist es manchmal notwendig, eine Variable eines Typs in einen anderen Typ umzuwandeln. Go hat keine automatische Typkonvertierung; eine explizite Typkonvertierung ist erforderlich.

Beispiel:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // Konvertiert int in float64

	var f float64 = 3.14
	fmt.Println(int(f)) // Konvertiert float64 in int, der Dezimalteil wird verworfen
}

Bei der Durchführung der Typkonvertierung ist es wichtig, sicherzustellen, dass die Daten während des Konvertierungsprozesses sicher sind, wie zum Beispiel das potenzielle Verlust an Präzision bei der Umwandlung einer Gleitkommazahl in eine Ganzzahl.