Pacchetto locale di import di golang

In GO, un pacchetto si riferisce a una raccolta di file di codice sorgente GO nella stessa directory che vengono compilati insieme. In genere, utilizzerai questi pacchetti per esportare e importare il codice tra loro. Questo a sua volta rende il codice modulare e facile da mantenere.

Tuttavia, se stai solo entrando nel linguaggio di programmazione Go, può essere piuttosto difficile capire come importare il pacchetto locale. Questo è questo tutorial.

Pacchetto golang

Per capire meglio cosa è un pacchetto Go, facciamo un progetto chiamato My Workspace. All'interno della directory dell'area di lavoro, hai altre 3 directory chiamate DIR1, DIR2 e DIR3.

Quindi, l'albero della directory è come mostrato:

└──−worworkspace
├──−Dir1
├──−Dir2
└──−Dir3

Ciò significa che il progetto dell'area di lavoro ha 3 pacchetti. Ogni file creato sotto ogni directory diventa parte di quel pacchetto (directory).

Tieni presente che il progetto principale è ciò che è noto come il pacchetto principale. Nella maggior parte dei casi, troverai file come Main.Vai con la prima riga di codice come "

Pacchetto principale

Tornando al progetto dell'area di lavoro, farai la prima voce in ciascuno dei file con il nome del pacchetto in base al quale appartengono.

Un esempio è come:

pacchetto dir1 // per i file in dir1
pacchetto dir2 // per i file in dir2
PACCHETTO DIR3 // per DIR3

Ogni file all'interno di un pacchetto può esportare il suo codice. Altri file all'interno del progetto possono quindi fare riferimento a quel pacchetto (directory) e importare il codice dai file. Ciò consente di importare semplicemente un singolo pacchetto e tutto il codice nei file in quel pacchetto sarà accessibile per l'uso.

Per creare un nuovo pacchetto nel tuo progetto, puoi semplicemente creare una nuova directory.

Vediamo un esempio pratico per la creazione di pacchetti Go.

Golang Initialize Module

Il primo passo quando i pacchetti di importazione è inizializzare un nuovo modulo. Puoi farlo eseguendo il comando:

Go Mod init

Ad esempio, nella directory dell'area di lavoro, possiamo creare un nuovo modulo come:

Go Mod init Workspace

Una volta eseguito il go mod init, crea un go.file mod che tiene traccia dei moduli import. Il file contiene anche informazioni come il nome del modulo, la versione GO, ecc.

Pensalo come il pacchetto.file json in nodo.

Tieniti alla denominazione dei moduli in quanto lo richiederai quando importi i pacchetti. Un esempio di Go.Il file mod è come mostrato:

Apazio di lavoro del modulo
Vai 1.17

Dal momento che non abbiamo pacchetti esterni, il file contiene il nome del modulo e la versione GO.

Golang crea un pacchetto

Come accennato, per creare un pacchetto nel progetto GO, crea una nuova directory e aggiungi i file del codice sorgente in quel pacchetto.

Ad esempio, creiamo i file di origine GO per i pacchetti DIR1, DIR2 e DIR3.

$ touch dir1/dir1.andare
$ touch dir2/dir12.andare
$ touch dir3/dir3.andare

Nella prima riga di ogni file, includi lo spazio dei nomi dei pacchetti come:

PACCHETTO DIR1 // Sostituisci DiR2 con il nome del pacchetto

Successivamente, aggiungiamo un po 'di codice in ciascuno di questi file.

// dir1.andare
pacchetto dir1
funcsayHello () string
restituire "ciao dal pacchetto dir1"

// dir2.andare
pacchetto dir2
funcsayrunning () string
restituire "Sto correndo dal pacchetto dir2"

// dir3.andare
pacchetto dir3
funcsaybye () string
restituire "addio dal pacchetto dir3"

Gli esempi di cui sopra sono semplici. Sono solo funzioni che restituiscono un valore di stringa da ciascun pacchetto.

Nota: per esportare una variabile o una funzione da un pacchetto GO, assicurarsi di avviare il nome della funzione o della variabile con una lettera maiuscola.

Ancora: ☝️☝️☝️☝️☝️

GOlang Importa pacchetti locali

L'ultimo passo è importare i pacchetti locali in modo da poter utilizzare il codice in ciascuno di essi. Nella radice del tuo progetto, alias, la directory dell'area di lavoro, crea un principale.Vai file.

Quindi, aggiungi le seguenti righe per importare i pacchetti locali:

Pacchetto principale
importazione (
"FMT"
"Workspace/Dir1"
"Workspace/DIR2"
"Workspace/DIR3"
)
funcmain ()
fmt.Println (dir1.Di Ciao())
fmt.Println (dir2.Sayrunning ())
fmt.Println (dir3.Dire ciao())

Nell'esempio sopra, aggiungiamo 3 clausole di importazione per importare tutti i pacchetti nel nostro programma.

Una volta importato, possiamo utilizzare il codice esportato nei pacchetti.

Possiamo quindi eseguire il codice in main.Vai file come:

$ go run main.andare
Ciao dal pacchetto dir1
Sto correndo dal pacchetto dir2
Arrivederci dal pacchetto dir3

Vedrai l'output esportato dalle funzioni dai pacchetti.

Conclusione

In questo articolo, abbiamo discusso di come puoi esportare e importare il codice utilizzando i pacchetti GO. I pacchetti sono un modo molto pratico e pulito per organizzare il codice e mantenere la leggibilità e la manutenzione. Speriamo che ti sia piaciuto!