Go-ohjelmointi ja kymmensormijärjestelmä kulkevat käytännössä käsi kädessä. Go-kieli sisältää joukon tarkkoja syntaksisääntöjä ja symboleja, jotka voivat olla haastavia kirjoittaa nopeasti. Kun kymmensormijärjestelmää käytetään, kirjoitetaan ilman että katsotaan näppäimistöön, ja Go:n kohdalla tarkkuus on erityisen tärkeää: puuttuva aaltosulku tai väärin kirjoitettu operaattori voi johtaa käännösvirheeseen.

Mikä on ominaista Go-syntaksille?

Go on käännettävä kieli, jossa on selkeä ja minimalistinen tyyli. Lähdekoodi alkaa aina package-määrittelyllä. Tuonnit (imports) voidaan määritellä yksittäin tai ryhmitellä lohkoihin. Funktiot määritellään avainsanalla func ja niiden rajaus tapahtuu aaltosuluilla {}. Sisennys ei määritä Go-koodin lohkoja; go fmt -työkalu muotoilee koodin yhtenäisen käytännön mukaan. Puolipisteet jätetään yleensä pois lähdekoodista, ja kääntäjä lisää ne rivinvaihtoihin tiettyjen sääntöjen mukaan. Tämä tarkoittaa, että Enter-näppäimen painallus oikeassa kohdassa ei ole vain tapa, vaan sääntö Go:ssa.

package main

import "fmt"

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

Symbolit, joihin kannattaa kiinnittää huomiota

Go-koodia kirjoitettaessa tietyt merkit toistuvat jatkuvasti. Aaltosulut {} rajaavat funktioiden rungot ja ohjausrakenteiden lohkot. Sulkeet () ympäröivät funktioiden parametrit ja kutsut. Hakasulut [] määrittelevät slice:t ja taulukot. Merkkijonoissa käytetään lainausmerkkejä " ja gravisia heittomerkkejä `. Lyhyt määrittelyoperaattori := on yleinen muuttujien luomisessa. Kanavissa käytetään operaattoria <-, joka on monelle vieras näppäimistöltä ja vaatii erityistä harjoittelua.

Muuttujat ja määrittelyt

Toisin kuin joissakin kielissä, Go erottaa var-määrittelyn ja lyhyen määrittelyn :=. Tämä operaattori yhdistää kaksoispisteen ja yhtäsuuruusmerkin, mikä voi olla kömpelö kirjoittaa, jos ei ole vielä sujuva symbolien käytössä. Sormien liikkeeseen kannattaa kiinnittää huomiota - tämä operaattori esiintyy lähes kaikissa Go-ohjelmissa.

var count int = 10
message := "kirjoitettu oikein"

Ohjausrakenteet

Go käyttää rakenteita if, for ja switch. Erillistä while-rakennetta ei ole. Syntaksi on tiivis, mutta edellyttää tarkkaa kirjoittamista vertailuoperaattoreiden ==, !=, <, > sekä inkrementointioperaattorin ++ kohdalla. Ehdossa käytetty = ==:n sijaan aiheuttaa käännösvirheen.

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

Funktiot ja useat paluuarvot

Funktiot voivat palauttaa useamman kuin yhden arvon. Tämä on tehokas ominaisuus, mutta se tarkoittaa, että pilkut esiintyvät usein sekä paluuarvolistoissa että sijoituksissa. Harjoittelu tekee esimerkiksi rivistä result, err := luonnollisen kirjoittaa.

func divide(a, b int) (int, error) {
 if b == 0 {
 return 0, fmt.Errorf("nollalla ei voi jakaa")
 }
 return a/b, nil
}

result, err := divide(10, 2)

Slicet, mapit ja koostelitteraalit

Hakasulut [] ja aaltosulut {} esiintyvät jatkuvasti, kun työskennellään slicejen, taulukoiden ja mapien kanssa. Mapit käyttävät lisäksi kaksoispistettä : avaimen ja arvon erottamiseen. Nämä symbolit yhdessä muodostavat rivejä, jotka voivat olla hankalia kirjoittaa virheettömästi ilman harjoittelua.

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

Structit ja metodit

Go:n struct-tyyppi ryhmittelee dataa. Metodien lisääminen edellyttää sulkujen käyttöä vastaanottajalle sekä pisteen . kirjoittamista kenttien tai metodien kutsuun. Kun tätä tekee tarpeeksi usein, metodin vastaanottajan kirjoittaminen tuntuu yhtä luontevalta kuin sanan func kirjoittaminen.

type User struct {
 Name string
}

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

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

Rajapinnat (Interfaces)

Rajapinnat toteutetaan Go:ssa implisiittisesti, ilman erillisiä avainsanoja kuten implements. Niiden määrittely tuo lisää aaltosulkuja ja metodien allekirjoituksia kirjoitettavaksi. Kyse on pienestä määrästä syntaksia, mutta sen sujuva kirjoittaminen on hyödyllinen taito.

type Stringer interface {
 String() string
}

Rinnakkaisuus ja kanavat

Yksi Go:n erottuvimmista piirteistä on kanavaoperaattori <-. Se ei ole tuttu monista muista kielistä ja voi tuntua kömpelöltä aluksi. Sitä käytetään sekä lähettämiseen ch <- value että vastaanottamiseen value := <-ch. Kun harjoittelet tämän merkin kirjoittamista sujuvasti, säästät paljon vaivaa.

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

Merkkijonot ja runet

Go käyttää kaksoislainausmerkkejä normaaleihin merkkijonoihin, gravisia heittomerkkejä raakamerkkijonoihin ja yksittäisiä lainausmerkkejä rune-arvoihin. Näiden sekoittaminen on helppoa, jos kirjoitat nopeasti, mutta kääntäjä on tiukka. Erityisesti kannattaa kiinnittää huomiota siihen, milloin käytät ", ` ja '.

text := "normaali merkkijono"
raw := `polku\tiedostoon`
r := 'a'

Välit ja muotoilu

gofmt muotoilee koodin yhtenäiseen tyyliin. Kirjoittaessasi sinun on myös noudatettava aaltosulkujen ja rivinvaihtojen sijoittamista koskevia sääntöjä. Tyypillinen virhe on painaa Enter väärässä kohdassa, esimerkiksi return-sanan ja palautettavan arvon välissä. Go lisää tähän rivinvaihtoon puolipisteen, joka päättää return-lauseen. Kun totut näihin sääntöihin, kirjoitustahdistasi tulee yhtenäinen ja yhteensopiva Go:n muotoilusääntöjen kanssa.

Yhteenveto

Go-ohjelmointi edellyttää tarkkuutta kirjoittamisessa. Tärkeimmät merkit ovat aaltosulut {}, sulut (), hakasulut [], lyhyt määrittelyoperaattori := ja kanavien nuoli <-. Nämä symbolit ovat kaikkialla Go-koodissa. Harjoittele näiden merkkien kirjoittamista, jotta saat lisää varmuutta Go-koodin nopeaan ja tarkkaan kirjoittamiseen kymmensormijärjestelmällä.