Podstawy Go i pierwszy program

Cześć! Po tym, jak przedstawiłem filozofię stojącą za tym językiem, chcę zaprezentować podstawy Go. Zaraz po teorii chcę też pokazać przykładowy pierwszy program. Oczywiście nie musisz na początku instalować niczego na swoim komputerze. Polecam skorzystać sobie z The Go Playground.

Podstawy składni Go – zmienne, stałe i ich typy

W Go, jak w każdym języku programowania, mamy zmienne i stałe. Zmienne, bo nam się mogą zmieniać, stałe, bo raz zainicjowane wartością już jej nie zmieniają. Język jest też statycznie typowany. Oznacza to, że każda zmienna ma przypisany typ i jest on stały w ciągu trwania całej aplikacji. Nie możemy więc zrobić liczby z tekstu od tak.

maskotka go

Zmienne

Aby poinformować kompilator o nowej zmiennej, czyli zadeklarować ją, piszemy tak:

var nazwa typ

Jak łatwo zauważyć, zaczynamy od słowa kluczowego var, które informuje kompilator o pojawieniu się zmiennej. Możemy też nadać jej od razu wartość:

var nazwa typ = wartość

Wtedy od razu ją inicjujemy. Co bardziej spostrzegawczy zauważą, że nie ma też średnika. W Go nie używamy generalnie średników, chociaż są pewne wyjątki.

W Go mamy też możliwość pominięcia zarówno słowa kluczowego var, jak i typu. Kompilator jest na tyle mądry, że sam dobierze typ, na podstawie wartości. Wygląda to wtedy tak:

nazwa := wartość

Widzimy, że przed znakiem równości pojawia się jeszcze dwukropek. To jest skrócony operator deklaracji i jest bardzo często stosowany. W późniejszym czasie, kiedy dojdziemy do tablic, opowiem o różnicach, bo one się pojawiają.

Zmienne możemy też grupować i deklarować je masowo:

var (
    nazwa1 typ
    nazwa2 typ
    nazwa3 typ
)

// lub nawet tak

var (
    a, b, c typ = wartosc1, wartosc2, wartosc3
    d, e, f typ2 = wartosc4, wartosc5, wartosc6
)

Jeśli zmienne mają coś ze sobą wspólnego (np. użycie w jakimś kontekście), można je właśnie tak grupować.

Stałe

Stała – jak sama nazwa wskazuje, jej wartość przez czas trwania programu nie ulega zmianie. Podobnie jak w innych językach, stałą deklarujemy używając słowa kluczowego const.

const nazwa typ = wartosc

// lub

const nazwa = wartosc

Jak widać, śmiało możemy pominąć typ, ponieważ kompilator się domyśli. Podobnie jak zmienne, stałe możemy grupować:

const (
    nazwa = wartosc
    nazwa2 = wartosc2
)

Typy

Go jest językiem statycznie typowanym, więc trudno, mówiąc o zmiennych i stałych, pominąć temat typowania. Jeżeli chodzi o typy proste, to mamy do dyspozycji ich kilka rodzajów:

  • string – czyli podstawowy typ tekstowy
  • bool – prawda lub fałsz
  • int, int8, int16, int32, int64 – liczby całkowite
  • uint, uint8, uint16, uint32, uint64 – liczby całkowite bez znaku, czyli nieujemne
  • byte – to samo co uint8
  • rune – to samo co int32
  • float32, float64 – liczby zmiennoprzecinkowe
  • complex64 i complex128 – liczby zespolone

Jak widać, niektóre typy mają swoje wersje i te cyferki obok, to po prostu ich rozmiar w pamięci – np. int32 pozwala na zapisanie liczby całkowitej, która da się zapisać w 32 bitach.

Jaki rozmiar w takim razie ma int i uint? Deklarując zmienną z takim typem, zrzucamy na kompilator decyzję o najlepszym dla danej platformy i najwydajniejszym rozmiarze. Niemniej będzie to zawsze 32 i 64 bity – zazwyczaj 64 na systemach 64-bitowych i 32 na 32-bitowych.

Funkcje

Trudno napisać jakikolwiek program bez funkcji – chociażby po to, żeby cokolwiek wyświetlić na ekranie. Poza tym trzeba jeszcze wspomnieć, że w przeciwieństwie do np. Pythona czy PHP, ale w podobieństwie chociażby do C++ albo Javy, mamy funkcję main(), która jest punktem startowym każdego programu. To takie kompletne podstawy w Go.

Funkcja, to nic innego jak zbiór operacji. Funkcja może przyjmować parametry i zwracać jakąś wartość lub po prostu coś robić (wyświetlać na ekran) i nie zwracać nic. Składnia wygląda następująco:

func nazwa() {}

// lub

func nazwa (parametr typ) {}

//lub

func nazwa(parametr typ, parametr2 typ2, ...) typZwracany {}

// lub

func nazwa(parametr typ, parametr2 typ2) (typZwracany1, typZwracany2) {}

Pierwsze, co może się rzucić w oczy, a jest nieobecne w większości języków, to to, że w Go możemy zwracać kilka wartości. Jest to potrzebne chociażby do obsłużenia błędów, ale o tym innym razem. Zobaczmy, jak może wyglądać jakaś prosta implementacja:

func sum(a int, b int) int {
    return a + b
}

// to samo:

func sum(a, b int) int {
   return a + b
}

A sam program w całości wyglądałby tak:

// main.go
package main //ad1

import "fmt" //ad2

func main() {
    a := 2
    b := 3

    suma := sum(a, b)

    fmt.Print(suma) // wypisze 5
}

func sum(a, b int) int {
   return a + b
}

Widzimy, że tworzymy sobie dwie zmienne: a i b wraz z wartościami. Zaraz potem do zmiennej suma przypisujemy wynik funkcji sum() od powyższych parametrów. Potem wykorzystujemy funkcję Print() do wypisania tej wartości na ekran.

Teraz jeszcze dwa wyjaśnienia:

  1. Pierwsza (czy druga jeśli liczyć komentarz) linijka mówi o tym, że nasz plik należy do paczki „main„. Chwilowo potraktujmy to jako dogmat. Każdy plik w danym folderze musi mieć tę samą paczkę.
  2. Niżej importujemy paczkę „fmt„. W Go nawet biblioteka standardowa jest podzielona na paczki. Paczka fmt oferuje nam zbiór funkcji odpowiedzialnych za formatowanie wejścia i wyjścia. Tutaj po prostu wypisujemy coś na ekran korzystając z funkcji Print należącej do tejże paczki. O importach też jeszcze sobie napiszemy.

Na dziś to tyle jeśli chodzi o podstawy Go. Już niedługo będziemy kontynuować. Jeżeli język Cię zainteresował, zostaw komentarz, będzie mi bardzo miło!