Cara menulis kode Go

Pendahuluan

Dokumen ini mendemonstrasikan cara membuat sebuah paket Go yang sederhana dalam sebuah modul dan memperkenalkan perkakas go, cara standar untuk mengambil, membuat, dan memasang modul, paket, dan perintah Go.

Catatan: dokumen ini mengasumsikan bahwa Anda menggunakan Go 1.13 atau terbaru dan variabel lingkungan GO111MODULE tidak di-set. Jika Anda mencari versi dokumen pra-modul, bisa dilihat di sini.

Organisasi kode

Program Go disusun menjadi paket-paket. Sebuah paket adalah koleksi dari sumber berkas di dalam direktori yang sama yang dikompilasi bersamaan. Fungsi, tipe, variabel, dan konstanta yang didefinisikan dalam sebuah sumber berkas dapat dilihat dan digunakan oleh sumber berkas lain dalam paket yang sama.

Sebuah repositori berisi satu atau lebih modul. Sebuah modul adalah koleksi dari paket-paket Go yang berkaitan yang dirilis secara bersamaan. Sebuah repositori Go biasanya hanya berisi satu modul. Sebuah berkas bernama go.mod di dalam repositori mendeklarasikan path dari modul: sebuah path impor prefiks untuk semua paket dalam modul. Modul berisi paket-paket di dalam direktori yang berisi berkas go.mod beserta sub-direktori di dalamnya.

Ingatlah bahwa Anda tidak perlu menerbitkan kode Anda ke repositori publik sebelum dapat digunakan. Sebuah modul bisa dibuat secara lokal tanpa ada repositori. Namun, akan lebih baik meng-organisir kode Anda supaya suatu saat dapat diterbitkan.

Setiap path dari modul tidak hanya sebagai prefiks dari path impor bagi paket-paket mereka saja, tetapi juga mengindikasikan di mana perintah go harus mencari untuk diunduh. Misalnya, untuk mengunduh "golang.org/x/tools", perintah go akan berkomunikasi dengan repositori yang diindikasikan oleh golang.org/x/tools (dijelaskan lebih lanjut nanti).

Sebuah path impor adalah sebuah string yang digunakan untuk mengimpor sebuah paket. Sebuah path import dari paket yaitu path modul digabung dengan subdirektori di dalam modul tersebut. misalnya, modul github.com/google/go-cmp berisi sebuah paket dalam direktori "cmp/". Path import dari paket tersebut yaitu github.com/google/go-cmp/cmp. Paket-paket dari pustaka standar tidak memiliki prefiks path impor.

Program pertama

Untuk mengompilasi dan menjalankan sebuah program sederhana, pertama pilih sebuah path untuk paket (kita akan gunakan github.com/user/hello) dan buat direktori untuk paket tersebut di dalam ruang-kerja:

$ mkdir $GOPATH/src/github.com/user/hello

Selanjutnya, buat sebuah berkas bernama hello.go di dalam direktori tersebut, yang berisi kode Go berikut.

package main

import "fmt"

func main() {
	fmt.Println("Hello, world.")
}

Sekarang kita bisa membuat dan memasang program tersebut dengan perkakas go:

$ go install github.com/user/hello

Ingatlah bahwa program tersebut bisa dijalankan di mana pun dalam sistem. Perkakas go mencari sumber kode dengan melihat paket github.com/user/hello di dalam ruang-kerja yang dispesifikasikan oleh GOPATH.

Kita bisa mengindahkan path paket jika menjalankan go install dari dalam direktori paket:

$ cd $GOPATH/src/github.com/user/hello
$ go install

Perintah tersebut membangun program hello, menghasilkan sebuah binari yang dapat dieksekusi. Perintah tersebut kemudian memasang binari tersebut ke direktori bin di ruang-kerja sebagai hello (atau, pada Windows, hello.exe). Pada contoh ini, binari tersebut akan dibuat di $GOPATH/bin/hello, atau sama dengan $HOME/go/bin/hello.

Perkakas go akan menampilkan pesan eror bila terjadi kesalahan, jadi bila tidak ada eror yang ditampilkan, berarti perintah tersebut dieksekusi dengan sukses.

Anda sekarang dapat menjalankan program tersebut dengan cara:

$ $GOPATH/bin/hello
Hello, world.

Atau, bila telah menambahkan $GOPATH/bin ke dalam PATH, tinggal mengetikan nama program:

$ hello
Hello, world.

Jika menggunakan sistem source control (misalnya, Git), sekarang adalah saat yang bagus untuk menginisiasi repositori, menambahkan berkas, dan melakukan commit yang pertama. Sekali lagi, langkah ini adalah opsional: tidak perlu menggunakan source control untuk menulis kode Go.

$ cd $GOPATH/src/github.com/user/hello
$ git init
Initialized empty Git repository in /home/user/go/src/github.com/user/hello/.git/
$ git add hello.go
$ git commit -m "commit pertama"
[master (root-commit) 0b4507d] initial commit
 1 file changed, 1 insertion(+)
 create mode 100644 hello.go

Memuat kode ke repositori luar sengaja diindahkan sebagai latihan bagi pembaca.

Pustaka pertama

Sekarang mari kita coba membuat sebuah paket pustaka dan menggunakannya dalam program hello.

Langkah pertama yaitu memilih path untuk paket pustaka (kita akan gunakan github.com/user/stringutil) dan membuat direktori paket:

$ mkdir $GOPATH/src/github.com/user/stringutil

Selanjutnya, buat sebuah berkas dengan nama reverse.go di dalam direktori tersebut yang berisi:

// Package stringutil berisi fungsi-fungsi untuk bekerja dengan strings.
package stringutil

