Ćwiczenie szybkiego pisania: Programowanie w języku Go

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 natychmiast spowoduje 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 są grupowane w blokach. Funkcje deklaruje się słowem kluczowym func, a zakres ich działania ograniczają nawiasy klamrowe {}. Wcięcia nie są opcjonalne - Go wymusza formatowanie przy pomocy polecenia go fmt. Język unika średników, ale kompilator automatycznie wstawia je na końcu linii. 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 {} pojawiają się po każdej funkcji lub instrukcji sterującej. 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ótkie przypisanie 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 ++. Nawet drobny błąd, jak użycie = zamiast ==, unieruchomi program.

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 mocna cecha, 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

Go wymusza jednolity styl kodu. To pomocne, ale oznacza również, że musisz przestrzegać zasad dotyczących nawiasów i kończenia linii. Typowym błędem jest naciśnięcie Enter w złym miejscu, na przykład po słowie return. Go od razu zgłosi błąd. 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. Ćwiczenie ich, aż staną się naturalne, to klucz do szybkiego i bezbłędnego pisania programów w Go.