1. Zmienne i Stałe

W języku Golang zmienne i stałe to dwa podstawowe koncepcje, które odgrywają bardzo ważną rolę w programie.

  • Zmienna to nazwany identyfikator używany do przechowywania danych w programie. W Golangu słowo kluczowe var służy do deklaracji zmiennych.
  • Stała to identyfikator, którego wartość nie może być zmieniona w programie. W Golangu słowo kluczowe const służy do deklaracji stałych.

2 Deklaracja i Inicjalizacja Zmiennych w Golangu

2.1 Deklaracja i Przypisanie Jednej Zmiennej

W języku Go słowo kluczowe var służy do deklaracji zmiennej w formacie var nazwa_zmiennej typ. Po deklaracji zmienna może być przypisana wartość w kolejnym kodzie lub może być bezpośrednio zainicjalizowana podczas deklaracji. Na przykład:

var wiek int // Deklaracja zmiennej całkowitej wiek
wiek = 25    // Przypisanie wartości zmiennej

var imie string = "Ala" // Deklaracja i inicjalizacja zmiennej imie

2.2 Deklaracja Wielu Zmiennych

Język Go obsługuje jednoczesną deklarację wielu zmiennych, co może sprawić, że kod będzie bardziej zwięzły. Deklaracja zbiorcza zazwyczaj jest wykonywana na początku funkcji lub na poziomie pakietu. Na przykład:

var (
    imie, nazwisko string
    wiek           int
)

imie = "Jan"
nazwisko = "Kowalski"
wiek = 30

W powyższej deklaracji zbiorczej imie i nazwisko są deklarowane jako ciągi znaków, a wiek jako liczba całkowita.

2.3 Wnioskowanie Typu i Krótka Deklaracja Zmiennych

W języku Go nie zawsze jest konieczne explicite określenie typu zmiennej. Jeśli podczas deklaracji zmiennej dostarczony jest wyrażenie inicjalizujące, Go może wywnioskować typ zmiennej. Jest to znane jako wnioskowanie typu. Krótka deklaracja zmiennych za pomocą := może upraszczać deklarację i inicjalizację zmiennych na podstawie wnioskowania typu. Na przykład:

miasto := "Warszawa" // Użycie krótkiej deklaracji zmiennej do jednoczesnej deklaracji i inicjalizacji miasta
panstwo := "Polska" // państwo jest wnioskowane jako typ string

Warto zauważyć, że krótka deklaracja zmiennych może być używana tylko wewnątrz funkcji i nie może być używana na poziomie globalnym.

2.4 Deklaracja Zmiennej Poza Funkcjami

Zmienne zadeklarowane poza funkcjami mają zasięg na poziomie pakietu. Te zmienne są widoczne i dostępne w całym pakiecie. Na przykład:

var globalnaZmienna string = "Jestem globalna" // Deklaracja zmiennej globalnej

func drukujGlobalnaZmienna() {
    fmt.Println(globalnaZmienna) // Dostęp do zmiennej globalnej wewnątrz funkcji
}

Zmienne globalne mogą być współdzielone między dowolnymi funkcjami w pakiecie, ale powinny być używane ostrożnie, aby uniknąć potencjalnych konfliktów nazewniczych i niejasnych odwołań.

Wskazówka: Zrozumienie podstawowego kodu funkcji tutaj jest wystarczające, szczegółowe wyjaśnienia funkcji zostaną podane w późniejszych sekcjach.

3 Podstawowe Typy Danych i Wartości Zero

3.1 Podstawowe Typy Danych w Golangu

W języku Go każdy typ zmiennej dostarcza jawne semantyczne charakterystyki zachowania. Oto kilka wspólnych podstawowych typów danych:

  • int, int8, int16, int32, int64: Różne zakresy liczb całkowitych
  • uint, uint8, uint16, uint32, uint64: Liczby całkowite bez znaku
  • float32, float64: Liczby zmiennoprzecinkowe
  • bool: Wartości logiczne (prawda lub fałsz)
  • string: Ciągi znaków

3.2 Pojęcie Wartości Zero

W języku Go zmienne są automatycznie inicjalizowane wartością zero odpowiadającą ich typowi po deklaracji. Wartość zero oznacza domyślną wartość odpowiadającego typu, gdy zmienna nie jest explicite zainicjalizowana. To nie jest powszechne w niektórych innych językach, ale w Go zapewnia, że wszystkie zmienne zawsze mają ważną wartość początkową. Oto wartości zero dla każdego podstawowego typu danych:

  • Wartość zero dla liczby całkowitej to 0
  • Wartość zero dla liczby zmiennoprzecinkowej to 0.0
  • Wartość zero dla wartości logicznej to false
  • Wartość zero dla ciągu znaków to pusty ciąg znaków ""

Na przykład:

var i int     // Wartość zero to 0
var f float64 // Wartość zero to 0.0
var b bool    // Wartość zero to false
var s string  // Wartość zero to ""

