Esercizio di dattilografia: Programmazione in linguaggio Go

Programmare in Go e usare la dattilografia si combinano naturalmente. Go ha regole di sintassi rigorose e caratteri speciali che possono risultare difficili da digitare rapidamente. Un errore in una parentesi graffa o in un operatore porta subito a un errore di compilazione.

Cosa è caratteristico della sintassi di Go?

Go è un linguaggio compilato (inglese: compiled language) con uno stile chiaro e minimalista. Il codice inizia sempre con una dichiarazione package. Le importazioni sono raggruppate in blocchi. Le funzioni si dichiarano con la parola chiave func e usano parentesi graffe {}. L'indentazione non è opzionale: Go applica automaticamente la formattazione con go fmt. I punti e virgola non si scrivono, ma il compilatore li inserisce automaticamente alla fine delle righe.

package main

import "fmt"

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

Caratteri da tenere a mente

Nel codice Go compaiono spesso parentesi graffe {}, tonde (), quadre [], virgolette ", backtick `, l'operatore di dichiarazione corta := e l'operatore dei canali <-.

Variabili e dichiarazioni

Go distingue tra la dichiarazione con var e l'assegnazione corta :=. Quest'ultima combina due simboli e appare ovunque nel codice.

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

Strutture di controllo

Go usa if, for e switch. Non esiste while. Gli operatori di confronto ==, !=, <, > e l'operatore ++ devono essere digitati con precisione.

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

Funzioni e valori di ritorno multipli

Le funzioni possono restituire più di un valore. Questo porta a scrivere virgole in liste di ritorno e assegnazioni.

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)

Slices, mappe e letterali compositi

Le parentesi quadre [] e graffe {} sono ovunque. Le mappe usano i due punti : tra chiave e valore.

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

Struct e metodi

Il tipo struct raggruppa dati. I metodi hanno un receiver e si chiamano con il punto ..

type User struct {
 Name string
}

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

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

Interfacce

Le interfacce sono soddisfatte implicitamente, senza una parola chiave come implements.

type Stringer interface {
 String() string
}

Concorrente e canali

L'operatore dei canali <- è tipico di Go. Si usa sia per inviare (ch <- valore) sia per ricevere (valore := <-ch).

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

Stringhe e rune

Le stringhe normali usano doppi apici, i backtick definiscono raw strings e gli apici singoli servono per le rune.

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

Indentazione e formattazione

Go impone uno stile unico. Le parentesi e gli a capo devono essere corretti. Un errore frequente è andare a capo subito dopo return.

Riepilogo

I caratteri principali in Go sono: parentesi graffe {}, tonde (), quadre [], l'operatore := e la freccia <-. Imparare a scriverli senza errori è la chiave per programmare velocemente e con precisione.