Kymmensormijärjestelmä opetus: Ohjelmointi Go kielellä

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 johtaa välittömään 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) ryhmitellään lohkoihin. Funktiot määritellään avainsanalla func ja niiden rajaus tapahtuu aaltosuluilla {}. Sisennys ei ole valinnaista - Go pakottaa muotoilun go fmt -työkalulla. Käytännössä puolipisteitä ei tarvitse kirjoittaa, mutta kääntäjä lisää ne automaattisesti rivin loppuun. 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 {} tulevat jokaisen funktion tai ohjausrakenteen jälkeen. 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. Pienikin virhe, kuten = väärässä paikassa ==:n sijaan, rikkoo koodin.

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

Go pakottaa yhtenäisen koodityylin. Tämä helpottaa lukemista, mutta tarkoittaa myös sitä, että sinun on kunnioitettava aaltosulkujen ja rivinvaihtojen paikkoja. Tyypillinen virhe on painaa Enter väärässä kohdassa, esimerkiksi heti return-sanan jälkeen. Go huomauttaa siitä heti. 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. Kun niiden kirjoittaminen tulee luonnostaan, voit kirjoittaa Go-ohjelmia nopeasti ja virheettömästi kymmensormijärjestelmällä.