Zrozumienie pojęcia wartości zero jest bardzo ważne, ponieważ może pomóc programistom zrozumieć zachowanie inicjalizacji zmiennej i może być używane do zapobiegania błędom związanym z niezainicjowanymi wskaźnikami lub zmiennymi.

4. Zakres Zmiennych

4.1 Zmienne lokalne

Zmienne lokalne to zmienne zdefiniowane wewnątrz funkcji i mogą być używane jedynie wewnątrz tej funkcji. Parametry funkcji również należą do zmiennych lokalnych. Od momentu ich utworzenia do zakończenia wykonania funkcji, zmienne lokalne znikną. Za każdym razem, gdy wywoływana jest funkcja, zmienne lokalne są odtwarzane.

func przykladZmiennejLokalnej() {
    var zmiennaLokalna int = 10 // To jest zmienna lokalna
    fmt.Println(zmiennaLokalna)
}

func main() {
    przykladZmiennejLokalnej() // Wynik: 10
    // fmt.Println(zmiennaLokalna) // Spowoduje błąd kompilacji, ponieważ zmiennaLokalna nie jest widoczna tutaj
}

W powyższym przykładzie zmiennaLokalna może być używana tylko wewnątrz funkcji przykladZmiennejLokalnej.

4.2 Zmienne globalne

Zmienne globalne to zmienne zdefiniowane poza funkcjami i mogą być używane w dowolnym pliku w tej samej paczce. Aby użyć zmiennych globalnych w innych paczkach, nazwa zmiennej musi zaczynać się od dużej litery, zgodnie z zasadami kontroli dostępu Go.

package main

import "fmt"

var zmiennaGlobalna int = 20 // To jest zmienna globalna

func main() {
    fmt.Println(zmiennaGlobalna) // Wynik: 20
    zmienZmiennaGlobalna()
    fmt.Println(zmiennaGlobalna) // Wynik: 30
}

func zmienZmiennaGlobalna() {
    zmiennaGlobalna = 30 // Zmiana wartości zmiennej globalnej
}

W tym przykładzie zmiennaGlobalna jest widoczna zarówno w funkcji main, jak i w funkcji zmienZmiennaGlobalna.

5 Deklaracja i Użycie Stałych

5.1 Słowo kluczowe const

Używamy słowa kluczowego const do definiowania stałych. Stałe to wartości, których nie można modyfikować i po zdefiniowaniu ich wartość nie może być zmieniona. Stałe mogą być dowolnego podstawowego typu danych, takiego jak liczby całkowite, liczby zmiennoprzecinkowe, wartości logiczne lub ciągi znaków.

const Pi = 3.14 // Deklaracja stałej typu float
const StrConst string = "Witaj, Świecie!" // Deklaracja stałej typu string

func main() {
    fmt.Println(Pi)
    fmt.Println(StrConst)
}

5.2 Stałe typu wyliczeniowego

Język Go nie posiada określonego typu wyliczeniowego, ale można użyć słowa kluczowego iota do osiągnięcia wyliczeniowego efektu. Wewnątrz bloku const każde kolejne deklarowanie stałej zwiększy wartość iota o 1.

const (
    Niedziela = iota  // 0
    Poniedziałek         // 1
    Wtorek        // 2
    Środa      // 3
    Czwartek       // 4
    Piątek         // 5
    Sobota       // 6
)

func main() {
    fmt.Println(Niedziela)    // Wynik: 0
    fmt.Println(Sobota)  // Wynik: 6
}

Powyzszy kod deklaruje wyliczenie dla dni tygodnia, gdzie iota inicjuje się na 0 wewnątrz bloku const i zwiększa się o 1 dla każdej kolejnej deklaracji.

5.3 Zakres stałych

Zakres stałych jest podobny do zmiennych. Jeśli stała jest zdefiniowana wewnątrz funkcji, jej zakres jest ograniczony do tej funkcji. Jeśli stała jest zdefiniowana poza funkcją (globalnie), jej zakres jest całą paczką, a jeśli pierwsza litera jest wielką literą, można uzyskać do niej dostęp w innych paczkach.

Zarządzanie zakresem stałych pomaga zmniejszyć zanieczyszczenie globalnym zakresem i poprawia czytelność i czytelność programu.

const GlobalnaStała = "To jest globalna stała"

func main() {
    const LokalnaStała = "To jest lokalna stała"
    fmt.Println(GlobalnaStała)  // To jest poprawne
    fmt.Println(LokalnaStała)   // To jest poprawne
}

func innaFunkcja() {
    // fmt.Println(LokalnaStała) // Spowoduje błąd kompilacji: LokalnaStała nie jest widoczna w tej funkcji
    fmt.Println(GlobalnaStała)  // To jest poprawne
}

W tym przykładzie LokalnaStała może być używana tylko wewnątrz funkcji main, podczas gdy GlobalnaStała może być używana w całej paczce.