Site Overlay

Il tuo primo programma

Tradizionalmente il primo programma che scrivi in qualsiasi linguaggio di programmazione è chiamato un programma “Hello World” – un programma che emette semplicemente Hello World sul tuo terminale. Scriviamone uno usando Go.

Prima creiamo una nuova cartella dove possiamo memorizzare il nostro programma. Create una cartella chiamata ~/src/golang-book/chapter2. (Dove ~ significa la vostra home directory) Dal terminale potete farlo inserendo i seguenti comandi:

mkdir src/golang-bookmkdir src/golang-book/chapter2

Usando il vostro editor di testo digitate quanto segue:

package mainimport "fmt"// this is a commentfunc main() { fmt.Println("Hello World")}

Assicuratevi che il vostro file sia identico a quello mostrato qui e salvatelo come main.go nella cartella che abbiamo appena creato. Aprite un nuovo terminale e digitate quanto segue:

cd src/golang-book/chapter2go run main.go

Dovresti vedere Hello World visualizzato nel tuo terminale. Il comando go run prende i file successivi (separati da spazi), li compila in un eseguibile salvato in una directory temporanea e poi esegue il programma. Se non hai visto visualizzato Hello World potresti aver fatto un errore nel digitare il programma. Il compilatore Go ti darà dei suggerimenti su dove si trova l’errore. Come la maggior parte dei compilatori, il compilatore Go è estremamente pedante e non ha tolleranza per gli errori.

Come leggere un programma Go

Guardiamo questo programma più in dettaglio. I programmi Go si leggono dall’alto in basso, da sinistra a destra. (come un libro) La prima riga dice questo:

package main

Questa è conosciuta come una “dichiarazione di pacchetto”. Ogni programma Go deve iniziare con una dichiarazione di pacchetto. I pacchetti sono il modo di Go di organizzare e riutilizzare il codice. Ci sono due tipi di programmi Go: eseguibili e librerie. Gli eseguibili sono i tipi di programmi che possiamo eseguire direttamente dal terminale. (in Windows finiscono con .exe) Le librerie sono collezioni di codice che impacchettiamo insieme in modo da poterle usare in altri programmi. Esploreremo le librerie in modo più dettagliato più avanti, per ora assicurati di includere questa linea in ogni programma che scrivi.

La prossima linea è una linea vuota. I computer rappresentano le newline con un carattere speciale (o più caratteri). Newlines, spazi e tabulazioni sono conosciuti come spazi bianchi (perché non si possono vedere). Go per lo più non si preoccupa degli spazi bianchi, noi li usiamo per rendere i programmi più facili da leggere. (Potresti rimuovere questa linea e il programma si comporterebbe esattamente allo stesso modo)

Poi vediamo questo:

import "fmt"

La parola chiave import è come includiamo codice da altri pacchetti da usare con il nostro programma. Il pacchetto fmt (abbreviazione di format) implementa la formattazione per l’input e l’output. Dato quello che abbiamo appena imparato sui pacchetti, cosa pensi che i file del pacchetto fmt possano contenere in cima ad essi?

Nota che fmt sopra è circondato da doppi apici. L’uso di doppi apici come questo è noto come “letterale di stringa” che è un tipo di “espressione”. In Go le stringhe rappresentano una sequenza di caratteri (lettere, numeri, simboli, …) di una lunghezza definita. Le stringhe sono descritte più in dettaglio nel prossimo capitolo, ma per ora la cosa importante da tenere a mente è che un carattere " di apertura deve essere seguito da un altro " e qualsiasi cosa tra i due è inclusa nella stringa. (Il carattere " stesso non fa parte della stringa)

La linea che inizia con // è conosciuta come un commento. I commenti sono ignorati dal compilatore Go e sono lì per il tuo bene (o per chiunque prenda il codice sorgente del tuo programma). Go supporta due diversi stili di commenti: Commenti // in cui tutto il testo tra il // e la fine della linea fa parte del commento e commenti /* */ in cui tutto ciò che è compreso tra i * fa parte del commento. (E può includere più righe)

Dopo questo si vede una dichiarazione di funzione:

func main() { fmt.Println("Hello World")}

Le funzioni sono gli elementi costitutivi di un programma Go. Hanno ingressi, uscite e una serie di passi chiamati dichiarazioni che vengono eseguiti in ordine. Tutte le funzioni iniziano con la parola chiave func seguita dal nome della funzione (main in questo caso), una lista di zero o più “parametri” circondati da parentesi, un tipo di ritorno opzionale e un “corpo” che è circondato da parentesi graffe. Questa funzione non ha parametri, non restituisce nulla e ha solo una dichiarazione. Il nome main è speciale perché è la funzione che viene chiamata quando si esegue il programma.

Il pezzo finale del nostro programma è questa linea:

 fmt.Println("Hello World")

Questa dichiarazione è fatta di tre componenti. Prima accediamo ad un’altra funzione all’interno del pacchetto fmt chiamata Println (questo è il pezzo fmt.Println, Println significa Print Line). Poi creiamo una nuova stringa che contiene Hello World e invochiamo (noto anche come chiamata o esecuzione) quella funzione con la stringa come primo e unico argomento.

A questo punto abbiamo già visto un sacco di nuova terminologia e potresti essere un po’ sopraffatto. A volte è utile leggere deliberatamente il vostro programma ad alta voce. Una lettura del programma che abbiamo appena scritto potrebbe andare così:

Crea un nuovo programma eseguibile, che fa riferimento alla libreria fmt e contiene una funzione chiamata main. Questa funzione non prende argomenti, non restituisce nulla e fa quanto segue: Accede alla funzione Println contenuta all’interno del pacchetto fmt e la invoca usando un argomento – la stringa Hello World.

La funzione Println fa il vero lavoro in questo programma. Puoi saperne di più digitando quanto segue nel tuo terminale:

godoc fmt Println

Tra le altre cose dovresti vedere questo:

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

Go è un linguaggio di programmazione molto ben documentato ma questa documentazione può essere difficile da capire a meno che tu non abbia già familiarità con i linguaggi di programmazione. Tuttavia il comando godoc è estremamente utile ed è un buon punto di partenza ogni volta che hai una domanda.

Tornando alla funzione in questione, questa documentazione ti sta dicendo che la funzione Println invierà qualsiasi cosa tu le dia allo standard output – un nome per l’output del terminale in cui stai lavorando. Questa funzione è ciò che causa la visualizzazione di Hello World.

Nel prossimo capitolo esploreremo come Go memorizza e rappresenta cose come Hello World imparando i tipi.

Problemi

  • Cos’è lo spazio bianco?

  • Cos’è un commento? Quali sono i due modi di scrivere un commento?

  • Il nostro programma inizia con package main. Con cosa inizierebbero i file del pacchetto fmt?

  • Abbiamo usato la funzione Println definita nel pacchetto fmt. Se volessimo usare la funzione Exit del pacchetto os cosa dovremmo fare?

  • Modificare il programma che abbiamo scritto in modo che invece di stampare Hello World stampi Hello, my name is seguito dal tuo nome.

← Precedente Index

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.