// Reverse mengembalikan sebuah string yang dibalik dari kanan ke kiri.
func Reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

Sekarang, tes apakah paket tersebut dapat di- compile dengan go build:

$ go build github.com/user/stringutil

Atau, jika sekarang berada dalam direktori sumber paket, tinggal:

$ go build

Perintah tersebut tidak akan membuat berkas apa pun. Namun, ia akan menyimpan paket yang telah terkompilasi di dalam cache internal.

Setelah memastikan paket stringutil dapat dibangun, ubah hello.go (yang ada di $GOPATH/src/github.com/user/hello) untuk menggunakan paket stringutil:

package main

import (
	"fmt"

	"github.com/user/stringutil"
)

func main() {
	fmt.Println(stringutil.Reverse("!oG ,olleH"))
}

Pasang kembali program hello:

$ go install github.com/user/hello

Jalankan versi terbaru dari program tersebut, akan terlihat pesan yang dibalik:

$ hello
Hello, Go!

Setelah mengikuti langkah-langkah di atas, ruang-kerja akan seperti berikut:

bin/
    hello                 # program yang dapat dieksekusi
src/
    github.com/user/
        hello/
            hello.go      # sumber program
        stringutil/
            reverse.go    # sumber paket

Nama paket

Perintah pertama dalam sebuah sumber kode Go haruslah

package name

yang mana name adalah nama untuk paket yang di- import. (Semua berkas di dalam sebuah paket harus menggunakan nama yang sama.)

Konvensi dari Go yaitu nama paket adalah elemen terakhir dari import path: paket yang diimpor dengan "crypto/rot13" seharusnya bernama rot13.

Semua program yang dapat dieksekusi harus menggunakan paket dengan nama main.

Tidak ada keharusan bahwa nama paket harus unik di antara semua paket-paket dalam membuat sebuah program, hanya saja nama import path haruslah unik.

Lihatlah dokumen Efektif Go untuk belajar lebih lanjut tentang konvensi penamaan pada Go.

Pengujian

Go memiliki framework (kerangka) pengujian yang ringan, terdiri dari perintah go test dan paket testing.

Pengujian dibuat dalam sebuah berkas yang berakhiran _test.go yang berisi fungsi-fungsi bernama TestXXX dengan format func TestXxx(t *testing.T). Kerangka tes menjalankan setiap fungsi TestXXX tersebut; Jika fungsi tes memanggil sebuah fungsi perintah kesalahan, seperti t.Error atau t.Fail, maka tes dianggap gagal.

Tambahkan sebuah tes ke paket stringutil dengan membuat berkas $GOPATH/src/github.com/user/stringutil/reverse_test.go yang berisi kode Go berikut.

package stringutil

import "testing"

func TestReverse(t *testing.T) {
	cases := []struct {
		in, want string
	}{
		{"Hello, world", "dlrow ,olleH"},
		{"Hello, 世界", "界世 ,olleH"},
		{"", ""},
	}
	for _, c := range cases {
		got := Reverse(c.in)
		if got != c.want {
			t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want)
		}
	}
}

Kemudian jalankan tes dengan go test:

$ go test github.com/user/stringutil
ok  	github.com/user/stringutil 0.165s

Seperti biasa, jika menjalankan perintah go dari dalam direktori paket, kita bisa mengindahkan path dari paket:

$ go test
ok  	github.com/user/stringutil 0.165s

Jalankan go help test dan lihat dokumentasi dari paket testing untuk belajar lebih lanjut.

Paket eksternal

Sebuah import path mendeskripsikan bagaimana mendapatkan sumber kode dari paket menggunakan sebuah sistem kontrol revisi seperti Git atau Mercurial. Perkakas go menggunakan properti ini untuk secara otomatis mengambil paket dari repositori luar. Misalnya, contoh-contoh yang diuraikan dalam dokumen ini juga tersimpan di dalam sebuah repositori Git pada github.com/golang/example. Jika mengikutkan URL dari repositori pada import path, go get akan mengambil, membuat, dan memasangnya secara otomatis:

$ go get github.com/golang/example/hello
$ $GOPATH/bin/hello
Hello, Go examples!

Jika paket yang disebutkan tidak ada di dalam ruang-kerja, go get akan menyimpannya di dalam ruang-kerja pertama yang diset dalam GOPATH. (Jika paket sudah ada, go get akan melewatkan pengambilan dari luar dan berjalan seperti halnya go install.)

Setelah menjalankan perintah go get di atas, direktori ruang-kerja akan berbentuk seperti berikut:

bin/
    hello                           # program yang bisa dieksekusi
src/
    github.com/golang/example/
        .git/                       # metadata repositori Git
        hello/
            hello.go                # sumber program
        stringutil/
            reverse.go              # sumber paket
            reverse_test.go         # sumber tes
    github.com/user/
        hello/
            hello.go                # sumber program
        stringutil/
            reverse.go              # sumber paket
            reverse_test.go         # sumber tes

Program hello yang disimpan di Github bergantung pada paket stringutil pada repositori yang sama. Import path di dalam berkas hello.go menggunakan konvensi yang sama, sehingga perintah go get dapat menemukan dan memasang paket dependensi.

import "github.com/golang/example/stringutil"

Konvensi ini adalah cara mudah untuk membuat paket Go yang dapat digunakan oleh orang lain. Halaman Go Wiki dan situs godoc.org menyediakan daftar proyek dan paket eksternal dari Go.

Untuk informasi lebih lanjut tentang menggunakan repositori luar dengan perkakas go, lihatlah go help importpath.

Selanjutnya

Ikuti Tur Bahasa Go untuk belajar bahasa Go secara daring.