Programowanie w Go i pisanie bezwzrokowe naturalnie się ze sobą łączą. Go ma określone reguły składni i zestaw znaków specjalnych, które mogą stanowić wyzwanie podczas szybkiego pisania. Pisanie bezwzrokowe polega na pisaniu bez patrzenia na klawiaturę, a w kontekście Go jest to szczególnie istotne, ponieważ język wymaga precyzji: brakujący nawias klamrowy lub źle wpisany operator może spowodować błąd kompilacji.

Co jest charakterystyczne w składni Go?

Go to język kompilowany ang.: compiled language o czystym, minimalistycznym stylu. Kod źródłowy zawsze zaczyna się od deklaracji package. Importy można deklarować pojedynczo lub grupować w blokach. Funkcje deklaruje się słowem kluczowym func, a zakres ich działania ograniczają nawiasy klamrowe {}. Wcięcia nie wyznaczają bloków w Go; polecenie go fmt stosuje standardowe formatowanie kodu. Średniki zwykle pomija się w kodzie źródłowym, a kompilator wstawia je przy przejściach do nowego wiersza zgodnie z określonymi regułami. Oznacza to, że naciśnięcie Enter we właściwym miejscu nie jest tylko kwestią estetyki, ale regułą Go.

package main

import "fmt"

func main() {
 fmt.Println("Hello, Go")
}

Znaki, na które trzeba uważać

Podczas pisania w Go często spotkasz się z określonymi znakami. Nawiasy klamrowe {} wyznaczają ciała funkcji i bloki w instrukcjach sterujących. Nawiasy okrągłe () obejmują parametry funkcji i wywołania. Nawiasy kwadratowe [] definiują tablice i wycinki ang.: arrays i slices. Cudzysłowy " i odwrotne apostrofy ang.: backticks ` używane są w napisach. Operator krótkiej deklaracji := jest powszechny przy tworzeniu zmiennych. Kanały ang.: channels wprowadzają operator <-, który rzadko pojawia się w innych językach i wymaga dodatkowej uwagi.

Zmienne i deklaracje

W odróżnieniu od wielu języków Go rozróżnia deklarację przy pomocy var i krótką deklarację zmiennej z użyciem :=. Ten operator łączy dwukropek i znak równości, co bywa kłopotliwe, jeśli nie masz jeszcze wprawy w pisaniu symboli. Warto zwracać uwagę na ruchy palców - ten operator jest wszędzie w programach Go.

var count int = 10
message := "typed correctly"

Instrukcje sterujące

Go używa instrukcji if, for i switch. Nie ma w nim while. Składnia jest zwięzła, ale wymaga starannego wpisywania operatorów porównania ==, !=, <, > oraz operatora inkrementacji ++. Użycie = zamiast == w warunku spowoduje błąd kompilacji.

for i := 0; i < 5; i++ {
 if i%2 == 0 {
 fmt.Println("even")
 }
}

Funkcje i wiele wartości zwracanych

Funkcje w Go mogą zwracać więcej niż jedną wartość. To przydatna funkcja, ale oznacza, że często wpisujesz przecinki w listach zwracanych wartości i przypisaniach. Warto ćwiczyć, aż wpisywanie result, err := stanie się odruchem.

func divide(a, b int) (int, error) {
 if b == 0 {
 return 0, fmt.Errorf("division by zero")
 }
 return a/b, nil
}

result, err := divide(10, 2)

Wycinki (slices), mapy i literały złożone

Nawiasy kwadratowe [] i klamrowe {} pojawiają się bardzo często, gdy pracujesz z tablicami, wycinkami i mapami. Mapy używają też dwukropków : do oddzielania kluczy i wartości. Te symbole razem tworzą linie kodu, które mogą być trudne do wpisania bez błędów, jeśli nie czujesz się jeszcze z nimi pewnie.

nums := []int{1, 2, 3}
scores := map[string]int{"alice": 5, "bob": 7}

Struktury i metody

Typ struct w Go grupuje dane. Dodawanie metod wymaga wpisywania nawiasów dla odbiorników ang.: receivers i kropek . do dostępu do pól lub metod. Po pewnym czasie pisanie takich konstrukcji staje się tak naturalne, jak wpisywanie słowa kluczowego func.

type User struct {
 Name string
}

func (u User) Greet() string {
 return "Hello " + u.Name
}

u := User{Name: "A"}
fmt.Println(u.Greet())

Interfejsy

Interfejsy ang.: interfaces w Go są spełniane niejawnie, bez słowa kluczowego typu implements. Definiując je, wpisujesz kolejne nawiasy klamrowe i sygnatury metod. To niewielka ilość składni, ale warto nauczyć się pisać ją płynnie.

type Stringer interface {
 String() string
}

Współbieżność i kanały

Jednym z najbardziej charakterystycznych elementów Go jest operator kanału <-. Nie występuje on w wielu innych językach i początkowo może wydawać się niewygodny. Używasz go w obie strony: do wysyłania ch <- value i odbierania value := <-ch. Ćwiczenie tego operatora to ważna część nauki pisania w Go.

ch := make(chan int)
go func() { ch <- 42 }()
value := <-ch

Napisy (strings) i runy (runes)

Go używa cudzysłowów podwójnych do zwykłych napisów, odwrotnych apostrofów ang.: backticks do napisów surowych ang.: raw strings i pojedynczych apostrofów do run (pojedynczych znaków, typ rune). Łatwo je pomylić podczas szybkiego pisania, ale kompilator jest bezwzględny. Warto zwracać szczególną uwagę na przełączanie się między ", ` i '.

text := "normal string"
raw := `path\to\file`
r := 'a'

Odstępy i formatowanie

gofmt ujednolica formatowanie kodu. Podczas pisania musisz też przestrzegać reguł dotyczących nawiasów i kończenia linii. Typowym błędem jest naciśnięcie Enter w złym miejscu, na przykład między słowem return a zwracaną wartością. Go wstawia w tym miejscu średnik, kończąc instrukcję return. Kiedy przyzwyczaisz się do tych zasad, rytm pisania będzie zgodny z oczekiwanym stylem Go.

Podsumowanie

Programowanie w Go wymaga uwagi przy pisaniu. Najważniejsze znaki to nawiasy klamrowe {}, okrągłe (), kwadratowe [], operator krótkiej deklaracji := i strzałka kanału <-. Te symbole są wszędzie w kodzie Go. Ćwicz wpisywanie tych znaków, aby nabrać wprawy w szybkim i dokładnym pisaniu kodu Go.