Perintah go

Penggunaan:

Perintah bug membuka peramban dan menjalankan laporan bug yang baru. Laporan tersebut mengikutkan informasi sistem.

Penggunaan:

Perintah build kompilasi paket-paket berdasarkan nama dari path import, bersama dengan dependensinya, namun tidak memasang hasilnya.

Jika argumennya adalah daftar berkas .go dari sebuah direktori, maka build menganggapnya sebagai daftar berkas sumber dari paket yang sama.

Saat mengompilasi paket, build mengindahkan berkas yang berakhiran _test.go.

Saat mengompilasi paket main, build menulis hasil program ke sebuah berkas yang namanya diambil dari berkas sumber pertama (go build ed.go rx.go menulis ed atau ed.exe) atau direktori sumber kode (go build unix/sam menulis sam atau sam.exe). Akhiran '.exe’ ditambahkan bila menulis program untuk Windows.

Saat mengompilasi beberapa paket atau paket yang bukan main, build mengompilasi paket-paket tersebut namun mengindahkan objek hasilnya, cara ini untuk memeriksa bahwa paket dapat dibangun.

Opsi "-o" memaksa build untuk menulis hasil program atau objek dengan nama atau direktori yang diberikan, bukan dengan perilaku seperti yang dijelaskan pada dua paragraf sebelumnya. Jika nama keluaran adalah direktori yang sudah ada, maka hasil program akan ditulis di dalam direktori tersebut.

Opsi "-i" memasang paket-paket dependensi dari target.

Opsi-opsi dari build berikut dapat digunakan pada perintah clean, get, install, list, run, dan test:

