Gestione Package

Creazione di un Package

Decisioni:

• il repository di appoggio sarà masha.kan
• L'autore sarà mich
• Il package (artefatto) sarà customer

Preparazione delle directory:

cd $GOPATH/src
mkdir -p masha.kan/mich/customer

Redazione del programma per il package:

cd masha.kan/mich/customer
vi customer.go

(customer.go):

package customer

import "fmt"

// Tutte le struct e i loro metodi sono in questo package
// I nomi con iniziale maiuscola sono esportati
type Address struct {
    Street, City, State, Zip string
    IsShippingAddress        bool
}
type Customer struct {
    FirstName, LastName, Email, Phone string
    Addresses                         []Address
}

func (c Customer) ToString() string {
    return fmt.Sprintf("Customer: %s %s, Email:%s",
        c.FirstName, c.LastName, c.Email)
}
func (c Customer) ShippingAddress() string {
    for _, v := range c.Addresses {
        if v.IsShippingAddress == true {
            return fmt.Sprintf("%s, %s, %s, Zip -%s",
                v.Street, v.City, v.State, v.Zip) 
        }
    }
    return ""
}
func Getcustomer() Customer {
    // In realtà sarebbe ottenuto da un DB
    c := Customer{
        FirstName: "Alex",
        LastName:  "John",
        Email:     "alex@email.com",
        Phone:     "732-757-2923",
        Addresses: []Address{
            Address{
                Street:            "1 Mission Street",
                City:              "San Francisco",
                State:             "CA",
                Zip:               "94105",
                IsShippingAddress: true,
            },
            Address{
                Street: "49 Stevenson Street",
                City:   "San Francisco",
                State:  "CA",
                Zip:    "94105",
            },
        },
    }
    return c
}

L'albero al di sotto del workspace è al momento:

.
├── bin
└── src
    └── masha.kan
        └── mich
            └── customer
                └── customer.go

Andare nella directory customer.

Installare il package:

go install

L'albero al di sotto del workspace è diventato:

.
├── bin
├── pkg
│   └── linux_amd64
│       └── masha.kan
│           └── mich
│               └── customer.a
└── src
    └── masha.kan
        └── mich
            └── customer
                └── customer.go

Notare che pkg è stato creato perchè ancora non esisteva, e che al di sotto ha una directory che specifica l'architettura.

Essendo i package delle librerie statiche, composte di moduli oggetto, sono dipendenti dall'architettura per cui sono state prodotte.

E' possibile in Go la cross-compilazione, ovvero la produzione di oggetti ed eseguibili destinati ad architetture diverse da quella della piattaforma di sviluppo.

Creazione di un programma che usa il package

Decisioni:

• Sarà nella directory sorgente masha.kan/mich/cust e questo saraà anche automaticamente il nome dell'eseguibile
• Il file sorgente si chiamerà listcust.go

Notare che il fatto che un eseguibile o un package si chiami come la directory che lo contiene, ci permette di suddividerlo
in molti file con nomi diversi, e il build saprà come fare.
Naturalmente tutti i file devono appartenere allo stesso package, qui main, e nel nostro caso ci deve essere una sola func main().

Quindi creare la directory, andarvi dentro ed editare il programma:

cd $GOPATH
mkdir -p src/masha.kan/mich/cust 
cd src/masha.kan/mich/cust
vi listcust.go

(listcust.go):

package main

import "fmt"

// cus è un alias a customer
import cus "masha.kan/mich/customer"

func main() {
        c := cus.Getcustomer()
        fmt.Println(c.ToString())
        fmt.Println(c.ShippingAddress())
}

Provarlo con:

go run listcust.go

Compilarlo a eseguibile locale:

go build

Provarlo da eseguibile:

./cust

Per installarlo:

go install

L'albero sotto il workspace è diventato:

.
├── bin
│   └── cust
├── pkg
│   └── linux_amd64
│       └── masha.kan
│           └── mich
│               └── customer.a
└── src
    └── masha.kan
        └── mich
            ├── cust
            │   └── listcust.go
            └── customer
                └── customer.go

Ora possiamo eseguirlo da ovunque nel filestore semplicemente col comando cust non qualificato.