La dattilografia è significativa nella programmazione. Sei più efficiente utilizzando tecniche di digitazione rapida per scrivere codice nel linguaggio di programmazione Go.
Programmazione in Go e dattilografia
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.