Opsi -asmflags, -gccgoflags, -gcflags, dan -ldflags menerima daftar argumen yang dipisahkan oleh spasi untuk dikirim ke perkakas yang dijalankan dibelakangnya selama pembangunan. Untuk menambah spasi dalam elemen dalam daftar tersebut, kurung dengan tanda kutip tunggal atau ganda. Daftar argumen bisa diawali dengan sebuah pola paket dan tanda sama dengan ("="), yang membatasi penggunaan dari daftar argumen tersebut ke pembangunan paket-paket yang cocok dengan pola (lihat 'go help packages’ untuk deskripsi dari pola paket). Tanpa pola, daftar argumen hanya berlaku untuk paket yang diberikan pada perintah baris. Opsi-opsi tersebut bisa berulang dengan pola yang berbeda dengan tujuan untuk menentukan argumen yang berbeda untuk sekumpulan paket. Jika sebuah pola pencocokan paket diberikan dalam beberapa opsi, kecocokan yang terakhir akan digunakan. Sebagai contohnya, 'go build -gcflags=-S fmt’ mencetak disassembly hanya untuk paket fmt, sementara 'go build -gcflags=all=-S fmt’ mencetak disassembly untuk fmt dan semua dependensinya.

Untuk lebih tahu tentang cara menspesifikasikan paket, lihat 'go help packages’. Untuk mengetahui lebih lanjut tentang di mana paket dan program dipasang, jalankan 'go help gopath’. Untuk mengetahui lebih lanjut tentang pemanggilan antara Go dan C/C++, jalankan 'go help c’.

Catatan: Perintah build mengikuti beberapa konvensi seperti yang dijelaskan oleh 'go help gopath’. Tidak semua proyek dapat mengikuti konvensi tersebut. Pemasangan yang memiliki konvensinya sendiri atau yang menggunakan sistem pembangunan perangkat lunak yang terpisah bisa memilih untuk menggunakan pemanggilan tingkat-rendah seperti 'go tool compile’ dan 'go tool link’ untuk menghindari beberapa beban dan rancangan dari perkakas build.

Lihat juga: go install, go get, go clean.

Penggunaan:

Perintah clean menghapus berkas objek dari direktori sumber paket. Perintah go menulis objek dalam sebuah direktori sementara, sehingga 'go clean’ biasanya berguna untuk berkas objek sisa dari perkakas lain atau dari pemanggilan manual dari go build.

Jika argumen sebuah paket diberikan atau opsi -i atau -r di set, clean menghapus berkas-berkas berikut dari setiap direktori sumber yang berkorespondensi dengan path impor:

Dalam daftar tersebut, DIR merepresentasikan elemen path terakhir dari direktori, dan MAINFILE adalah nama dasar dari sumber kode Go dalam direktori tersebut yang tidak diikutkan saat membangun paket.

Opsi -i membuat perintah clean untuk menghapus arsip dan binary yang terpasang (yang dibuat oleh 'go install’).

Opsi -n membuat perintah clean untuk mencetak perintah penghapusan yang akan dieksekusi, namun tidak menjalankannya.

Opsi -r membuat perintah clean menerapkan secara rekursif ke semua dependensi dari paket dari path impor.

Opsi -x membuat perintah clean mencetak perintah penghapus saat ia dieksekusi.

Opsi -cache membuat clean menghapus semua cache dari go build.

Opsi -testcache menyuruh supaya clean untuk kedaluwarsa semua hasil tes dalam cache go build.

Opsi -modcache menyebabkan clean menghapus semua cache unduhan modul termasuk sumber kode dari dependensi yang memiliki versi.

Untuk lebih lanjut tentang opsi build, lihat 'go help build’.

Untuk lebih lanjut tentang menentukan paket, lihat 'go help packages’.

Penggunaan:

Perintah doc mencetak komentar dokumentasi yang berasosiasi dengan item yang diidentifikasi lewat argumen-argumen (sebuah paket, const, func, type, var, method, atau field dari struct) diikuti dengan sebuah ringkasan satu-baris dari setiap item tingkat-pertama "di bawah" item tersebut (deklarasi tingkat-paket untuk sebuah paket, method untuk sebuah tipe, dan seterusnya.).

Perintah doc menerima argumen kosong, satu, atau dua.

Bila argumen tidak ada, yaitu, bila dijalankan seperti

ia akan mencetak dokumentasi paket dalam direktori yang sekarang. Jika paket adalah sebuah program (package main), simbol-simbol yang diekspor oleh paket tidak ditampilkan kecuali bila opsi -cmd diberikan.

Bila dijalankan dengan satu argumen, maka argumen tersebut dianggap sebagai representasi mirip sintaksis Go dari item yang didokumentasikan. Apa yang argumen pilih bergantung pada apa yang dipasang dalam GOROOT dan GOPATH, sebagaimana juga bentuk dari argumen, yang secara semantik adalah satu dari hal berikut:

Item pertama dalam daftar di atas yang sesuai dengan argumen akan dicetak dokumentasinya. (Lihat contoh di bawah). Namun jika argumen dimulai dengan huruf besar maka diasumsikan sebagai simbol atau method dari direktori yang sekarang.

Untuk paket, urutan pencarian ditentukan secara leksikal dengan cara breadth-first order. Yaitu, paket yang ditampilkan adalah yang cocok dengan pencarian dan terdekat dengan root dan yang pertama secara leksikal di tingkat hirarkinya. Pohon GOROOT selalu dicari pertama kali sebelum GOPATH.

Jika tidak ada paket yang diberikan atau cocok, maka paket di direktori sekarang yang dipilih, sehingga "go doc Foo" memperlihatkan dokumentasi untuk simbol Foo dalam paket yang sekarang.

Path dari paket bisa secara penuh atau cukup sufiks dari path saja. Mekanisme umum dari go tool tidak berlaku: elemen path paket seperti . dan …​ tidak diimplementasikan oleh go doc.

Bila dijalankan dengan dua argumen, yang pertama haruslah path penuh dari paket (tidak hanya sufiks saja), dan yang kedua adalah simbol, atau simbol dengan method atau field struct. Hal ini sama dengan sintaksis yang diterima oleh godoc:

Dalam semua bentuk, saat mencocokan simbol, huruf kecil dalam argumen menyesuaikan dengan huruf kecil atau besar namun huruf besar dicocokan persis. Hal ini berarti akan ada beberapa kecocokan dari argumen dengan huruf kecil dalam sebuah paket jika simbol yang berbeda memiliki huruf yang berbeda. Jika hal ini terjadi, dokumentasi untuk semua kecocokan dicetak.

Contoh:

Opsi-opsi:

Penggunaan:

Perintah env mencetak informasi lingkungan Go.

Secara baku env mencetak informasi sebagai skrip shell (pada Windows, sebuah berkas batch). Jika satu atau lebih variabel diberikan sebagai argumen, env mencetak nilai dari setiap variabel per baris.

Opsi -json mencetak nilai variabel dalam format JSON.

Opsi -u membutuhkan satu atau lebih argumen dan akan menghapus pengaturan baku dari variabel lingkungan tersebut, jika sebelumnya telah diset dengan 'go env -w’.

Opsi -w membutuhkan satu atau lebih argumen dengan bentuk NAME=VALUE dan mengubah pengaturan baku dari variabel lingkungan yang diberikan sesuai dengan nilainya.

Untuk lebih lanjut tentang variabel lingkungan, lihat 'go help environment’.

Penggunaan:

Perintah fix menjalankan perintah perbaikan Go terhadap nama paket-paket yang diberikan lewat path impor.

Untuk lebih lanjut tentang fix, lihat 'go doc cmd/fix’. Untuk lebih lanjut tentang argumen paket, lihat 'go help packages’.

Untuk menjalankan fix dengan opsi-opsi tertentu, jalankan 'go tool fix’.

Lihat juga: go fmt, go vet.

Penggunaan:

Fmt menjalankan program 'gofmt -l -w’ pada paket-paket berdasarkan nama dari path import. Ia akan mencetak nama berkas yang diubah.

Untuk informasi lebih lanjut tentang gofmt, lihat 'go doc cmd/gofmt’. Untuk informasi tentang menentukan paket, lihat 'go help packages’.

Opsi -n mencetak perintah yang akan dieksekusi. Opsi -x mencetak perintah saat dieksekusi.

Opsi -mod menset mode unduhan yang akan digunakan: baca-saja atau vendor. Lihat 'go help modules’ untuk lebih lanjut.

Untuk menjalankan gofmt dengan opsi tertentu, jalankan gofmt itu sendiri.

Lihat juga: go fix, go vet.

Penggunaan:

Generate menjalankan perintah yang dijelaskan oleh petunjuk dalam berkas. Perintah tersebut dapat menjalankan proses apa saja namun tujuannya yaitu membuat atau memperbarui sumber berkas Go.

Go generate tidak pernah dijalankan secara otomatis oleh go build, go get, go test, and seterusnya. Ia harus dijalankan secara eksplisit.

Go generate memindai petunjuk dalam berkas, yang berupa baris dalam bentuk,

(catatan: tidak ada spasi awal dan spasi dalam "//go") yang mana "perintah" adalah generator yang akan dijalankan, yang berkorespondensi dengan nama berkas program yang dapat dijalankan di lokal. Program tersebut harus ada dalam PATH dari shell, path penuh (/usr/you/bin/mytool), atau sebuah alias dari perintah, yang dijelaskan di bawah.

Untuk memberitahu ke manusia atau mesin bahwa kode tersebut hasil generate, sumber hasil generate seharusnya memiliki baris yang sesuai dengan regular expression (dalam sintaksis Go):

Baris tersebut bisa muncul di mana pun dalam berkas Go, namun biasanya berada di awal supaya mudah dicari.

Ingat bahwa go generate tidak mem-parse berkas, sehingga baris-baris yang mirip dengan directive dalam komentar atau string akan dianggap sebagai directive.

Argumen dari directive adalah token yang dipisahkan oleh koma atau string dengan kutip ganda yang dikirim sebagai sebuah argumen saat ia dijalankan.

String dengan tanda kutip menggunakan sintaksis Go dan dievaluasi sebelum dieksekusi; String dengan tanda kutip dianggap sebagai sebuah argumen oleh generator.

Go generate men-set beberapa variabel saat ia berjalan:

Selain penggantian variabel dan evaluasi string berkutip, tidak ada lagi pemrosesan khusus yang dilakukan, seperti "globbing", dalam baris perintah.

Sebagai langkah terakhir sebelum menjalankan perintah, pemanggilan variabel lingkungan apa pun dengan nama alfa-numerik, seperti $GOFILE atau $HOME, akan diganti lewat baris perintah. Sintaksis dari penggatian variabel yaitu $NAME pada semua sistem operasi. Dikarenakan urutan evaluasi, variabel diganti bahkan di dalam string berkutip. Jika variabel NAME tidak diset, $NAME akan akan diganti dengan string kosong.

Sebuah directive dengan bentuk,

menspesifikasikan, untuk berkas itu saja, bahwa string xxx merepresentasikan perintah yang diidentifikasi oleh argumennya. Hal ini bisa digunakan untuk membuat alias atau menangani generator dengan banyak kata. Sebagai contohnya,

menentukan bahwa perintah "foo" merepresentasikan "go tool foo".

Perintah generate memproses paket-paket dengan urutan sesuai dengan yang diberikan pada baris perintah, satu per satu. Jika baris perintah berisi berkas .go dari sebuah direktori, mereka akan diperlakukan sebagai satu paket. Dalam sebuah paket, generate memproses sumber berkas dalam paket berurutan sesuai nama, satu per satu. Dalam sebuah berkas, generate menjalankan generator dengan urutan kemunculan dalam berkas, satu per satu. Perkakas "go generate" juga men-set tag build "generate" sehingga berkas-berkas bisa diperiksa oleh "go generate" namun diindahkan selama pembangunan.

Jika salah satu generator berhenti karena eror, "go generate" melewati semua pemrosesan selanjutnya untuk paket tersebut.

Si generator berjalan dalam sumber direktori paket.

Go generate menerima satu opsi khusus:

Go generate juga dapat menerima opsi "build" termasuk -v, -n, dan -x. Opsi -v mencetak nama-nama paket dan berkas saat proses berjalan. Opsi -n mencetak perintah yang akan dieksekusi. Opsi -x mencetak perintah saat dieksekusi.

Untuk lebih lanjut tentang opsi "build", lihat 'go help build’.

Untuk lebih lanjut tentang cara menspesifikasikan paket, lihat 'go help packages’.

Penggunaan:

Perintah "get" menambahkan dependensi ke modul pengembangan yang sekarang dan kemudian membangun dan memasangnya.

Langkah pertama yaitu menyelesaikan dependensi apa yang ditambahkan.

Untuk setiap paket atau pola paket, "get" harus memutuskan versi mana dari modul yang akan digunakan. Secara baku, "get" mencari tag dari versi rilis tag yang terakhir, seperti v0.4.5 atau v1.2.3. Jika versi rilis tidak memiliki tag, "get" mencari versi tag pra-rilis yang terakhir, seperti v0.0.1-pre1. Jika tidak ada versi tag sama sekali, "get" mencari commit terakhir. Jika modul belum dibutuhkan (misalnya, pra-rilis lebih baru dan rilis terakhir), "get" akan menggunakan versi yang dicarinya. Selain itu, "get" akan menggunakan versi yang sekarang dibutuhkan.

Pemilihan versi ini dapat ditimpa dengan menambahkan sufiks @version pada argumen paket, seperti 'go get golang.org/x/text@v0.3.0'. Versi tersebut bisa berupa prefiks: @v1 berarti versi terakhir yang tersedia mulai dari v1. Lihat 'go help modules’ pada 'Module queries’ untuk sintaks keseluruhan.

Untuk modul yang disimpan dalam repositori dengan version control system (sistem kontrol versi, atau disingkat VCS), sufiks di versi bisa berupa hash dari commit, nama branch, atau sintaks lainnya yang dikenal oleh VCS tersebut, seperti 'go get golang.org/x/text@master’. Ingat bahwa nama branch yang sama dengan sintaks query modul tidak dapat dipilih secara eksplisit. Contohnya, sufiks @v2 artinya versi terakhir mulai dari v2, bukan branch yang bernama v2.

Jika sebuah modul yang diinginkan sudah menjadi dependensi dari modul pengembangan sekarang, maka "get" akan memperbarui versi yang dibutuhkan. Menspesifikasikan sebuah versi yang lebih awal dari versi yang dibutuhkan sekarang adalah valid dan akan men-downgrade dependensi. Versi dengan sufiks @none mengindikasikan bahwa dependensi harus dihapus sepenuhnya, di-downgrade atau menghapus modul yang bergantung kepadanya.

Versi dengan sufiks @latest secara eksplisit meminta rilis minor terakhir dari modul yang diberikan pada path argumen. Sufiks @upgrade seperti @latest namun tidak akan men-downgrade modul jika ia sudah dibutuhkan pada versi tertentu atau versi pra-rilis lebih baru dari pada versi rilis terbaru. Sufiks @patch meminta rilis patch terbaru: versi rilis terbaru dengan angka mayor dan minor yang sama dengan yang dibutuhkan sekarang. Seperti halnya dengan @upgrade, @path tidak akan men-downgrade sebuah modul yang sudah dibutuhkan pada versi terbaru. Jika path tertentu belum diperlukan, @upgrade dan @path sama dengan @latest.

Walaupun "get" secara bawaan menggunakan versi terakhir dari modul yang beris nama paket, ia tidak menggunakan versi terakhir dari dependensi modul. Namun ia menggunakan versi dependensi tertentu yang diminta oleh modul tersebut. Misalnya, jika A butuh modul B v1.2.3, sementara B v1.2.4 dan v1.3.1 juga tersedia, maka 'go get A’ akan menggunakan versi A yang terakhir namun menggunakan B v1.2.3, seperti yang diminta oleh A. (Jika ada kebutuhan yang saling bersaing untuk sebuah modul tertentu, 'go get’ menyelesaikan kebutuhan mereka dengan memilih versi maksimum yang diminta.)

Opsi -t menyuruh 'get’ supaya mengunduh modul-modul yang dibutuhkan untuk pengujian paket yang dispesifikasikan pada baris perintah.

Opsi -u menyuruh 'get’ untuk memperbarui modul-modul sebagai dependensi dari nama paket pada baris perintah supaya menggunakan rilis minor atau patch terbaru bila ada. Melanjutkan contoh sebelumnya, 'go get -u A’ akan menggunakan versi A yang terakhir dengan B v1.3.1 (bukan B v1.2.3). Jika B membutuhkan modul C, namun C tidak menyediakan paket apa pun yang dibutuhkan untuk membangun paket di A, maka C tidak akan diperbarui.

Opsi -u=patch (bukan '-u patch’) juga menyuruh 'get’ untuk memperbarui dependensi, namun dengan menggunakan rilis patch saja. Melanjutkan contoh sebelumnya, 'go get -u=patch A@latest’ akan menggunakan versi A yang terakhir dengan B v1.2.4 (bukan B v1.2.3), namun untuk 'go get -u=patch A’ akan menggunakan rilis patch dari A.

Bila opsi -t dan -u digunakan bersamaan, 'get’ akan memperbarui dependensi tes juga.

Pada umumnya, menambahkan dependensi baru membutuhkan pembaruan dependensi yang ada supaya pembangunan dapat berjalan, dan 'go get’ akan melakukan hal ini secara otomatis. Hal yang sama, menurunkan versi salah satu dependensi bisa jadi menurunkan dependensi yang lain, dan 'go get’ juga menangani ini secara otomatis.

Opsi -insecure membolehkan pengambilan dari repositori yang menggunakan skema tidak aman seperti HTTP. Gunakan dengan hati-hati.

Langkah kedua yaitu mengunduh (bila perlu), membangun, dan memasang paket yang diminta.

Jika argumen berupa modul bukan paket (karena tidak ada sumber kode Go dalam direktori akar dari modul), maka langkah pemasangan dilewati, bukan menyebabkan gagal pembangunan. Misalnya, 'go get golang.org/x/perf’ akan sukses walaupun tidak ada kode di dalam path impor tersebut.

Ingat bahwa pola paket dibolehkan dan dikembangkan setelah versi modul diselesaikan. Misalnya, 'go get golang.org/x/perf/cmd/…​' menambahkan versi 'golang.org/x/perf’ yang terakhir dan kemudian memasang perintah-perintah pada versi yang terakhir juga.

Opsi -d membuat 'get’ mengunduh kode yang dibutuhkan untuk membangun paket, termasuk mengunduh dependensi yang dibutuhkan, namun tidak membangun dan memasang mereka.

Tanpa ada argumen, 'go get’ berlaku terhadap paket Go di direktori yang sekarang, jika ada. Terutama, 'go get -u’ dan 'go get -u=patch’ memperbarui semua dependensi dari paket tersebut. Jika tidak ada argumen paket dan juga tanpa -u, 'go get’ hampir sama dengan 'go install’, dan 'go get -d’ hampir sama dengan 'go list’.

Untuk lebih tentang modul, lihat 'go help modules’.

Untuk lebih lanjut tentang argumen paket, lihat 'go help packages’.

Tulisan ini menjelaskan perilaku dari 'get’ pada modul untuk mengatur kode dan dependensi. Jika perintah 'go’ berjalan dalam mode GOPATH, opsi dari 'get’ berubah, sebagaimana juga 'go help get’. Lihat 'go help modules’ dan 'go help gopath-get’.

Lihat juga: go build, go install, go clean, go mod.

Penggunaan:

Perintah 'install’ mengompilasi dan memasang paket berdasarkan path impor.

Program executable dipasang dalam direktori GOBIN dari variabel lingkungan, yang bila kosong akan diset ke $GOPATH/bin atau $HOME/go/bin. Program dalam $GOROOT dipasang di $GOROOT/bin atau $GOTOOLDIR bukan $GOBIN.

Jika mode modul tidak aktif, paket-paket lain dipasang dalam direktori $GOPATH/pkg/$GOOS_$GOARCH. Jika mode modul aktif, paket-paket dibangun dan di-cache tapi tidak dipasang.

Opsi -i memasang dependensi dari paket juga.

Untuk informasi lebih lanjut tentang opsi pembangunan, lihat 'go help build’. Untuk informasi lebih lanjut tentang penamaan paket, lihat 'go help packages’.

Lihat juga: go build, go get, go clean.

Penggunaan:

Perintah 'list’ mencetak nama paket, per baris. Opsi yang sering digunakan yaitu -f dan -json, yang mengatur pencetakan dari setiap paket. Opsi 'list’ lainnya, mengontrol detail yang lebih khusus.

Keluaran bakunya mencetak path impor dari paket:

Opsi -f menentukan format alternatif dari daftar tersebut, menggunakan sintaksis dari templat paket. Keluaran bakunya sama dengan -f '{{.ImportPath}}'. Struct yang dikirim ke templat yaitu:

Paket yang disimpan dalam direktori vendor melaporkan ImportPath yang mengikutkan path ke direktori vendor (misalnya, "d/vendor/p" bukan "p"), sehingga ImportPath secara unik mengidentifikasi salinan dari sebuah paket. Daftar pada Imports, Deps, TestImports, dan XTestImports juga berisi path impor yang diperluas ini. Lihat golang.org/s/go15vendor untuk lebih lanjut tentang "vendor".

Informasi eror, jika ada, yaitu

Informasi modul yaitu struct Module, didefinisikan dalam diskusi dari daftar -m di bawah.

Fungsi templat "join" memanggil strings.Join.

Fungsi templat "context" mengembalikan context pembangunan, didefinisikan sebagai:

Untuk informasi lebih lanjut tentang makna dari field-field tersebut lihat dokumentasi paket go/build untuk tipe Context.

Opsi -json menyebabkan data paket dicetak dalam format JSON bukan menggunakan format templat.

Opsi -compiled men-set CompiledGoFiles dengan berkas sumber Go yang diberikan kepada compiler. Biasanya hal ini berisi berkas dalam GoFiles dan juga menambahkan kode Go yang dihasilkan dari pemrosesan CgoFiles dan SwigFiles. Daftar impor berisi gabungan dari semua impor GoFiles dan CompiledGoFiles.

Opsi -deps membuat perintah "list" melakukan iterasi tidak hanya pada paket tetapi juga semua dependensinya. Semua dependensi dikunjungi secara depth-first post-order, sehingga paket dicetak setelah semua dependensinya. Paket-paket yang secara eksplisit tidak dicantumkan pada baris perintah akan memiliki field DepOnly bernilai true.

Opsi -e mengubah penanganan paket-paket yang eror, yaitu paket yang tidak bisa ditemukan atau salah format. Secara baku, perintah "list" mencetak kesalahan untuk setiap paket dan mengindahkan paket yang eror tersebut. Dengan opsi -e, perintah "list" tidak akan mencetak kesalahan namun memproses paket yang eror tersebut. Paket yang eror akan memiliki isi pada field ImportPath dan Error; informasi lainnya bisa saja kosong.

Opsi -export membuat field Export di-set dengan nama berkas yang berisi informasi ekspor terbaru dari paket yang diberikan.

Opsi -find membuat perintah "list" mengidentifikasi paket tetapi tidak mencari dependensinya: field Imports dan Deps akan kosong.

Opsi -test melaporkan tidak hanya nama paket namun juga program pengujiannya (untuk paket-paket dengan tes), supaya perkakas analisis sumber kode tahu bagaimana program test dibangun. Path impor yang dilaporkan untuk sebuah program tes yaitu path import dari paket diikuti oleh sufiks ".test", seperti "math/rand.test". Saat membangun sebuah tes, terkadang perlu membangun ulang beberapa dependensi khusus untuk tes (umumnya paket tes itu sendiri). Path impor yang dilaporkan dari sebuah paket yang dikompilasi ulang untuk sebuah program tes tertentu yaitu diikuti dengan sebuah spasi dan nama dari program tes dalam tanda kurung siku, seperti "math/rand [math/rand.test]" atau "regexp [sort.test]". Field ForTest diisi dengan nama dari paket yang di tes ("math/rand" atau "sort" pada contoh sebelumnya).

Path berkas pada Dir, Target, Shlib, Root, ConflictDir, dan Export adalah path absolut.

Secara baku, daftar dalam GoFiles, CgoFiles, dan seterusnya berisi nama-nama berkas dalam Dir (yaitu path yang relatif terhadap Dir, bukan path absolut). Berkas-berkas yang ditambah saat menggunakan opsi -compiled dan -test adalah berupa path absolut yang mengacu ke salinan dari berkas sumber Go. Walaupun mereka adalah sumber berkas Go, path mereka sendiri bisa saja tidak diakhiri dengan ".go".

Opsi -m mencetak daftar modul bukan paket-paket.

Saat mencetak modul, opsi -f menentukan format templat yang diterapkan pada sebuah Go struct, yaitu Module struct:

Keluaran baku yaitu mencetak path modul dan informasi tentang versi dan penggantinya jika ada. Contohnya, 'go list -m all’ mencetak:

Struct Module memiliki method String yang membuat format baris keluaran di atas, sehingga format baku sama dengan -f '{{.String}}'.

Ingatlah bahwa saat sebuah modul telah ditimpa, field Replace menjelaskan modul yang menggantinya, dan field Dir diisi dengan sumber kode pengganti, jika ada. (Jika Replace tidak kosong, maka Dir diisi dengan Replace.Dir, tanpa akses ke sumber kode yang menggantinya.)

Opsi -u menambahkan informasi tambahan tentang adanya pembaruan. Bila versi terakhir dari sebuah modul lebih baru dari yang sekarang, opsi -u men-set field Update dengan informasi tentang modul terbaru. Method String pada Module mengindikasikan adanya pembaruan dengan mencetak versi terbaru dalam tanda kurung siku setelah versi yang sekarang. Misalnya, 'go list -m -u all’ bisa mencetak:

(Untuk perkakas luar, 'go list -m -u -json all’ mungkin lebih mudah untuk diurai.)

Opsi -versions men-set field Version pada Module dengan daftar semua versi dari modul tersebut, diurut berdasarkan versi semantik, dari yang lama ke yang terbaru. Opsi ini mengubah format keluaran baku dengan menampilkan path modul diikuti daftar versi yang dipisahkan oleh spasi. Misalnya,

Argumen yang diberikan ke -m adalah daftar modul, bukan paket. Modul utama yaitu modul yang berisi direktori sekarang. Modul aktif adalah modul utama dan dependensinya. Tanpa argumen, 'list -m’ mencetak modul utama. Dengan argumen, 'list -m’ mencetak modul yang diberikan pada argumen. Modul-modul yang aktif dapat dispesifikasikan dengan path modul mereka. Pola khusus seperti "all" menentukan semua modul aktif, pertama modul utama dan kemudian dependensinya diurut berdasarkan path modul. Pola yang berisi "…​" menentukan modul aktif yang path modul-nya cocok dengan pola tersebut. Kueri dengan format "path@version" menentukan hasil dari pencarian tersebut, yang tidak dibatasi oleh modul aktif. Lihat 'go help modules’ untuk lebih tentang kueri modul.

Fungsi templat "module" menerima argumen sebuah string yang harus berupa path modul atau kueri dan mengembalikan modul tertentu sebagai struct Module. Jika terjadi kesalahan, hasilnya berupa struct Module dengan field Error yang berisi.

Untuk lebih lanjut tentang opsi "build", lihat 'go help build’.

Untuk lebih lanjut tentang penentuan paket, lihat 'go help packages’.

Untuk lebih lanjut tentang modul, lihat 'go help modules’.

Perintah 'go mod’ menyediakan akses terhadap operasi-operasi pada modul.

Ingatlah bahwa dukungan untuk modul tertanam pada semua perintah go, tidak hanya 'go mod’. Misalnya, penambahan, penghapusan, pembaruan, dan pemunduran dari dependensi seharusnya dilakukan lewat 'go get’. Lihat 'go help modules’ untuk gambaran dari fungsionalitas modul.

Penggunaan:

Argumen "command" adalah:

Gunakan "go help mod <command>" untuk informasi lebih lanjut tentang perintah-perintah tersebut.

Penggunaan:

Perintah "run" mengompilasi dan menjalankan paket Go bernama "main". Biasanya paket tersebut ditentukan sebagai daftar berkas sumber .go dari sebuah direktori, tetapi bisa juga dalam bentuk path impor, path dalam sistem berkas, atau pola yang sesuai dengan sebuah paket, seperti 'go run .' atau 'go run my/cmd’.

Secara bawaan, 'go run’ secara langsung menjalankan berkas binari hasil kompilasi: 'a.out argumen…​'. Jika opsi "-exec" diberikan, 'go run’ menjalankan berkas binari menggunakan program "xprog":

Jika opsi "-exec" tidak diberikan, GOOS atau GOARCH berbeda dengan bawaan sistem, dan sebuah program bernama go_$GOOS_$GOARCH_exec ditemukan ditemukan dalam system PATH, 'go run’ memanggil berkas binari menggunakan program tersebut, misalnya 'go_js_wasm_exec a.out argumen…​'. Hal ini membolehkan eksekusi dari program yang dikompilasi silang (cross-compiled) saat sebuah simulator atau metode eksekusi lain tersedia.

Status keluaran dari perintah run bukanlah status keluaran dari berkas binary hasil kompilasi.

Untuk informasi lebih lanjut tentang opsi-opsi pembangunan, lihat 'go help build’. Untuk informasi lebih lanjut tentang cara menspesifikasikan paket, lihat 'go help packages’.

Lihat juga: go build.

Penggunaan:

Perintah 'go test’ men- otomatisasi pengujian paket-paket berdasarkan nama path impor. Ia mencetak ringkasan dari hasil pengujian dalam format:

diikuti dengan detail untuk setiap paket yang gagal (FAIL).

Perintah 'go test’ meng-ompilasi ulang setiap paket bersama dengan semua berkas yang sesuai dengan pola berkas "*test.go". Berkas-berkas tambahan ini bisa berisi fungsi-fungsi pengujian, _benchmark_, dan contoh. Lihat 'go help testfunc’ untuk lebih lanjut. Setiap paket yang didaftarkan menyebabkan eksekusi pengujian yang berbeda. Nama berkas yang dimulai dengan "" (termasuk "_test.go") atau "." akan diindahkan.

Berkas-berkas uji yang memiliki nama paket dengan sufiks "_test" akan dikompilasi sebagai paket yang terpisah, dan kemudian dihubungkan dan dijalankan bersamaan dengan binari pengujian utama.

Perkakas go akan mengindahkan sebuah direktori bernama "testdata", membuatnya tersedia sebagai tempat penyimpanan data yang dibutuhkan oleh pengujian.

Sebagai bagian dari pembangunan sebuah binari pengujian, 'go test’ menjalankan 'go vet’ terhadap paket yang diberikan dan berkas sumber ujinya untuk mengidentifikasi permasalahan yang signifikan. Jika 'go vet’ menemukan masalah, 'go test’ melaporkannya dan tidak akan menjalankan binari pengujian. Hanya sebagian dari perkakas 'go vet’ yang digunakan, yaitu: 'atomic’, 'bool’, 'buildtags’, 'errorsas’, 'ifaceassert’, 'nilfunc’, 'printf’, dan 'stringintconv’. Anda bisa membaca dokumentasi dari setiap perkakas tersebut lewat "go doc cmd/vet". Untuk meniadakan eksekusi 'go vet’, gunakan opsi "-vet=off".

Semua baris keluaran dan ringkasan pengujian dicetak ke standard output, bahkan bila fungsi pengujian mencetaknya ke standard error-nya sendiri. (standard error dari perintah go disediakan hanya untuk mencetak eror saat membangun binari pengujian.)

Perintah 'go test’ berjalan dalam dua mode berbeda:

Yang pertama, disebut mode direktori lokal, terjadi saat 'go test’ dipanggil tanpa argumen paket (misalnya, 'go test’ atau 'go test -v’). Dalam mode ini, 'go test’ mengompilasi sumber kode dan tes paket yang ditemukan dalam direktori yang sekarang dan kemudian menjalankan binari tes. Dalam mode ini, tembolok (didiskusikan di bawah) di non-aktifkan. Setelah pengujian paket selesai, "go test" mencetak baris ringkasan memperlihatkan status pengujian ('ok’ atau 'FAIL’), nama paket, dan waktu yang dihabiskan.

Yang kedua, disebut mode daftar paket, terjadi saat "go test" dipanggil dengan argumen paket (misalnya 'go test math’, 'go test ./…​', dan bahkan 'go test .'). Dalam mode ini, "go test" mengompilasi dan menguji setiap paket yang diberikan pada baris perintah. Jika sebuah pengujian paket berhasil, "go test" hanya mencetak baris ringkasan 'ok’. Jika pengujian paket gagal, "go test" mencetak semua keluaran pengujian. Jika dipanggil dengan opsi "-bench" atau "-v", "go test" mencetak semua keluaran bahkan untuk pengujian paket yang berhasil, dengan tujuan menampilkan hasil benchmark atau pencatatan. Setelah pengujian semua paket selesai, dan hasilnya dicetak, "go test" menampilkan status 'FAIL’ jika salah satu pengujian paket gagal.

Pada mode daftar paket, "go test" menyimpan hasil pengujian paket yang berhasil dalam sebuah tembolok untuk menghindari pengulangan pengujian yang tidak penting. Bila hasil dari sebuah pengujian dapat dipulihkan dari tembolok, "go test" akan menampilkan ulang keluaran sebelumnya bukan menjalankan binari pengujian kembali. Bila ini terjadi, "go test" mencetak '(cached)' sebagai pengganti waktu pada baris ringkasan.

Aturan dari penggunaan tembolok yaitu pengujian dijalankan mengikutkan binari pengujian yang sama dan opsi-opsi pada baris perintah menggunakan sekumpulan opsi yang dapat di-cache, yaitu -cpu, -list, -parallel, -run, -short, dan -v. Jika "go test" dijalankan dengan opsi selain dari sekumpulan opsi tersebut, maka hasilnya tidak akan di-cache. Untuk menonaktifkan caching pengujian, gunakan opsi pengujian atau argumen selain opsi-opsi yang dapat di-cache. Cara idiomatis untuk menonaktifkan cache pengujian secara eksplisit yaitu menggunakan -count=1. Tes-test yang membuka berkas dalam sumber paket (biasanya $GOPATH) atau yang membaca variabel lingkungan akan selalu berjalan sama selama berkas dan variabel lingkungan tidak berubah. Sebuah hasil pengujian yang di-cache dianggap dieksekusi tanpa memakan waktu sama sekali, sehingga sebuah hasil tes yang sukses akan di-cache dan digunakan ulang dengan mengindahkan pengaturan -timeout.

Selain opsi-opsi "build", opsi-opsi yang ditangani oleh 'go test’ itu sendiri diantaranya:

Binari tes juga menerima opsi yang mengontrol eksekusi dari tes; opsi-opsi tersebut juga dapat diakses oleh 'go test’. Lihat 'go help testflag’ untuk lebih detail.

Untuk lebih lanjut tentang opsi "build", lihat 'go help build’. Untuk lebih lanjut tentang cara menspesifikasikan paket, lihat 'go help packages’.

Lihat juga: go build, go vet.

Penggunaan:

Perintah 'tool’ menjalankan perintah yang diidentifikasi oleh argumen-argumennya. Bila argumen tidak diberikan, ia akan mencetak daftar perintah yang dikenal oleh 'tool’.

Opsi -n menyebabkan 'tool’ mencetak perintah yang akan dieksekusi tetapi tidak mengeksekusinya.

Untuk informasi lebih lanjut tentang setiap perintah pada 'tool’, lihat 'go doc cmd/<perintah>'.

Penggunaan:

Perintah 'version’ mencetak informasi pembangunan dari hasil binari Go.

Perintah 'go version’ melaporkan versi Go yang digunakan untuk membangun setiap nama berkas binari yang diberikan pada baris perintah.

Jika tidak ada berkas yang diberikan, 'go version’ akan mencetak informasi versi dirinya sendiri.

Jika sebuah direktori diberikan, 'go version’ menelusuri direktori tersebut secara rekursif, mencari hasil binari-binari Go yang dikenal dan melaporkan versi mereka masing-masing. Secara bawaan, 'go version’ tidak melaporkan berkas-berkas yang tidak dikenal yang ditemukan selama pemindaian direktori. Opsi -v melaporkan berkas-berkas yang tidak dikenal tersebut.

Opsi -m menyebabkan 'go version’ mencetak informasi versi modul yang tertanam dalam binari, bila ada. Keluarannya yaitu informasi modul yang berisi beberapa baris diikuti oleh versi, yang dipisahkan oleh karakter tab.

Lihat juga: go doc runtime/debug.BuildInfo.

Penggunaan

Program vet menjalankan perintah go vet pada paket-paket berdasarkan nama path impor yang diberikan pada parameter "packages".

Untuk informasi lebih lanjut tentang vet dan opsinya, lihat 'go doc cmd/vet’. Untuk informasi tentang parameter "packages", lihat 'go help packages’. Untuk informasi dafter checker (pemeriksa) yang tersedia berikut opsinya, lihat 'go tool vet help’. Untuk informasi tentang checker seperti 'printf’, lihat 'go tool vet help printf’.

Opsi -n mencetak perintah yang akan dieksekusi. Opsi -x mencetak perintah saat mereka dieksekusi.

Opsi -vettool=prog menentukan perkakas analisis yang akan digunakan dengan pemeriksaan alternatif atau tambahan. Misalnya, penganalisis 'shadow’ dapat dibangun dan dijalankan menggunakan perintah berikut:

Opsi "build flags" yang didukung oleh "go vet" yaitu opsi-opsi yang mengontrol eksekusi dan pencarian paket, seperti -n, -x, -v, -tags, dan -toolexec. Untuk tahu lebih banyak tentang opsi tersebut, lihat 'go help build’.

Lihat juga: go fmt, go fix.

Sebuah batasan pembangunan, dikenal juga dengan tag build, adalah baris komentar yang diawali dengan

yang berisi daftar kondisi yang mana sebuah berkas akan disertakan dalam paket. Batasan-batasan tersebut bisa muncul dalam berkas sumber kode apa saja (tidak hanya Go), namun harus berada paling atas, diawali hanya oleh baris kosong atau baris komentar lain. Aturan ini berarti bahwa dalam berkas Go sebuah batasan pembangunan harus muncul sebelum klausa "package".

Untuk membedakan antara batasan pembangunan dengan dokumentasi paket, sekumpulan batasan pembangunan harus diikuti oleh baris kosong.

Sebuah batasan pembangunan dievaluasi sebagai logika OR dari opsi-opsi yang dipisahkan dengan spasi. Setiap opsi dievaluasi sebagai logika AND bila dipisahkan oleh koma. Setiap kondisi terdiri dari huruf, angka, garis bawah, dan titik. Sebuah kondisi bisa dinegasikan dengan mengawali dengan !. Sebagai contoh, batasan pembangunan berikut:

berkorespondensi dengan formula logika:

Sebuah berkas bisa memiliki banyak batasan pembangunan. Keseluruhan batasan dievaluasi dengan operasi AND. Batasan pembangunan berikut:

berkorespondensi dengan formula logika:

Saat pembangunan dilakukan, beberapa kata-kata berikut dipenuhi:

Tidak ada tag-tag pembangunan yang memisahkan antara rilis beta atau minor.

Jika sebuah nama berkas, setelah ekstensi dan akhiran "_test" dihapus, cocok dengan salah satu pola berikut:

(contoh: source_windows_amd64.go) yang mana GOOS dan GOARCH merepresentasikan sistem operasi dan arsitektur, maka berkas tersebut dianggap memiliki batasan pembangunan implisit (dengan tambahan batasan-batasan eksplisit dari dalam berkas).

Menggunakan GOOS=android akan cocok dengan tag dan berkas pembangunan untuk GOOS=linux dengan tambahan tag dan berkas untuk android.

Menggunakan GOOS=illumos akan cocok dengan tag dan berkas pembangunan untuk GOOS=solaris dengan tambahan tag dan berkas untuk illumos.

Menggunakan GOOS=ios akan cocok dengan tag dan berkas untuk GOOS=darwin dengan tambahan tag dan berkas khusus untuk ios.

Untuk melewati sebuah berkas dari pembangunan:

(kata lain bisa digunakan, tetapi "ignore" lebih konvensional.)

Untuk membangun sebuah berkas hanya saat menggunakan cgo, dan hanya pada Linux dan OS X:

Berkas tersebut biasanya dipadukan dengan berkas lain yang mengimplementasikan fungsionalitas baku untuk sistem berbeda, yang mana pada kasus ini akan memiliki batasan sebaliknya:

Menamakan sebuah berkas dengan dns_windows.go akan menyebabkan ia hanya diikutkan saat membangun paket pada sistem Windows; hal yang sama, math_386.s hanya akan diikutkan saat membangun paket untuk arsitektur 32-bit x86.

Perintah 'go build’ dan 'go install’ menerima argumen -buildmode yang mengindikasikan jenis berkas objek apa yang akan dibangun. Nilai yang didukung antara lain,

Pada AIX, saat mengaitkan program C yang menggunakan arsip Go yang dibangun dengan -buildmode=c-archive, Anda harus mengirim -Wl,-bnoobjreorder ke compiler C.

Ada dua perbedaan cara pemanggilan antara kode Go dan C/C++.

Yang pertama yaitu perkakas cgo, yang merupakan bawaan dari distribusi Go. Untuk informasi tentang cara penggunaannya lihat dokumentasi cgo (go doc cmd/cgo).

Yang kedua yaitu program SWIG, yaitu sebuah perkakas umum antarmuka antar bahasa. Informasi lebih lanjut tentang SWIG lihat swig.org. Saat menjalankan "go build", setiap berkas dengan ekstensi .swig akan dikirim ke SWIG. Setiap berkas dengan ekstensi .swigcxx akan dikirim ke SWIG dengan opsi -c++.

Bila cgo atau SWIG tidak digunakan, "go build" akan mengirim semua berkas .c, .m, .s, .S, atau .sx ke compiler C, dan semua berkas .cc, .cpp, .cxx ke compiler C. Variabel lingkungan CC atau CXX bisa diset untuk menentukan _compiler_ C atau C yang akan digunakan.

Perintah go menyimpan hasil pembangunan untuk digunakan lagi pada pembangunan berikutnya. Lokasi baku dari tempat penyimpanan ini yaitu direktori bernama go-build di dalam direktori tembolok pengguna sesuai dengan sistem operasi yang digunakan. Lokasi ini dapat diganti lewat variabel lingkungan GOCACHE, dan menjalankan 'go env GOCACHE’ akan menampilkan direktori tembolok yang sedang digunakan.

Perintah go secara berkala akan menghapus data tembolok yang jarang digunakan. Menjalankan 'go clean —cache’ menghapus semua data tembolok.

Tembolok pembangunan mencatat perubahan pada sumber kode Go, compiler, opsi pada compiler, dan seterusnya: membersihkan tembolok secara eksplisit sebenarnya tidak perlu dilakukan. Namun, tembolok pembangunan tidak mendeteksi perubahan terhadap pustaka C yang diimpor lewat cgo. Jika Anda melakukan perubahan pada pustaka C dalam sistem Anda, Anda harus membersihkan tembolok secara eksplisit atau gunakan opsi pembangunan -a (lihat 'go help build’) untuk memaksa membangun ulang semua paket yang bergantung pada pustaka C yang diubah.

Perintah go juga menyimpan tembolok hasil pengujian paket yang sukses. Lihat 'go help test’ untuk lebih detail. Menjalankan 'go clean -testcache’ menghapus semua tembolok hasil pengujian (namun tetap menyimpan tembolok hasil pembangunan).

Variabel sistem GODEBUG dapat digunakan untuk menghidupkan pelacakan (debugging) tentang kondisi dari tembolok:

GODEBUG=gocacheverify=1 menyebabkan perintah go mengindahkan tembolok sehingga memaksa membangun ulang semuanya dan memeriksa apakah hasilnya sesuai dengan isi tembolok sekarang.

GODEBUG=gocachehash=1 menyebabkan perintah go mencetak input yang di-hash untuk membangun kunci pencarian tembolok. Keluaran dari pelacakan ini sangat banyak namun berguna untuk memeriksa tembolok.

GODEBUG=gocachetest=1 menyebabkan perintah go mencetak detail keputusan apakah memakai ulang hasil pengujian di tembolok atau tidak.

Perintah go dan perkakas yang dieksekusi, membaca variabel lingkungan untuk konfigurasi. Jika sebuah variabel lingkungan tidak diset, perintah go menggunakan pengaturan bawaan. Untuk melihat pengaturan efektif dari variabel <NAME>, jalankan 'go env <NAME>'. Untuk mengganti pengaturan bawaan, jalankan 'go env -w <NAME>=<VALUE>'. Perubahan dari 'go env -w’ dicatat dalam berkas konfigurasi Go yang disimpan dalam direktori konfigurasi user, yang diambil lewat os.UserConfigDir. Lokasi dari berkas konfigurasi dapat diganti dengan men-set variabel lingkungan GOENV, dan 'go env GOENV’ mencetak lokasi efektifnya, namun 'go env -w’ tidak bisa mengganti lokasi bawaannya. Lihat 'go help env’ untuk lebih detail.

Variabel lingkungan untuk tujuan umum:

Variabel lingkungan yang digunakan dengan cgo:

Variabel lingkungan untuk arsitektur tertentu:

Variabel lingkungan untuk tujuan tertentu:

Informasi tambahan yang tersedia lewat 'go env’ tapi tidak dibaca dari lingkungan:

Perintah go memeriksa isi dari direktori dengan batasan berkas tertentu. Go mengidentifikasi berkas mana yang diperiksa berdasarkan ekstensi dari nama berkas. Ekstensi tersebut antara lain:

Berkas dari setiap tipe-tipe tersebut kecuali .syso bisa berisi batasan pembangunan (komentar //+build), namun perintah go akan berhenti mencari batasan pembangunan bila baris pertama pada berkas bukan baris kosong atau bukan baris komentar dengan prefiks //. Lihat dokumentasi go/build untuk lebih detail.

Sebuah versi modul didefinisikan oleh kumpulan berkas, dengan sebuah berkas go.mod pada root direktori. Saat perintah go berjalan, ia akan mencari berkas go.mod tersebut di direktori sekarang dan di direktori di atas-nya untuk menentukan root dari modul utama.

Format berkas go.mod dijelaskan secara detail di https://golang.org/ref/mod#go-mod-file.

Untuk membuat berkas go.mod yang baru, gunakan 'go mod init’. Untuk detail lihat 'go help mod init’ atau https://golang.org/ref/mod#go-mod-init.

Untuk menambahkan modul yang kurang atau menghapus modul yang tidak dibutuhkan, gunakan 'go mod tidy’. Untuk detail, lihat 'go help mod tidy’ atau https://golang.org/ref/mod#go-mod-tidy.

Untuk menambah, meningkatkan atau menurunkan versi modul, atau menghapus modul tertentu, gunakan 'go get’. Untuk detail-nya, lihat 'go help module-get’ atau https://golang.org/ref/mod#go-get.

Untuk membuat perubahan lain atau membaca go.mod sebagai JSON untuk digunakan oleh perkakas lain, gunakan 'go mod edit’. Lihat 'go help mod edit’ atau https://golang.org/ref/mod#go-mod-edit.

Variabel lingkungan GOPATH berisi daftar direktori untuk mencari kode Go. Pada Unix, nilainya adalah string yang dipisahkan oleh titik-dua ":". Pada Windows, nilainya adalah string yang dipisahkan oleh titik-koma ";". Pada Plan 9, nilainya adalah sebuah daftar.

Jika GOPATH tidak diset, nilai bakunya adalah direktori bernama "go" di dalam rumah direktori user ($HOME/go pada Unix, %USERPROFILE% pada Windows), kecuali bila direktori tersebut telah berisi pemasangan distribusi Go. Jalankan "go env GOPATH" untuk melihat nilai GOPATH.

Lihat https://golang.org/wiki/SettingGOPATH untuk menset nilai GOPATH.

Setiap direktori yang terdaftar dalam GOPATH haruslah memiliki struktur sebagai berikut:

Direktori src menyimpan sumber kode. Path yang ada di dalam src menentukan path impor atau nama program.

Direktori pkg menyimpan pemasangan objek-objek paket. Seperti pada distribusi Go, setiap pasangan target sistem operasi dan arsitektur memiliki sub-direktori sendiri (pkg/GOOS_GOARCH).

Jika DIR adalah sebuah direktori dalam GOPATH, sebuah paket dengan sumber kode dalam DIR/src/foo/bar dapat diimpor lewat "foo/bar" dan hasil kompilasinya dipasang ke "DIR/pkg/GOOS_GOARCH/foo/bar.a".

Direktori bin menyimpan hasil kompilasi program. Setiap program memiliki nama sesuai dengan nama sumber direktorinya, namun hanya elemen direktori terakhir, bukan keseluruhan path. Misalnya, program dengan sumber kode dalam DIR/src/foo/quux dipasang ke DIR/bin/quux, bukan DIR/bin/foo/quux. Prefiks "foo/" dihapus supaya Anda bisa menambahkan DIR/bin ke variabel lingkungan PATH pada sistem operasi Anda. Jika variabel lingkungan GOBIN diset, program-program akan dipasang ke dalam direktori tersebut bukan ke DIR/bin. Nilai dari GOBIN haruslah path absolut.

Berikut contoh struktur direktori:

Go mencari setiap direktori yang terdaftar dalam GOPATH untuk mencari sumber kode, namun paket-paket yang baru selalu diunduh ke direktori pertama dalam daftar tersebut.

Lihat /doc/code.html sebagai contohnya.

Saat menggunakan mode modul, GOPATH tidak digunakan lagi untuk mencari impor. Namun, ia masih digunakan untuk menyimpan sumber kode yang diunduh (dalam GOPATH/pkg/mod) dan menyimpan program yang dikompilasi (dalam GOPATH/bin).

Kode yang ada di dalam direktori bernama "internal" hanya bisa diimpor oleh kode-kode dalam direktori di atas dari "internal". Berikut versi tambahan dari struktur direktori di atas:

Kode dalam z.go diimpor sebagai "foo/internal/baz", namun perintah impor tersebut hanya dapat dilakukan dalam berkas sumber dari dalam direktori foo dan turunannya. Berkas sumber foo/f.go, foo/bar/x.go, dan foo/quux/y.go dapat mengimpor "foo/internal/baz", namun berkas sumber crash/bang/b.go tidak bisa.

Lihat https://golang.org/s/go14internal untuk lebih detailnya.

Go 1.6 mendukung penggunaan salinan lokal dari dependensi eksternal untuk memenuhi impor-impor dari dependensi tersebut, sering juga disebut dengan istilah vendoring.

Kode di dalam direktori bernama "vendor" hanya dapat diimpor oleh kode dalam direktori dan sub-direktori dari bagian atas "vendor", dan hanya dengan menggunakan path impor yang mengindahkan prefiks sampai ke elemen vendor.

Berikut contoh dari bagian sebelumnya, tapi dengan direktori "internal" diganti nama dengan "vendor" dan sebuah direktori "foo/vendor/crash/bang" ditambahkan:

Aturan impor diterapkan sebagaimana pada direktori internal, namun kode dalam z.go diimpor sebagai "baz", bukan sebagai "foo/vendor/baz".

Kode di dalam direktori vendor menimpa kode pada direktori di atasnya. Misalnya, kode-kode di bawah direktori "foo" yang mengimpor "crash/bang" akan menunjuk ke "foo/vendor/crash/bang", bukan bagian teratas "crash/bang".

Kode di dalam direktori vendor tidak ada pemeriksaan path impor (lihat 'go help importpath’).

Saat 'go get’ mengambil atau memperbarui sebuah repositori git, ia juga akan memperbarui submodules.

Direktori vendor tidak memengaruhi penempatan dari repositori-repositori baru yang diunduh pertama kali oleh 'go get’: repositori tersebut selalu disimpan dalam GOPATH, tidak dalam direktori vendor.

Lihat https://golang.org/s/go15vendor untuk lebih detailnya.

Perintah 'go get’ memiliki perilaku yang berbeda bergantung pada apakah perintah go berjalan dengan mode modul atau mode legasi GOPATH. Teks bantuan untuk legasi GOPATH berikut, yang dapat diakses juga lewat 'go help gopath-get’ bahkan untuk mode modul, menjelaskan 'go get’ yang beroperasi dengan mode legasi GOPATH.

Penggunaan: go get [-d] [-f] [-t] [-u] [-v] [-fix] [opsi build] [paket]

Perintah get mengunduh paket-paket berdasarkan nama dari path impor, berikut dengan dependensinya. Ia kemudian memasang paket-paket tersebut, seperti dengan 'go install’.

Opsi -d membuat perintah get berhenti setelah mengunduh paket; tidak memasang paket tersebut.

Opsi -f, hanya berlaku bila -u juga digunakan, memaksa perintah get -u untuk tidak memeriksa bahwa setiap paket telah diunduh dari repositori yang ditandai oleh path impor-nya. Opsi ini bisa digunakan jika sumber repositori adalah salinan lokal dari yang aslinya.

Opsi -fix membuat perintah get menjalankan perkakas fix pada paket-paket yang diunduh sebelum mencari dependensi atau membangun kode.

Opsi -t membuat perintah get juga mengunduh paket-paket yang dibutuhkan untuk membangun pengujian untuk paket-paket yang ditentukan.

Opsi -u membuat perintah get memperbarui paket-paket yang diberikan berikut dengan dependensinya. Secara bawaan, get menggunakan jaringan internet untuk mengunduh paket yang kurang tapi tidak untuk mencari pembaruan dari paket-paket yang telah terpasang.

Opsi -v membuat perintah get menampilkan progres dan pelacakan lebih lanjut.

Perintah get juga dapat menerima opsi dari perintah build untuk mengontrol pemasangan. Lihat 'go help build’.

Saat mengunduh sebuah paket yang baru, get membuat direktori target GOPATH/src/<import-path>. Jika GOPATH berisi lebih dari satu direktori, get menggunakan direktori yang pertama. Untuk detail lebih lanjut lihat: 'go help gopath’.

Saat mengunduh atau memperbarui sebuah paket, get mencari branch atau tag yang sesuai dengan versi Go yang terpasang di lokal. Aturannya yaitu jika versi pemasangan Go di lokal yaitu "go1", get akan mencari branch atau tag bernama "go1". Jika versi tersebut tidak ada ia akan mengambil branch bawaan dari paket.

Saat go get mengunduh atau memperbarui sebuah repositori Git, ia juga memperbarui git submodules yang diacu oleh repositori tersebut.

Perintah get tidak pernah mengunduh atau memperbarui kode yang disimpan dalam direktori vendor.

Untuk informasi lebih lanjut tentang parameter paket, lihat 'go help packages’.

Untuk informasi tentang bagaimana 'go get’ mencari sumber kode untuk diunduh, lihat 'go help importpath’.

Bagian ini menjelaskan perilaku perintah get bila menggunakan GOPATH untuk mengatur sumber kode dan dependensi. Jika perintah go berjalan dalam mode modul, detail dari opsi get dan efeknya berubah, seperti yang dijelaskan pada 'go help get’. Lihat 'go help modules’ dan 'go help module-get’.

Lihat juga: go build, go install, go clean.

Sebuah proksi Go modul adalah peladen web yang dapat merespon permintaan GET untuk URL dari bentuk tertentu. Permintaan tersebut tidak memiliki parameter kueri, bahkan sebuah situs yang melayani sistem berkas yang statik (termasuk sebuah URL file:///) bisa menjadi proksi modul.

Untuk detail tentang protokol GOPROXY, lihat https://golang.org/ref/mod#goproxy-protocol.

Sebuah path impor (lihat 'go help packages’) menandakan sebuah paket yang disimpan dalam sistem berkas lokal. Secara umum, sebuah path impor menandakan sebuah paket standar (seperti "unicode/utf8") atau sebuah paket yang ditemukan dalam salah satu ruang kerja (Untuk informasi lebih detail lihat: 'go help gopath’).

Sebuah path impor yang dimulai dengan ./ atau ../ disebut dengan path relatif. Perkakas Go mendukung path impor relatif sebagai penyingkat dengan dua cara.

Pertama, sebuah path relatif dapat digunakan sebagai singkatan pada baris perintah. Jika Anda misalkan sedang bekerja dalam direktori yang berisi kode yang diimpor sebagai "unicode" dan ingin menjalankan pengujian untuk "unicode/utf8", Anda bisa menjalankan "go test ./utf8" tanpa perlu menulis keseluruhan path. Hal yang sama, dengan situasi yang sebaliknya, "go test .." akan menjalankan pengujian "unicode" jika dijalankan dari dalam direktori "unicode/utf8". Pola relatif juga dibolehkan, seperti "go test ./…​" untuk menguji semua sub-direktori. Lihat 'go help packages’ untuk detail tentang sintaksis pola.

Kedua, jika Anda mengompilasi sebuah program Go bukan dari ruang kerja, Anda bisa menggunakan path relatif pada perintah impor dalam program tersebut untuk mengacu ke kode terdekat yang juga tidak dalam ruang kerja. Hal ini mempermudah bereksperimen dengan program kecil di luar ruang kerja yang biasa, namun program tersebut tidak bisa dipasang dengan "go install" (tidak ada ruang kerja tempat ia akan dipasang), jadi program tersebut akan selalu dibangun ulang dari awal setiap kali pembangunan dilakukan. Untuk menghindari ambiguitas, program Go tidak bisa menggunakan path impor relatif dari dalam ruang kerja.

Beberapa path impor juga menentukan bagaimana mendapatkan sumber kode dari paket tersebut menggunakan sebuah sistem kontrol revisi (version control system atau VCS).

Beberapa situs penyimpanan kode umum memiliki sintaksis khusus:

Untuk kode yang disimpan pada peladen lain, path impor bisa ditambahkan dengan tipe pengontrol versi, atau perkakas go bisa secara dinamik mengambil path impor lewat https/http dan menentukan di mana kode disimpan berdasarkan tag <meta> dalam HTML.

Untuk mendeklarasikan lokasi kode, sebuah path impor dengan bentuk

menentukan repositori, dengan atau tanpa sufiks .vcs, menggunakan nama VCS, dan path dalam repositori. Nilai VCS yang didukung antara lain:

Misalnya,

menyatakan direktori dari repositori Mercurial pada example.org/user/foo atau foo.hg, dan

menyatakan foo/bar direktori sebagai repositori Git pada example.org/repo atau repo.git.

Saat sebuah VCS mendukung beberapa protokol, setiap protokol akan dicoba bergantian saat melakukan pengunduhan. Misalnya, pengunduhan Git mencoba https://, kemudian git+ssh://.

Secara bawaan, pengunduhan dibatasi hanya untuk protokol yang aman (misalnya https, ssh). Untuk menimpa pengaturan ini pada saat pengunduhan dengan Git, variabel lingkungan GIT_ALLOW_PROTOCOL dapat diset (Untuk detail lebih lanjut lihat: 'go help environment’).

Jika path impor bukan dari situs yang dikenal dan juga tidak memiliki penanda VCS, perkakas go mencoba mengambil path impor lewat https/http dan mencari tag <meta> dalam HTML dokumen <head>.

Tag meta tersebut memiliki bentuk berikut:

Bagian import-prefix adalah path impor yang berkorespondensi dengan root repositori. Nilainya haruslah sebuah prefiks atau path dari paket yang akan diambil lewat "go get". Jika path tidak sesuai, permintaan http berikutnya dilakukan terhadap import-prefix untuk memverifikasi bahwa tag <meta> cocok.

Tag meta sebaiknya berada paling awal dalam berkas HTML sebisa mungkin. Secara khusus, sebaiknya muncul sebelum ada JavaScript atau CSS, untuk menghindari kesalahan penguraian pada perintah Go yang terbatas.

Bagian vcs yaitu salah satu dari "bzr", "fossil", "git", "hg", "svn".

Bagian repo-root yaitu root dari VCS yang berisi sebuah skema dan tidak berisi .vcs.

Misalnya,

akan menghasilkan beberapa permintaan berikut:

Jika halaman kembalian berisi tag meta berikut

perkakas go akan memverifikasi bahwa https://example.og/?go-get=1 berisi tag meta yang sama dan kemudian mengeksekusi

ke dalam

Bila menggunakan mode GOPATH, paket-paket yang diunduh akan disimpan dalam direktori pertama yang terdaftar dalam variabel lingkungan GOPATH. (Lihat 'go help gopath-get’ dan 'go help gopath’.)

Bila menggunakan mode modul, paket-paket yang diunduh disimpan dalam tembolok modul. Lihat https://golang.org/ref/mod#module-cache.

Bila menggunakan mode modul, sebuah variasi tambahan dari tag meta go-import akan dikenali dan dipilih. Variasi tersebut menggunakan "mod" sebagai nilai dalam vcs, seperti berikut:

Tag tersebut berarti untuk mengunduh modul dengan path yang diawali dengan example.org dari proksi modul lewat URL https://code.org/moduleproxy. Lihat https://golang.org/ref/mod#goproxy-protocol untuk detail tentang protokol proksi.

Saat fitur path impor kostum seperti yang dijelaskan di atas dialihkan ke situs penyimpanan yang dikenal, maka setiap paket-paket bisa memiliki dua path impor, menggunakan domain kostum atau lewat situs penyimpanan.

Sebuah perintah paket dikatakan memiliki "komentar impor" jika ia diikuti oleh (sebelum baris baru selanjutnya) oleh sebuah komentar dengan dua bentuk berikut:

Perintah go akan menolak memasang sebuah paket dengan komentar impor kecuali bila ia diacu dengan path impor tersebut. Dengan cara ini, komentar impor membolehkan pemilik paket memastikan bahwa path impor kostum yang digunakan dan bukan path langsung ke situs penyimpanan.

Pemeriksaan path impor dimatikan untuk kode yang ditemukan dalam direktori vendor. Hal ini membolehkan menyalin kode ke dalam lokasi alternatif dalam direktori vendor tanpa perlu mengganti komentar impor.

Pemeriksaan path impor juga dimatikan saat menggunakan modul. Komentar path impor sudah tidak berlaku lagi karena digantikan oleh berkas go.mod lewat baris perintah module.

Lihat https://golang.org/s/go14customimport untuk detailnya.

Modul adalah bagaimana Go mengatur dependensi.

Sebuah modul adalah koleksi dari paket-paket yang dirilis, diberi versi, dan didistribusikan bersamaan. Modul bisa diunduh langsung lewat repositori VCS atau lewat peladen proksi modul.

Untuk seri tutorial tentang modul, lihat https://golang.org/doc/tutorial/create-module.

Untuk referensi detail tentang modul, lihat https://golang.org/ref/mod.

Secara bawaan, perintah go bisa mengunduh modul lewat https://proxy.golang.org. Ia bisa melakukan autentikasi modul menggunakan basis data checksum pada https://sum.golang.org. Kedua layanan ini dioperasikan oleh tim Go pada Google. Kebijakan privasi bagi layanan tersebut dapat dilihat di https://proxy.golang.org/privacy dan https://sum.golang.org/privacy.

Perilaku pengunduhan dari perintah Go bisa diatur lewat variabel lingkungan GOPROXY, GOSUMDB, GOPRIVATE, dan lainnya. Lihat 'go help environment’ dan https://golang.org/ref/mod#private-module-privacy untuk informasi lebih lanjut.

Saat perintah go mengunduh sebuah berkas zip dari modul atau berkas go.mod ke dalam tembolok modul, ia akan menghitung hash kriptografi dan membandingkannya dengan nilai yang diketahui untuk memverifikasi bahwa berkas tersebut belum berubah sejak ia diunduh pertama kalinya. Daftar hash yang dikenal tersebut disimpan dalam sebuah berkas dalam direktori modul bernama go.sum. Daftar hash tersebut juga bisa diunduh lewat basis data checksum bergantung pada nilai dari GOSUMDB, GOPRIVATE, dan GONOSUMDB.

Untuk detailnya, lihat https://golang.org/ref/mod#authenticating.

Banyak perintah Go berlaku untuk sekumpulan paket-paket:

Biasanya, [packages] adalah daftar dari path impor.

Sebuah path impor yang absolut atau dimulai dengan . atau .. diinterpretasikan sebagai path pada sistem berkas dan menyatakan paket dalam direktori tersebut.

Selain itu, path impor P menyatakan paket ditemukan dalam direktori DIR/src/P untuk DIR yang terdaftar dalam variabel lingkungan GOPATH (Untuk detail lebih lanjut lihat: 'go help gopath’).

Jika tidak ada path impor yang diberikan, maka aksi dari perintah go tersebut berlaku untuk paket dalam direktori yang sekarang.

Ada empat nama untuk path yang sebaiknya tidak digunakan untuk nama paket yang akan dibangun dengan perkakas go:

Path impor yang diawali dengan "cmd/" hanya dicocokan dengan sumber kode dalam repositori Go.

Sebuah path impor adalah sebuah pola jika ia mengikutkan satu atau lebih "…​" wildcard, setiap wildcard dapat dicocokan dengan string apapun, termasuk string kosong dan string yang berisi slash "/". Pola seperti itu dikembangkan menjadi semua direktori paket yang ditemukan dalam GOPATH dengan nama yang sesuai dengan pola.

Supaya pola umum lebih gampang, ada dua kasus khusus. Pertama, /... di akhir dari pola dapat cocok dengan string kosong, sehingga net/... cocok dengan net dan paket-paket dalam sub-direktori nya, seperti net/http. Kedua, setiap pola yang dipisahkan oleh slash "/" yang berisi sebuah wildcard tidak diikutkan dalam pencocokan dengan elemen "vendor", sehingga ./... tidak dicocokan dengan paket-paket dalam direktori ./vendor atau ./mycode/vendor, namun ./vendor/... dan ./mycode/vendor/... bisa. Ingatlah, bahwa sebuah direktori bernama "vendor" yang berisi kode bukanlah paket yang di-vendor-kan: cmd/vendor berarti sebuah program bernama vendor, dan pola ./cmd/... akan mengikutkannya. Lihat https://golang.org/s/go15vendor untuk informasi tentang vendoring.

Sebuah path impor bisa mengikutkan sebuah paket yang akan diunduh dari repositori remote. Lihat 'go help importpath’ untuk detailnya.

Setiap paket dalam sebuah program haruslah memiliki path impor yang unik. Secara konvensi, hal ini diatur dengan mengawali setiap path dengan prefiks yang unik yang dimiliki oleh Anda. Misalnya, path yang digunakan secara internal oleh Google semuanya dimulai dengan 'google’, dan path yang menyatakan repositori remote dimulai dengan path ke kode, seperti 'github.com/user/repo’.

Paket-paket dalam sebuah program tidak harus memiliki nama yang unik, tetapi ada dua nama paket yang memiliki nama yang spesial. Paket bernama "main" mengindikasikan sebuah program, bukan sebuah pustaka. Program bisa dieksekusi dan tidak bisa diimpor. Paket bernama "documentation" mengindikasikan dokumentasi untuk program selain Go di dalam direktori. Berkas-berkas di dalam paket dokumentasi diindahkan oleh perintah go.

Sebagai kasus khusus, jika parameter [packages] adalah daftar berkas-berkas .go dari sebuah direktori yang sama, maka perintah tersebut akan digabungkan menjadi sebuah paket yang berisi berkas-berkas tersebut, mengindahkan batasan pembangunan dalam berkas tersebut dan mengindahkan berkas-berkas lain dalam direktori paket tersebut.

Nama berkas dan direktori yang dimulai dengan "." atau "_" diindahkan oleh perkakas go, sebagaimana juga direktori bernama "testdata".

Perintah go secara bawaan mengunduh Go modul yang publik lewat proksi di proxy.golang.org. Ia secara bawaan juga melakukan validasi checksum terhadap modul yang diunduh, dengan basis data publik yang ada di sum.golang.org. Konfigurasi bawaan ini bekerja untuk semua sumber kode yang publik.

Variabel lingkungan GOPRIVATE mengontrol modul mana saja yang dianggap oleh perintah go sebagai privat (tidak tersedia secara umum) yang meniadakan penggunaan proksi dan validasi basis data checksum. Variabel tersebut berisi daftar prefiks dari modul, dipisahkan oleh koma (sesuai dengan sintaksis fungsi patch.Match). Misalnya,

menyebabkan perintah go menganggap semua modul yang sesuai dengan prefiks tersebut sebagai privat, termasuk git.corp.example.com/xyzzy, rsc.io/private, dan rsc.io/private/guux.

Untuk kontrol lebih lanjut terhadap pengunduhan dan validasi modul, variabel lingkungan GONOPROXY dan GONOSUMDB menerima daftar pola yang sama dan menimpa GOPRIVATE untuk menentukan apakah menggunakan proksi dan basis data checksum.

Misalnya, jika sebuah perusahaan memiliki modul proksi sendiri untuk modul-modul pribadi, pengguna akan set go menggunakan:

Variabel GOPRIVATE juga menentukan pola "publik" dan "private" untuk variabel GOVCS; lihat 'go help vcs’. Untuk penggunaan tersebut, GOPRIVATE berlaku bahkan untuk mode GOPATH. Pada kasus ini, ia mencocokan path impor bukan path modul.

Perintah 'go env -w’ (lihat 'go help env’) dapat digunakan untuk menset variabel-variabel lingkungan tersebut untuk diaplikasikan pada perintah go selanjutnya.

Untuk lebih rinci, lihat https://golang.org/ref/mod#private-modules.

Perintah 'go test’ menerima opsi-opsi yang berlaku untuk 'go test’ itu sendiri dan juga untuk hasil program pengujian.

Beberapa opsi-opsi tersebut mengontrol profiling dan menulis hasil eksekusi profile yang sesuai untuk "go tool pprof"; jalankan 'go tool pprof -h’ untuk informasi lebih lanjut. Opsi —alloc_space, —alloc_objects, dan —show_types dari pprof mengontrol bagaimana informasi tersebut ditulis.

Opsi-opsi berikut dikenali oleh perintah 'go test’ dan mengontrol eksekusi dari pengujian:

Opsi-opsi berikut juga dikenali oleh 'go test’ dan dapat digunakan untuk mem-profile tes saat eksekusi:

Setiap opsi-opsi tersebut juga dikenali lewat prefiks opsional 'test.', seperti -test.v. Saat mengeksekusi program tes (hasil dari 'go test -c’) secara langsung, prefiks ini menjadi wajib.

Perintah 'go test’ akan menulis atau menghapus opsi-opsi yang dikenali, bila diperlukan, sebelum dan sesudah parameter opsional untuk daftar paket, sebelum menjalankan program tes.

Misalnya, perintah

akan mengompilasi program tes dan menjalankannya sebagai

(Opsi -x dihapus karena hanya berlaku untuk eksekusi perintah go, bukan untuk program tes itu sendiri.)

Opsi tes yang membangkitkan profile (selain liputan analisis) juga menyimpan program tes dalam pkg.test untuk digunakan saat menganalisis profile.

Saat 'go test’ menjalankan sebuah program tes, ia akan dijalankan di dalam direktori sumber kode paket. Bergantung kepada tes yang dijalankan, bisa jadi ia akan melakukan hal yang sama saat mengeksekusi program tes secara langsung.

Daftar paket pada baris perintah, jika ada, harus muncul sebelum opsi-opsi yang tidak dikenali oleh perintah 'go test’. Melanjutkan contoh sebelumnya, daftar paket seharusnya muncul sebelum -myflag, namun bisa diberikan antara -v.

Saat 'go test’ berjalan dengan mode daftar paket, 'go test’ menyimpan tembolok dari hasil tes paket yang sukses untuk mengurangi menjalankan tes yang tidak diperlukan. Untuk mematikan tembolok, gunakan opsi tes atau argumen selain dari opsi yang bisa mempengaruhi tembolok. Cara paling umum untuk mematikan tembolok tes secara eksplisit yaitu menggunakan -count=1.

Untuk menghindari supaya argumen dari program tes dianggap sebagai nama paket atau opsi, gunakan -args (lihat 'go help test’) yang akan mengirim sisa dari baris perintah ke program tes tanpa diubah.

Misalnya, perintah

akan mengompilasi program tes dan menjalankannya sebagai

Hal yang sama,

akan mengompilasi program tes dan menjalankannya sebagai

Pada contoh yang pertama, argumen -x dan -v dikirim ke program tes tanpa diubah dan tanpa memengaruhi program go itu sendiri. Pada contoh kedua, argumen math dikirim ke program tes, bukan dianggap sebagai bagian dari daftar paket.

Perintah 'go test’ mencari fungsi tes, benchmark, dan contoh dalam berkas-berkas '*_test.go’ pada paket-paket yang akan dites.

Sebuah fungsi tes yaitu fungsi yang memiliki prefiks Test, misalnya TestXxx (yang mana Xxx harus diawali dengan huruf kapital) dan harus memiliki penanda berikut,

Sebuah fungsi benchmark yaitu yang bernama BenchmarkXxx dan harus memiliki penanda berikut,

Sebuah fungsi ExampleXxx mirip dengan fungsi TestXxx tetapi tidak menggunakan *testing.T untuk melaporkan sukses atau gagal, melainkan mencetak keluaran ke os.Stdout. Jika komentar terakhir pada function ExampleXxx dimulai dengan "Output:" maka keluaran dari fungsi tersebut dibandingkan dengan komentar (lihat contoh di bawah). Jika komentar terakhir dimulai dengan "Unordered output:" maka keluaran dari fungsi Example tersebut dibandingkan dengan isi dari komentar, namun dengan urutan dari baris komentar bisa tidak berurut. Sebuah fungsi Example tanpa ada dua komentar tersebut hanya dikompilasi tapi tidak dijalankan. Sebuah fungsi Example tanpa ada teks setelah "Output:" dikompilasi, dieksekusi, dan ekspektasi-nya adalah tidak ada keluaran.

Godoc menampilkan badan dari ExampleXxx untuk mendemonstrasikan penggunaan dari fungsi, konstanta, atau variabel Xxx. Contohnya, sebuah method M dengan penerima bertipe T atau *T nama fungsi Example-nya adalah ExampleT_M. Bisa saja ada banyak contoh untuk fungsi, konstanta, atau variabel tersebut, dibedakan dari akhiran _xxx, yang mana xxx adalah sebuah sufiks yang tidak dimulai dengan huruf kapital.

Berikut sebuah contoh dari fungsi Example:

Berikut contoh lain yang mana urutan dari keluaran diindahkan:

Keseluruhan berkas tes dipresentasikan sebagai contoh bila ia hanya berisi sebuah fungsi Example saja, paling tidak deklarasi fungsi, tipe, variabel, atau konstanta, dan tidak ada fungsi Benchmark atau Test lainnya.

Lihat dokumentasi dari paket testing untuk informasi lebih lanjut.

Perintah 'go get’ dapat menjalankan perintah-perintah version control, seperti git, untuk mengunduh kode yang diimpor. Fungsionalitas ini sangat penting untuk ekosistem desentralisasi paket Go, yang mana kode dapat diimpor dari peladen mana pun, namun hal ini juga bisa menimbulkan masalah keamanan, jika peladen yang berniat jahat menemukan cara untuk menjalankan kode yang tidak diinginkan.

Untuk menyeimbangkan fungsionalitas dan keamanan, perintah 'go get’ secara bawaan hanya akan menggunakan git dan gh untuk mengunduh kode dari peladen publik. Namun ia akan menggunakan sistem version control yang dikenal (bzr, fossil, git, hg, svn) untuk mengunduh kode dari peladen privat, selama paket-paket yang disimpan sesuai dengan variabel GOPRIVATE (lihat 'go help private’). Rasionalitas dari hanya membolehkan Git dan Mercurial adalah kedua sistem ini memiliki perhatian yang khusus terhadap isu-isu bila dijalankan sebagai klien pada peladen yang tidak dipercaya. Sebaliknya, Bazaar, Fossil, dan Subversion umumnya hanya digunakan pada lingkungan yang dipercaya dengan autentikasi dan rentan terhadap serangan.

Batasan perintah version control hanya berlaku saat menggunakan akses langsung untuk mengunduh kode. Saat mengunduh modul dari sebuah proksi, 'go get’ akan menggunakan protokol proksi, yang mana selalu dibolehkan. Secara bawaan, perintah 'go get’ menggunakan salinan modul Go pada proksi (proxy.golang.org) untuk paket-paket publik dan hanya menggunakan version control untuk paket-paket private atau saat proksi publik menolak melayani publik paket (biasanya karena alasan legalitas). Oleh karena itu, klien masih dapat mengakses kode publik yang disimpan lewat repositori Bazaar, Fossil, atau Subversion, secara pengunduhan dilakukan oleh Go modul proksi, yang menangani resiko keamanan dengan menjalankan perintah version control menggunakan sandbox tersendiri.

Variabel GOVCS dapat digunakan untuk mengubah sistem version control apa saja yang dibolehkan untuk paket-paket tertentu (diidentifikasi lewat path impor atau modul). Variabel GOVCS diterapkan saat membangun paket dengan mode modul dan GOPATH. Saat menggunakan mode modul, pola dengan path modul. Saat menggunakan mode GOPATH, pola disamakan dengan path impor yang berkorespondensi dengan induk dari repositori.

Format umum dari nilai pengaturan GOVCS yaitu sebuah aturan yang dipisahkan dengan koma, format aturan ini yaitu "pola:daftar_vcs". Format dari "pola" yaitu menggunakan glob yang harus sesuai dengan satu atau lebih elemen dari path impor atau modul. Format dari "daftar_vcs" yaitu daftar version control yang dibolehkan yang dipisahkan dengan '|', atau "all" untuk membolehkan perintah apa pun, atau "off" untuk menolak perintah apa pun. Ingatlah bahwa jika sebuah modul cocok dengan pola pada "daftar_vcs" yang di set ke "off", ia bisa saja tetap diunduh jika peladen menggunakan skema "mod", yang menyuruh perintah go untuk mengunduh modul tersebut menggunakan protokol GOPROXY. Pola pertama yang cocok akan digunakan, walaupun pola selanjutnya ada yang cocok juga.

Misalnya,

Dengan pengaturan ini, kode dengan modul atau path impor yang diawali dengan github.com/ hanya dapat menggunakan git; path dengan evil.com tidak dapat menggunakan perintah version control apa pun, dan semua path lainnya (* berarti cocok dengan lainnya) hanya dapat menggunakan git atau hg.

Pola khusus "public" dan "private" cocok dengan modul atau path impor publik dan privat. Sebuah path dikatakan "private" jika ia cocok dengan isi dari variabel GOPRIVATE; selain itu maka akan dianggap publik.

Jika tidak ada aturan dalam variabel GOVCS yang cocok dengan sebuah modul atau path impor tertentu, perintah 'go get’ akan menerapkan aturan bawaan, yaitu 'public:git|gh,private:all’.

Untuk membolehkan penggunaan sistem version control mana pun untuk semua paket, gunakan:

Untuk mematikan penggunakan version control, gunakan:

Perintah 'go env -w’ (lihat 'go help env’) dapat digunakan untuk menset variabel GOVCS untuk pemanggilan perintah go selanjutnya.