Go Operators

1 Przegląd operatorów w języku Golang

W języku Go operatory służą do wykonywania operacji kodu programu, w tym operacji arytmetycznych, porównań relacyjnych, operacji logicznych i nie tylko. Różne operatory odpowiadają różnym funkcjonalnościom i scenariuszom użycia. Zrozumienie i opanowanie tych operatorów stanowi podstawę efektywnego programowania.

2 Operatory arytmetyczne

W języku Go dostępny jest zestaw operatorów arytmetycznych:

• Dodawanie (+): Operacja dodawania
• Odejmowanie (-): Operacja odejmowania
• Mnożenie (*): Operacja mnożenia
• Dzielenie (/): Operacja dzielenia
• Reszta z dzielenia (%): Operacja modulo

Przykłady:

package main

import "fmt"

func main() {
    // Operacja dodawania
    sum := 10 + 5
    fmt.Println("10 + 5 =", sum) // Wyświetla 15

    // Operacja odejmowania
    diff := 10 - 5
    fmt.Println("10 - 5 =", diff) // Wyświetla 5

    // Operacja mnożenia
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // Wyświetla 50

    // Operacja dzielenia
    quot := 10 / 5
    fmt.Println("10 / 5 =", quot) // Wyświetla 2

    // Operacja modulo
    rem := 10 % 5
    fmt.Println("10 % 5 =", rem) // Wyświetla 0
}

3 Operatory logiczne

Operatory logiczne w języku Go służą do łączenia wielu warunków (zazwyczaj używane dla wartości logicznych). Obejmują trzy typy: AND (&&), OR (||) i NOT (!).

3.1 AND (&&)

Gdy wszystkie warunki są prawdziwe, wynik operacji "AND" jest prawdziwy.

Przykłady:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // Wyświetla prawda
    fmt.Println(true && false)  // Wyświetla fałsz
    fmt.Println(false && false) // Wyświetla fałsz
    // Wynik jest prawdziwy tylko wtedy, gdy oba warunki są prawdziwe
}

3.2 OR (||)

Jeśli przynajmniej jeden warunek jest prawdziwy, wynik operacji "OR" jest prawdziwy.

Przykłady:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // Wyświetla prawda
    fmt.Println(true || false)  // Wyświetla prawda
    fmt.Println(false || false) // Wyświetla fałsz
    // Wynik jest prawdziwy, jeśli przynajmniej jeden warunek jest prawdziwy
}

3.3 NOT (!)

Służy do odwrócenia wartości logicznej warunku.

Przykłady:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // Wyświetla fałsz
    fmt.Println(!false) // Wyświetla prawda
    // Odwraca wartość logiczną
}

4 Operatory porównań

Operatory porównań w języku Go służą do porównywania dwóch zmiennych lub wartości:

• Równy (==)
• Nierówny (!=)
• Większy niż (>)
• Mniejszy niż (<)
• Większy lub równy (>=)
• Mniejszy lub równy (<=)

Wynik operacji porównania to wartość logiczna: true lub false.

5 Operatory bitowe

W Go operatory bitowe pozwalają na bezpośrednią manipulację binarnymi bitami danych:

• Bitowe AND (&)
• Bitowe OR (|)
• Bitowe XOR (^)
• Bitowe przesunięcie w lewo (<<)
• Bitowe przesunięcie w prawo (>>)

Operatory bitowe są głównie używane w programowaniu niskiego poziomu, takim jak bezpośrednie operacje sprzętowe, szyfrowanie i inne scenariusze.

6 Operatory przypisania

Operatory przypisania służą do przypisywania wartości do zmiennych. W języku Go istnieje kilka form operatorów przypisania:

• Proste przypisanie (=)
• Przypisanie dodawania (+=)
• Przypisanie odejmowania (-=)
• Przypisanie mnożenia (*=)
• Przypisanie dzielenia (/=)
• Przypisanie modulo (%=)

Te operatory sprawiają, że kod jest bardziej zwięzły. Na przykład x += 1 jest równoważne x = x + 1.

7 Specjalne operatory

7.1 Operatory inkrementacji (++) i dekrementacji (--)

Operator inkrementacji (++) i operator dekrementacji (--) służą do dodawania 1 i odejmowania 1 od wartości zmiennej, odpowiednio. Są to jedyne operatory w języku Go, które mogą działać bezpośrednio na samej zmiennej (nie na wyrażeniu).

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // Wyjście 2

    y := 10
    y--
    fmt.Println("y-- =", y) // Wyjście 9
}

Zauważ, że w języku Go, x++ lub x-- nie mogą być częścią wyrażenia. Na przykład, z := x++ nie jest dozwolone.

7.2 Konwersja Typów

Język Go jest statycznie typowany, co oznacza, że po zadeklarowaniu zmiennej jej typ nie może być zmieniony. Dlatego czasami konieczne jest konwertowanie zmiennej jednego typu na inny typ. Go nie ma automatycznej konwersji typów; wymagana jest jawna konwersja typów.

Przykład:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // Konwertuje int na float64

	var f float64 = 3.14
	fmt.Println(int(f)) // Konwertuje float64 na int, część dziesiętna zostanie odrzucona
}

Podczas wykonywania konwersji typów ważne jest zapewnienie bezpieczeństwa danych, np. potencjalna utrata precyzji podczas konwertowania liczby zmiennoprzecinkowej na liczbę całkowitą.