Funzioni e import

Go ha una estesissima libreria di funzioni nel core library, ed è possibile installare altre librerie.

La libreria di default è composta di packages e ogni package contiene svariate funzioni dello stesso tema.

Per poter usare una funzione occorre importare il package che la contiene, con l'istruzione, p.es.:

import "fmt"

Nel nostro caso fmt è un modulo, che possiede molte funzioni di formattazione.
La funzione Println() è una di esse, e stampa il suo argomento stringa a standard output seguito da un newline.

Tutte le funzioni di un package devono essere invocate col nome del package che le contiene, come prefisso separato da un punto. Si deve usare fmt.Println(), non solo Println().

I packages sono una struttura gerarchica, che usa / come separatore di sottopackage. Per esempio:

import "net/http"

Importare un package non importa i sottopackages (come in Java).

Nell'invocazione delle funzioni il prefisso è solo l'ultimo sottopackage: http.Get()e non net.http.Get().

I packages possono essere non di libreria standard, p.es.

import "stormforce.ac/cryptoutils"

Il compilatore dapprima ricerca tale package nella directory di libreria standard, $GOROOT/pkg, poi cerca il file (nel nostro esempio): $GOPATH/pkg/linux_amd64/stormforce.ac/cryptoutils.a

Si può dare un alias al nome del package, come in:

import cr "stormforce.ac/cryptoutils"

ed usare cr.Encrypt() anzichè cryptoutils.Encrypt(). Una volta definito un alias occorre usare quello, e non più il nome del package.

I packages sono tipicamente archivi statici, e le loro funzioni sono linkate staticamente all'interno del file eseguibile che le importa.

Non esiste nessuna direttiva tipo export, ma una convenzione obbligatoria:

Tutte le funzioni o variabili il cui nome inizia con una maiuscola sono pubbliche, e note nei programmi che importano il package. Se iniziano con la minuscola sono private, visibili solo nel package che le contiene.

I nomi esportati, essendo globali devono essere univoci nel package.

Le dichiarazioni di import devono essere all'inizio del file, subito dopo la dichiarazione di package. Non possono essere mescolate al codice.

Se si intende pubblicare un proprio package su Internet occorre inventarsi un nome univoco a livello mondiale. Un metodo è di usare il nome di un dominio che ci appartiene. Un altro metodo è di porlo su un sito di registry ben noto, con lo username come identificativo.

I packages si devono scaricare e installare sul computer corrente prima di poterli importare. Questo viene ottenuto col comando go get package.

Si possono installare direttamente un package da repository in Git, come per esempio:

go get github.com/pippo/pack

Che corrisponde alle operazioni:

cd $GOPATH/src
git clone https://github.com/pippo.pack.git
cd pack
git install

Importazione di più packages

Se si devono importare più package, lo si può fare in due modi. Si può avere una dichiarazione di import per ciascun modulo, p.es.:

import "fmt"
import "mypack"

oppure con un'unica dichiarazione di import:

import (
    "fmt"
    "mypack"
)

La posizione delle tonde è importante e non può essere diversa da quella indicata.
Ogni modulo importato è su una linea separata.

Si può anche scrivere:

import ( "fmt"; "mypack" )

ove il punto e virgola è un separatore. Questa sintassi è deprecata in favore delle due precedenti.

E' naturalmente errore usare una variabile o funzione di un package senza aver importato tale package.
Ma è altrettanto errore importare un package e non usarlo.

Documentazione

La documentaziione completa di riferimento di tutti i package della core library e di altre librerie usate spesso dalla Community di sviluppatori è disponibile omline alla URL https://golang.org/pkg/.

E' in formato Godoc.