Ciao Mondo

Hello-world

Preparazione Manuale del Progetto

Ogni applicativo Go è sviluppato al di sotto di una directory di progetto - anche chiamata directory di contesto.

  • Contiene il package main, che ha la funzione main(), punto di ingresso dell’applicativo
    • Deve esserci una e una sola funzione main()
  • Contiene eventuali sottodirectories per i package sviluppati nell’applicativo
    • Ogni directory di package ha il nome del package

In Windows generare la directory: C:\Users\USER\go\src\ex\010hello

  • Andare in quella directory
  • Editare il file main.go
    • C’è un solo file del package main in questo semplice applicativo
    • Non vi sono altri packages

Preparazione con Visual Studio Code

Creare la cartella ex:

  • In tale cartella creare la cartella 010hello
  • In tale cartella creare il file 010hello.go

Compare una pagina di descrizione dell’estensione di supporto al Go.

Compare inoltre un pop-up in basso a destra, che suggerisce l’installazione di un tool di supporto:

  • Selezionare Install All
  • Sono tutte le utilities Go a cui VSC accede per gestire il codice, p.es. la riformattazione automatica
  • Installare tutte le utilities subito risparmia tempo in seguito
  • Impiega un po’ di tempo

Programma

Questo è il classico 'Hello World' in go:

(010hello.go):

// Tutti i file di codice iniziano con la
// dichiarazine package - una sola
// Un package è uno spazio nomi
package main

// Sono importati i moduli che definiscono 
// i simboli usati nel file
// E' un errore importare un modulo e non usarlo
import "fmt"

// Ogni eseguibile ha una e una sola funzione main
// Definisce il punto d'ingresso del programma
func main() {
	// La funzione Println è nel modulo fmt
	// Con iniziale maiuscola - simboli public
	// minuscola - private al file che li definisce
	fmt.Println("hello world")
}

L'esecuzione comincia dalla funzione main().

La dichiarazione package dichiara un namespace. Un file sorgente può dichiarare un solo package. Tutti i file Go devono dichiarare un package. La funzione main deve essere nel package main, e ve ne può essere solo una nell'intero package.

Il namespace si può estendere ad altri file che dichiarano lo stesso package.
Il compilatore nel risolvere i riferimenti cerca in tutti i file dichiaranti lo stesso package, nella stessa directory di progetto.

Il package main serve per il programma principale, che viene compilato e linkato come eseguibile standalone. Altri package vengono compilati separatamente e installati al di sotto della directory $GOPATH/pkg. Altri programmi possono poi includere i packages così preparati.

Le funzioni sono globali, cioè visibili in tutto il package.

Compilazione ed Esecuzione

Linea di Comando Linux

Posizionarsi nella directory contenente il programma:

Compilare e lanciare insieme:

go run 010hello.go

Solo compilare:

go build -o hello 010hello.go
  • L’opzione -o specifica il nome dell’eseguibile
  • Altrimenti prende il nome dalla directory

Eseguire:

./hello

VSC in Windows

Run diretto da VSC:

  • Click destro nella finestra del codice: Run Code
  • Si apre la finestra di output col run del nostro codice

Alternativa:

  • Aprire la finestra di terminale View -> Terminal
  • Cambiare directory: cd ex\010hello
  • Compilare e lanciare insieme:
go run 010hello.go
  • Solo compilare:
go build -o hello.exe 010hello.go

  • L’opzione -o specifica il nome dell’eseguibile, deve avere estensione .exe

  • Altrimenti prende il nome dalla directory

  • Eseguire:

hello

Il file non è sorgente, nè codice intermedio, ma eseguibile nativo Unix ELF. Go è un compilatore, non un interprete.

Il file di default è linkato staticamente, quindi direttamente eseguibile su altri computer della stessa architettura e sistema operativo.

Fluscomp

Osservazioni

Organizzazione dei sorgenti

Un programma complesso è solitamente composto da molti file sorgente.

E' opportuno creare una sottodirectory di src che contenga tutti e soli i file del programma in sviluppo.

Terminazione di istruzioni

Le istruzioni NON sono terminate da un punto e virgola ma da un newline (RETURN).

Go inserisce silenziosamente e invisibilmente un punto e virgola al termine di ogni istruzione prima della compilazione del file.

Posizione delle graffe

Seguono lo standard del linguaggio C in versione di Kernighan e Ritchie. Non sono previste alternative, come per esempio in C++.

Il seguente esempio è errato:

func main() 
{
    fmt.Println("hello world")
}

Il seguente esempio è corretto:

func main(){
    fmt.Println("hello world")
}

Per assicurarsi della stesura corretta del file sorgente, incluso le graffe, c'è l'utility gofmt, fornita nel pacchetto Go, da usarsi come:

gofmt file.go

Commenti

Sono accettabili i due tipi di commenti del linguaggio C++:

  • inizio con /* e termine con */ su un qualsiasi numero di linee
  • inizio con // e termine a fine linea

I commenti stile /* ... */ non sono innestabili

I commenti sono molto importanti in alcune posizioni chiave, perchè sono sentiti dall'ambiente di produzione di documentazione godoc:

  • all'inizio del programma, appena prima della dichiarazione package
  • in un programma di package, non main, prima delle funzioni o simboli esportati

Parole Chiave

Non si possono usare come identificativi, come in qualsiasi linguaggio.

chiave

Operatori e Delimitatori

Simboli con significato già assegnato, non possono essere parte di identificatori.

opdel