Messo in piedi l’IDE incominciamo a vedere come è strutturato il sorgente. Go è organizzato in package, quindi il primo comando definito all’interno del nostro file contiene la definizione del package tramite la direttiva package
Il package principale è main ed è quello da cui parte la nostra applicazione. Possiamo importare altri package per estendere le funzionalità a nostra disposizione e lo facciamo tramite la direttiva import. I package hanno la classica struttura ad albero, importante sapere che per invocare le funzioni all’interno del programma va usato l’ultimo nodo della definizione del package.
|
1 2 3 4 5 6 7 8 |
package main import ( "fmt" "math/rand" ) func main() { fmt.Print(rand.Intn(100)) } |
Nel codice sopra ho definito il package main, ho fatto l’import di 2 package di sistema e nella function main ho provveduto a stampare il risultato della chiamata random. Come potete vedere per invocare la funzione ho utilizzato l’ultima parte del nome del package rand.
L’elenco completo dei package di sistema è disponibile qui. L’import multiplo può essere fatto anche invocando più volte la direttiva import per ogni package ma così risulta più compatto.
A questo punto introduciamo le variabili, esse possono essere definite a livello di package o a livello di funzione, possono essere definite in modo esplicito tramite la chiave var e relativo tipo oppure lasciamo che sia Go a dedurre il tipo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package main import ( "fmt" "math/rand" ) var principale int = 10 var i, j, k int = 1, 3, 4 var numberFloat float64 func main() { fmt.Println(rand.Intn(100)) secondaria := true fmt.Println(principale) fmt.Println(secondaria) fmt.Println(i + j + k) fmt.Println(numberFloat) numberFloat = float64(principale) fmt.Println(numberFloat) } |
Nel blocco ho definito una variabile principale a livello di package tramite var e specificando il tipo, mentre ho definito una variabile secondaria a livello di function specificando direttamente il valore e lasciando decidere al compilatore la deduzione del tipo. L’operatore := può essere usato solo dentro una function.
Go mira alla stesura di codice compatto e permette la definizione di più variabili e relativa inizializzazione nello stesso statement.
I tipi semplici previsti da Go sono i sequenti:
|
1 2 3 4 5 6 7 8 |
bool string int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr byte // alias per il tipo uint8 rune // alias per il tipo int32 float32 float64 complex64 complex128 |
Quando si definisce una variabile e non si specifica il valore il sistema inizializza con 0 i numeri, false i tipo bool e stringa vuota i tipi string. La conversione tra i tipi non è implicita ma deve essere gestita tramite l’opprtuna funzione.
Tramite l’operatore const è possibile definire delle costanti, se definite con lettera maiuscola saranno visibili al di fuori del package e dovranno presentare un commento a corredo
|
1 2 |
// Costante - esempio const Costante = 10 |