Paket Go terdiri dari file Go yang terletak di direktori yang sama, di mana ada ekspresi
package sama. Paket yang terhubung ke program memungkinkan Anda untuk memperluas kemampuan mereka. Beberapa paket adalah bagian dari perpustakaan Go standar. Ini berarti bahwa jika Anda menggunakan Go, mereka sudah diinstal. Paket-paket lain diinstal menggunakan perintah
go get . Anda juga dapat menulis Go-paket Anda sendiri, membuat file di direktori khusus, dan mematuhi aturan desain paket.
Bahan, terjemahan yang kami terbitkan hari ini, adalah panduan untuk pengembangan paket-Go yang dapat dihubungkan ke file lain.
Prasyarat
- Siapkan lingkungan perangkat lunak Go Anda (pelajari cara melakukannya di sini ). Buat ruang kerja Go (titik kelima dari materi di atas didedikasikan untuk ini). Di bagian selanjutnya dari bahan ini Anda dapat menemukan contoh yang direkomendasikan untuk direproduksi di rumah. Jadi Anda bisa lebih baik menghadapinya.
- Untuk memperdalam pengetahuan Anda tentang
GOPATH - lihat materi ini .
Paket penulisan dan impor
Menulis kode paket sama dengan menulis kode Go biasa. Paket dapat berisi deklarasi fungsi, tipe dan variabel, yang kemudian dapat digunakan dalam program-Go lainnya.
Sebelum kita dapat mulai membuat paket baru, kita harus pergi ke ruang kerja Go. Itu terletak di jalan yang ditentukan oleh variabel
GOPATH . Misalnya, biarkan organisasi kami disebut
gopherguides . Pada saat yang sama, kami, sebagai repositori, menggunakan
GitHub . Ini mengarah pada fakta bahwa, di sepanjang jalur yang ditentukan oleh
GOPATH , kami memiliki struktur folder berikut:
└── $GOPATH └── src └── github.com └── gopherguides
Kami akan menyebutkan paket yang akan kami kembangkan dalam panduan ini,
greet . Untuk melakukan ini, buat direktori
gopherguides direktori
gopherguides . Akibatnya, struktur folder yang ada akan mengambil bentuk berikut:
└── $GOPATH └── src └── github.com └── gopherguides └── greet
Sekarang kita siap untuk menambahkan file pertama ke direktori
greet . Biasanya, file yang merupakan titik masuk paket disebut sama dengan direktori paket. Dalam hal ini, ini berarti bahwa kita, dalam direktori
greet , membuat file
greet.go :
└── $GOPATH └── src └── github.com └── gopherguides └── greet └── greet.go
Dalam file ini kita dapat menulis kode yang ingin kita gunakan kembali dalam proyek kita. Dalam hal ini, kami akan membuat fungsi
Hello , yang menampilkan teks
Hello, World! .
Buka file
greet.go dalam editor teks dan tambahkan kode berikut ke dalamnya:
package greet import "fmt" func Hello() { fmt.Println("Hello, World!") }
Mari kita menganalisis isi file ini. Baris pertama dari setiap file harus berisi nama paket tempat kami bekerja. Karena kita berada dalam
package greet , kata kunci
package digunakan di sini, diikuti dengan nama paket:
package greet
Ini memberitahu kompiler untuk menerima semua yang ada di file sebagai bagian dari paket
greet .
Selanjutnya, paket yang diperlukan diimpor menggunakan pernyataan
import . Dalam hal ini, kita hanya perlu satu paket -
fmt :
import "fmt"
Dan akhirnya, kami membuat fungsi
Hello . Dia akan menggunakan kemampuan paket
fmt untuk menampilkan string
Hello, World! :
func Hello() { fmt.Println("Hello, World!") }
Sekarang, setelah paket
greet dibuat, Anda dapat menggunakannya dalam paket lainnya. Mari kita buat paket baru di mana kita akan menggunakan paket
greet .
Yaitu, kami akan membuat paket
example . Untuk melakukan ini, kami akan melanjutkan dari asumsi yang sama dari mana kami melanjutkan, membuat paket
greet . Pertama, buat folder
example di folder
gopherguides :
└── $GOPATH └── src └── github.com └── gopherguides └── example
Sekarang buat file yang merupakan titik masuk paket. Kami menganggap paket ini sebagai program yang dapat dieksekusi, dan bukan sebagai paket yang kodenya direncanakan untuk digunakan dalam paket lain. File yang merupakan titik input dari program biasanya disebut
main.go :
└── $GOPATH └── src └── github.com └── gopherguides └── example └── main.go
Buka file
main.go di editor dan
main.go kode berikut ke dalamnya, yang memungkinkan Anda untuk menggunakan kemampuan paket
greet :
package main import "github.com/gopherguides/greet" func main() { greet.Hello() }
Kami mengimpor paket
greet dalam file
main.go , yang berarti bahwa untuk memanggil fungsi yang dinyatakan dalam paket ini, kita perlu menggunakan notasi titik. Notasi titik adalah konstruksi di mana titik diletakkan di antara nama paket dan nama sumber daya dari paket ini untuk digunakan. Misalnya, dalam paket
greet , fungsi
Hello memainkan peran sebagai sumber daya. Jika Anda perlu memanggil fungsi ini, notasi titik digunakan
: greet.Hello() .
Sekarang Anda dapat membuka terminal dan menjalankan program:
go run main.go
Setelah Anda melakukan ini, terminal akan menampilkan yang berikut:
Hello, World!
Sekarang mari kita bicara tentang cara menggunakan variabel yang dideklarasikan dalam paket. Untuk melakukan ini, tambahkan deklarasi variabel ke file
greet.go :
package greet import "fmt" var Shark = "Sammy" func Hello() { fmt.Println("Hello, World!") }
Buka file
main.go dan tambahkan baris di sana di mana fungsi
fmt.Println() digunakan untuk menampilkan nilai variabel
Shark dinyatakan dalam paket
greet.go . Yaitu, bawa
main.go ke formulir berikut:
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) }
Jalankan kembali program:
go run main.go
Sekarang dia akan menampilkan yang berikut:
Hello, World! Sammy
Sekarang mari kita bicara tentang cara mendeklarasikan tipe dalam paket. Buat jenis
Octopus dengan bidang
Name dan
Color , dan buat metode jenis. Metode ini, ketika dipanggil, akan mengembalikan konten yang diproses secara khusus dari bidang
Octopus . Ayo
greet.go ke form berikut:
package greet import "fmt" var Shark = "Sammy" type Octopus struct { Name string Color string } func (o Octopus) String() string { return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func Hello() { fmt.Println("Hello, World!") }
Sekarang buka
main.go , buat sebuah instance dari struktur tipe baru di dalamnya dan lihat metode
String() :
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) oct := greet.Octopus{ Name: "Jesse", Color: "orange", } fmt.Println(oct.String()) }
Setelah Anda membuat instance
Octopus menggunakan konstruk yang terlihat seperti
oct := greet.Octopus , Anda dapat mengakses metode dan properti jenis dari
main.go file
main.go Ini, khususnya, memungkinkan Anda untuk menggunakan perintah
oct.String() terletak di akhir file
main.go tanpa harus
greet . Selain itu, kita dapat, misalnya, merujuk ke bidang struktur
Color menggunakan konstruksi
oct.Color . Pada saat yang sama, kami, seperti ketika kami memanggil metode, tidak mengakses
greet .
Metode
String dari tipe
Octopus menggunakan fungsi
fmt.Sprintf untuk membentuk kalimat dan kembali, menggunakan
return , hasil, string, ke pemanggilan metode (dalam hal ini, tempat ini di
main.go ).
Jalankan kembali program:
go run main.go
Ini akan menampilkan yang berikut ke konsol:
Hello, World! Sammy The octopus's name is "Jesse" and is the color orange.
Sekarang kita telah melengkapi Octopus dengan metode
String , kita punya mekanisme keluaran informasi tipe yang cocok untuk digunakan kembali. Jika di masa depan Anda perlu mengubah perilaku metode ini, yang dapat digunakan di banyak proyek, itu akan cukup untuk mengedit kode di
greet.go .
Ekspor Entitas
Anda mungkin telah memperhatikan bahwa semua yang kami kerjakan saat merujuk pada paket
greet memiliki nama yang dimulai dengan huruf kapital. Go tidak memiliki pengubah akses seperti
public ,
private atau
protected , yang dalam bahasa lain. Visibilitas entitas untuk mekanisme eksternal dikendalikan oleh fakta dengan huruf mana, dengan kecil atau besar, nama mereka dimulai. Akibatnya, jenis, variabel, fungsi yang namanya dimulai dengan huruf kapital tersedia di luar paket saat ini. Kode yang terlihat di luar paket disebut diekspor.
Jika Anda melengkapi jenis
Octopus dengan metode baru yang disebut
reset , maka metode ini dapat dipanggil dari paket
greet , tetapi bukan dari file
main.go , yang berada di luar paket
greet . Ini adalah versi terbaru dari
greet.go :
package greet import "fmt" var Shark = "Sammy" type Octopus struct { Name string Color string } func (o Octopus) String() string { return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) reset() { o.Name = "" o.Color = "" } func Hello() { fmt.Println("Hello, World!") }
Mari kita coba panggil
reset dari file
main.go :
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) oct := greet.Octopus{ Name: "Jesse", Color: "orange", } fmt.Println(oct.String()) oct.reset() }
Ini akan menghasilkan kesalahan kompilasi berikut:
oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset)
Untuk mengekspor metode
reset tipe
Octopus , Anda harus mengganti namanya, mengganti huruf pertama, huruf kecil
r , dengan huruf kapital
R Kami melakukan ini dengan mengedit
greet.go :
package greet import "fmt" var Shark = "Sammy" type Octopus struct { Name string Color string } func (o Octopus) String() string { return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) Reset() { o.Name = "" o.Color = "" } func Hello() { fmt.Println("Hello, World!") }
Ini akan mengarah pada fakta bahwa kita akan dapat memanggil
Reset dari paket lain dan tanpa menemukan pesan kesalahan:
package main import ( "fmt" "github.com/gopherguides/greet" ) func main() { greet.Hello() fmt.Println(greet.Shark) oct := greet.Octopus{ Name: "Jesse", Color: "orange", } fmt.Println(oct.String()) oct.Reset() fmt.Println(oct.String()) }
Jalankan program:
go run main.go
Inilah yang sampai ke konsol:
Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color .
Dengan memanggil metode
Reset , kami membersihkan bidang
Name dan
Color dari contoh
Octopus kami. Akibatnya, ketika memanggil
String , di mana isi bidang
Name dan
Color sebelumnya ditampilkan, sekarang tidak ada yang ditampilkan.
Ringkasan
Paket Writing Go tidak berbeda dengan menulis kode Go biasa. Namun, menempatkan kode paket di direktori mereka sendiri memungkinkan mengisolasi kode, yang dapat digunakan dalam proyek-proyek Go lainnya. Di sini kita berbicara tentang cara mendeklarasikan fungsi, variabel, dan tipe dalam paket, memeriksa cara menggunakan entitas ini di luar paket, dan menemukan di mana harus menyimpan paket yang dirancang untuk penggunaan berulang mereka.
Pembaca yang budiman! Program apa yang biasanya Anda tulis di Go? Apakah Anda menggunakan paket eksklusif di dalamnya?
