Gépelési gyakorlat: Programozás Go nyelven

A Go nyelven való programozás és a gépelés gyakorlás természetesen összetartozik. A Go szigorú szintaxis-szabályokkal és speciális karakterekkel dolgozik, amelyek gyors gépelés közben könnyen hibára vihetnek. Egy hiányzó kapcsos zárójel vagy rosszul begépelt operátor azonnali fordítási hibát okoz - ezért a pontosság elsődleges.

Mi jellemző a Go szintaxisára?

A Go fordított nyelv ang.: compiled language tiszta, minimalista stílussal. A forráskód mindig package deklarációval indul. Az importokat blokkban szokás csoportosítani. A függvényeket a func kulcsszóval deklaráljuk, a tartományukat kapcsos zárójelek {} határolják. A behúzás nem opcionális - a Go a go fmt eszközzel egységes formázást kényszerít ki. Pontosvesszőt ritkán írunk; a fordító automatikusan beszúrja a sor végére a szabályok szerint. Emiatt a Enter helyes pozíciója szabály, nem ízlés kérdése.

package main

import "fmt"

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

Kiemelt karakterek, amelyekre érdemes figyelni

Gyakran fogsz írni kapcsos zárójeleket {} (blokkok), kerek zárójeleket () (paraméterek és hívások), szögletes zárójeleket [] (tömbök és szeletek - ang.: arrays, slices), idézőjeleket " és backtick-et ang.: backticks ` a sztringekhez. A rövid deklarációs operátor := mindennapos, a csatorna nyíl <- pedig Go-specifikus és távol eső billentyűket kombinál, ezért különösen könnyű elütni.

Változók és deklarációk

A Go különbséget tesz a var deklaráció és a rövid hozzárendelés := között. A := egyszerre jelent deklarálást és inicializálást lokális környezetben, míg a var külön típusmegadással (vagy típuslevezetéssel) használható. A := kettőspont + egyenlőség jel kombinációja - érdemes tudatosan gyakorolni.

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

Vezérlési szerkezetek

A Go-ban if, for és switch van - while nincs. A for háromrészes (init; feltétel; léptetés) formában és "while-szerűen" is használható. A leggyakoribb hibák: = gépelése == helyett, illetve a relációs operátorok <, >, != elütése.

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

i := 0
for i < 3 {
 i++
}

Függvények és több visszatérési érték

A Go függvények több értéket is visszaadhatnak. Emiatt gyakori a vesszők használata a visszatérési lista és a bal oldali többes hozzárendelés esetén. A hibakezelés jellegzetes minta: result, err := ... majd if err != nil { ... }.

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)
if err != nil {
 // kezeld a hibát
}

Slices, mapek és összetett literálok

A szögletes [] és kapcsos {} zárójelek állandó szereplők. A mapekben a kulcs-érték párokat kettőspont : választja el. Tipikus elütések: hiányzó vesszők a literálokban, vagy a zárójelek felcserélése.

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

Structok és metódusok

A struct adatok csoportosítására szolgál. A metódusok receiverrel ang.: receiver rendelkeznek, és a pont operátorral . hívhatók. A pointeres (*T) és érték szerinti (T) receiver különbözik viselkedésben - ezt a szignatúrában kell pontosan begépelni.

type User struct {
 Name string
}

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

func (u *User) Rename(n string) {
 u.Name = n
}

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

Interfészek

Az interfészek ang.: interfaces teljesítése implicit - nincs implements kulcsszó. A definíciójuk rövid, de a kapcsos zárójelek és a metódusaláírások gépelése legyen hibátlan.

type Stringer interface {
 String() string
}

Párhuzamosság és csatornák

A csatorna nyíl <- a Go egyik védjegye. Mind a küldés (ch <- value), mind a fogadás (value := <-ch) formáját meg kell szokni. A nyíl két karaktere távol van egymástól a billentyűzeten - érdemes tudatosan gyakorolni.

ch := make(chan int, 2)

go func() {
 ch <- 42
}()

v := <-ch
fmt.Println(v)

Stringek és runok

Dupla idézőjel (") a normál stringhez, backtick ang.: backticks ` a raw stringhez (nyers sztring), aposztróf (') az egyetlen Unicode-kódponthoz (rune). A három különböző határoló közti elütés nagyon gyakori hiba.

text := "normal string"
raw := `path\to\file\*.txt
no escapes here`
r := 'ß'

Behúzás és formázás

A Go egységes kódstílust kényszerít ki (gofmt/go fmt). A kapcsos zárójelek pozíciója, az importblokkok rendezése, a tabulátor-alapú behúzás mind a formatter dolga - neked a helyes karakterek begépelésére kell koncentrálni. Fontos: a szemikolon-beillesztés szabályai miatt nem tehetsz sortörést például a return és a visszaadott kifejezés közé.

Összefoglalás

A Go-ban a kritikus karakterek: kapcsos zárójelek {}, kerek zárójelek (), szögletes zárójelek [], a rövid deklaráció := és a csatorna nyíl <-. Ezek adják a mindennapi kódolás "ritmusát". Ha ezeket következetesen és pontosan gépeled, a Go-kód gyorsan és megbízhatóan fog összeállni.