Efektif Go

Sumber paket Go bertujuan untuk menyediakan tidak hanya pustaka inti tapi juga sebagai contoh bagaimana menggunakan bahasa ini. Lebih lanjut lagi, banyak dari paket-paket tersebut memiliki contoh-contoh kode yang dapat dieksekusi yang dapat dijalankan secara langsung, seperti yang satu ini (jika perlu, klik pada kata "Example" untuk membukanya). Jika ada pertanyaan tentang bagaimana menyelesaikan suatu masalah atau bagaimana mengimplementasikan sesuatu, dokumentasi ini, kode, dan contoh-contoh dalam pustaka dapat menyediakan jawaban, gagasan dan latar belakang yang cukup baik.

Saat sebuah paket diimpor, nama paket menjadi pengakses dari isinya. Setelah

paket yang mengimpor dapat mengakses bytes.Buffer. Sangatlah membantu bila semua penggunaan paket memakai nama yang sama untuk mengacu pada isinya, hal ini menyiratkan bahwa nama paket haruslah bagus: singkat, padat, dan evokatif. Secara konvensi, nama paket menggunakan huruf kecil, dengan satu kata; tidak perlu garis bawah atau mixedCaps. Dan jangan khawatir dengan penamaan yang bentrok. Bila ada nama paket yang bentrok, paket yang mengimpor dapat memilih nama yang berbeda untuk digunakan secara lokal. Pada kasus apapun, kesalahan biasanya jarang terjadi karena nama berkas pada saat impor menentukan paket yang akan digunakan.

Konvensi lainnya yaitu nama paket adalah nama dasar dari direktori sumbernya; paket dalam src/encoding/base64 diimpor sebagai "encoding/base64" namun memiliki nama base64 bukan encoding_base64 dan bukan juga encodingBase64.

Pengimpor dari sebuah paket akan menggunakan nama tersebut untuk mengacu pada isi paket, jadi nama-nama yang diekspor di dalam paket dapat mengacu pada fakta tersebut untuk mencegah kegagapan. Misalnya, tipe reader dengan buffer dalam paket bufio disebut dengan Reader bukan BufReader, karena pengguna melihatnya sebagai bufio.Reader, yang mana namanya lebih bersih dan singkat. Lebih lanjut, karena entitas yang diimpor selalu diacu oleh nama paket, bufio.Reader tidak bentrok dengan io.Reader. Hal yang sama, fungsi yang membuat instansi baru dari ring.Ring  — yang mana merupakan definisi dari sebuah konstruktor dalam Go — biasanya dipanggil dengan NewRing, tapi karena Ring satu-satunya tipe yang diekspor oleh paket tersebut, dan karena paket sudah bernamakan ring, maka ia cukup dipanggil New saja, yang oleh pengguna paket dilihat sebagai ring.New. Gunakan struktur paket yang baik untuk membantu memilih nama yang bagus.

Salah satu contoh lainnya adalah once.Do; once.Do(setup) lebih mudah dibaca dan tidak lebih baik dari menulis once.DoOrWaitUntilDone(setup). Nama yang panjang belum tentu membuatnya lebih gampang dibaca. Sebuah komentar dokumentasi dapat membantu dan lebih bernilai daripada nama yang panjang.

Go tidak menyediakan dukungan otomatis untuk fungsi getter dan setter. Tidak ada yang salah dengan menyediakan fungsi tersebut, terkadang malah lebih pantas, namun secara idiomatis tidak perlu menambahkan Get pada nama getter. Jika kita memiliki sebuah field bernama owner (huruf kecil, tidak diekspor), method getter sebaiknya dipanggil Owner (huruf besar, diekspor), bukan GetOwner. Penggunaan huruf besar untuk nama yang diekspor membantu membedakan antara field dengan method. Fungsi setter, jika diperlukan, biasanya dipanggil dengan SetOwner. Kedua penamaan tersebut secara praktiknya lebih bagus dibaca:

Secara konvensi, interface dengan satu method dinamakan dengan nama method plus akhiran -er atau modifikasi yang mirip dengan pembentukan kata benda bersifat agen: Reader, Writer, Formatter, CloseNotifier, dll.

Ada sejumlah penamaan seperti itu dan akan lebih produktif bila menghargainya dan nama fungsi yang dikandungnya. Read, Write, Close, Flush, String dan seterusnya memiliki penanda dan makna kanonis. Untuk menghindari kekeliruan, jangan namakan method dengan nama tersebut kecuali ia memiliki penanda dan makna yang sama. Sebaliknya, jika tipe mengimplementasikan sebuah method yang memiliki makna yang sama pada method dengan tipe yang umum, berikan nama dan penanda yang sama; beri nama method untuk mengubah sebuah tipe ke string dengan String bukan ToString.

Terakhir, konvensi dalam Go yaitu menggunakan MixedCaps atau mixedCaps untuk penamaan dengan beberapa kata bukan dengan garis bawah.

Dalam Go if yang sederhana itu bentuknya seperti ini:

Wajibnya kurung kurawal mendorong penulisan perintah if menjadi beberapa baris. Gaya penulisan seperti ini sangat bagus, khususnya bila bagian badan kondisi memiliki perintah kontrol seperti return atau break.

Secara if dan switch dapat melakukan perintah inisialisasi, maka sangat umum melihatnya digunakan untuk mendeklarasikan lokal variabel.

Dalam pustaka Go, akan ditemukan bila perintah if tidak mengalir ke perintah selanjutnya—yakni, badan dari kondisi berakhir dengan break, continue, goto, atau return—kondisi else yang tidak berguna dihilangkan.

Ini adalah sebuah contoh situasi umum yang mana kode harus menjaga seurutan kondisi eror. Kode akan mudah dibaca jika kontrol yang sukses terus mengalir ke bawah, mengeliminasi kasus-kasus yang eror saat mereka muncul. Karena kasus yang eror condong berakhir dengan perintah return, maka kode tidak memerlukan perintah else

Contoh terakhir dari bagian sebelumnya memperlihatkan rincian dari bagaimana bentuk deklarasi singkat := bekerja. Deklarasi yang memanggil os.Open berbunyi,

Perintah tersebut mendeklarasikan dua variabel, f dan err. Beberapa baris selanjutnya, panggilan ke f.Stat dibaca,

yang tampak seperti ia mendeklarasikan d dan err. Perhatikan, err muncul dikedua perintah. Duplikasi seperti ini legal: err dideklarasikan oleh perintah pertama, tapi digunakan kembali pada perintah kedua. Ini artinya panggilan ke f.Stat menggunakan variabel err yang sama yang dideklarasikan di atas, dan diberikan nilai yang baru.

Dalam deklarasi sebuah variabel v dengan ":=" , variabel tersebut akan digunakan ulang walaupun telah dideklarasikan, selama:

Properti yang tidak biasa seperti ini murni karena pragmatisme, membuat kita lebih mudah menggunakan nilai tunggal err, sebagai contohnya, dalam beberapa if-else. Anda akan sering melihat penggunaan seperti ini.

§ Perlu diingat di sini, bahwa dalam Go, skop dari parameter fungsi dan nilai kembalian sama dengan badan fungsi, walaupun ia tampak secara leksikal berada di luar kurung kurawal yang menutup badan fungsi.

Pengulangan for pada Go mirip—tapi tidak sama—dengan C. Ia menggabungkan for dan while dan tidak ada for-while. Ada tiga bentuk pengulangan for, hanya satu yang menggunakan titik koma.

Deklarasi singkat membuatnya mudah mendeklarasikan variabel index di dalam pengulangan.

Jika melakukan pengulangan pada array, slice, string, atau map, atau membaca dari sebuah channel, sebuah klausa range dapat digunakan pada pengulangan.

Jika hanya membutuhkan item pertama dalam range (key dari map atau indeks dari array/slice/string), hapus variabel kembalian kedua,

Jika hanya membutuhkan item kedua (nilainya), gunakan pengidentifikasi kosong, sebuah garis bawah, untuk mengindahkan yang pertama:

Pengidentifikasi kosong memiliki banyak kegunaan, seperti yang akan dijelaskan di bagian nanti.

Untuk string, range bekerja lebih, memecah setiap kode poin dari Unicode dengan mengurai UTF-8. Pengkodean yang salah mengkonsumsi satu byte dan menghasilkan rune pengganti U+FFFD. (Nama rune adalah terminologi Go untuk sebuah kode poin Unicode tunggal. Lihat spesifikasi bahasa untuk lebih detilnya.) Pengulangan

mencetak

Terakhir, Go tidak memiliki operator koma dan perintah ` dan `--` bukanlah sebuah ekspresi. Maka, jika ingin menggunakan beberapa variabel dalam sebuah `for`, kita harus menggunakan penempatan paralel (cara ini tidak membolehkan ` dan —).

Kontrol switch pada Go lebih generik daripada C. Ekspresi switch pada Go tidak harus konstan maupun integer, bagian kondisi case dievaluasi dari atas ke bawah sampai ditemukan kondisi yang sesuai, dan jika ekspresi switch tidak memiliki ekspresi, ia akan memeriksa kondisi case yang bernilai true. Oleh karena itu, memungkinkan—dan idiomatis—untuk menulis kondisi if-else-if-else menggunakan switch.

Tidak seperti C, case pada Go tidak otomatis jatuh ke bawah, namun kondisi case bisa lebih dari satu yang dipisahkan dengan koma,

Perintah break pada Go bisa digunakan untuk mengakhiri blok switch. Terkadang, perlu juga untuk keluar dari pengulangan, namun bukan dari switch, dan dalam Go hal ini bisa dilakukan dengan memberi label pada pengulangan dan "keluar" dari label tersebut. Contoh berikut memperlihatkan penggunaan kedua break tersebut.

Tentu saja, perintah continue juga dapat menggunakan label tapi hanya berlaku pada pengulangan.

Untuk mengakhiri bagian ini, berikut fungsi yang membandingkan dua slice byte menggunakan dua perintah switch:

Perintah switch juga bisa digunakan untuk menemukan tipe dinamis dari sebuah variabel interface. Tipe switch seperti ini menggunakan sintaks dengan kata kunci type dalam tanda kurung. Jika perintah switch mendeklarasikan sebuah variabel dalam ekspresinya, variabel tersebut akan memiliki tipe korespondensinya di setiap klausa. Termasuk idiomatis menggunakan nama yang sama dalam kasus ini, efeknya mendeklarasikan variabel baru dengan nama yang sama tapi dengan tipe yang berbeda di setiap case.

Salah satu fitur tidak umum dari Go yaitu fungsi dan method dapat mengembalikan lebih dari satu nilai. Bentuk ini dapat digunakan untuk memperkaya beberapa idiom ceroboh dalam program C: mengembalikan nilai eror, seperti -1 atau EOF, dan mengubah argumen yang dikirim lewat alamat dari variabel (atau dikenal juga dengan pointer).

Pada C, eror dari fungsi write diketahui dari nilai negatif yang dikembalikan dengan kode eror tersimpan terpisah dalam sebuah lokasi yang volatile. Pada Go, Write dapat mengembalikan jumlah tertulis dan eror: "Kita berhasil menulis sejumlah byte tapi tidak semuanya karena perangkat telah penuh". Bentuk method Write terhadap berkas dalam paket os yaitu:

dan seperti yang disebutkan dalam dokumentasi, fungsi tersebut mengembalikan jumlah byte tertulis dan nilai eror non nil bila n != len(b). Bentuk seperti ini sangat umum pada Go; lihat bagian penanganan eror untuk melihat contoh lebih banyak.

Pendekatan ini juga menghilangkan kebutuhan untuk mengirim pointer sebagai nilai kembalian. Berikut sebuah fungsi sederhana untuk memindai sebuah angka dari slice byte, yang mengembalikan angka yang terpindai dan posisi selanjutnya.

Anda bisa menggunakan fungsi tersebut untuk memindai angka dari sebuah input slice b seperti berikut:

Parameter kembalian atau hasil dari sebuah fungsi dapat diberi nama dan dipakai seperti variabel, seperti halnya paramater pada fungsi. Bila diberi nama, ia diinisialisasi dengan nilai kosong dari tipenya saat fungsi dimulai; jika fungsi mengeksekusi perintah return tanpa argumen, nilai terakhir dari parameter kembalian digunakan sebagai nilai kembalian.

Pemberian nama ini bukanlah sebuah keharusan namun dapat membuat kode lebih singkat dan jelas: nama kembalian sebagai dokumentasi. Jika kita beri nama kembalian pada fungsi nextInt maka akan memperjelas makna nilai int yang dikembalikan.

Karena kembalian bernama diinisialisasi dan terikat dengan perintah return, cara ini dapat digunakan untuk mempermudah sebagaimana juga memperjelas kode. Berikut versi dari io.ReadFull yang menggunakan cara ini dengan bagus:

Perintah defer pada Go menangguhkan pemanggilan sebuah fungsi sampai fungsi yang mengeksekusi defer berakhir. Cara ini efektif untuk situasi yang harus menghapus alokasi atau sumber daya. Contoh umum dari penggunaan defer adalah membuka mutex atau menutup berkas.

Menangguhkan pemanggilan sebuah fungsi seperti Close memberikan dua kelebihan. Pertama, akan menjamin bahwa berkas tidak lupa ditutup kembali, sebuah kesalahan yang mudah terjadi jika kita mengubah fungsi untuk menambah sebuah perintah return di bagian manapun. Kedua, penutupan berkas berada dekat dengan pembukaan berkas, yang membuat kode lebih jelas daripada menempatkan penutupan di akhir fungsi.

Argumen dari fungsi atau method yang ditangguhkan dievaluasi saat perintah defer dieksekusi, bukan saat fungsi atau method dieksekusi. Hal ini berarti sebuah perintah defer dapat dieksekusi berulang kali. Berikut contoh sederhana,

Fungsi yang ditangguhkan dieksekusi secara LIFO (Last In First Out—Terakhir Masuk Pertama Keluar), sehingga kode di atas akan mencetak 4 3 2 1 0 saat fungsi berakhir. Contoh penggunaan defer yang lain yaitu melacak eksekusi fungsi, seperti berikut:

Karena argumen dari fungsi yang di- defer dievaluasi saat defer dieksekusi, kita dapat mengeksploitasinya lebih lanjut. Fungsi trace dapat mengatur argumen dari fungsi untrace. Contohnya:

mencetak

Bagi pemrogram yang terbiasa dengan manajemen sumber daya dalam bentuk blok kode dari bahasa pemrograman lain, defer mungkin tampak aneh, namun penerapannya datang dari fakta bahwa ia bukan berbasis-blok tapi berbasis-fungsi. Dalam bagian panic dan recover kita akan melihat contoh lain dari kemampuan defer.

Go memiliki dua fungsi bawaan, primitif untuk alokasi: new dan make. Kedua fungsi tersebut melakukan hal yang berbeda dan berlaku pada tipe yang berbeda, yang bisa membingungkan, tapi aturannya cukup sederhana. Mari kita telaah new terlebih dahulu. Fungsi new digunakan untuk mengalokasikan memory, tapi tidak seperti bahasa lain, ia tidak menginisialisasi memory, hanya mengosongkan saja. new(T) mengalokasikan penyimpanan kosong untuk item bertipe T dan mengembalikan alamatnya, sebuah nilai bertipe *T. Dalam terminologi Go, fungsi new mengembalikan sebuah pointer dari nilai kosong hasil alokasi dari tipe T.

Secara memory yang dikembalikan oleh new dikosongkan, maka sangatlah membantu merancang struktur data sehingga setiap nilai kosong dari tipe dapat digunakan tanpa perlu diinisialisasi. Hal ini berarti pengguna dari struktur data dapat membuatnya dengan new dan langsung menggunakannya. Sebagai contohnya, dokumentasi untuk bytes.Buffer berbunyi "nilai kosong dari Buffer adalah sebuah buffer kosong yang siap digunakan." Hal yang sama, sync.Mutex tidak memiliki eksplisit konstruktor atau method Init. Namun, nilai kosong dari sync.Mutex didefinisikan sebagai mutex yang tidak terkunci.

Properti dari nilai-kosong bekerja secara transitif. Perhatikan deklarasi tipe berikut.

Nilai dari tipe SyncedBuffer siap digunakan langsung setelah alokasi atau deklarasi. Pada contoh kode selanjutnya, p dan v dapat digunakan tanpa memerlukan pengaturan lebih lanjut.

Terkadang nilai kosong tidak cukup dan inisialisasi dengan konstruktor diperlukan, seperti contoh berikut yang diambil dari paket os.

Kode di atas dapat disederhanakan menggunakan inisialisasi komposit, yaitu sebuah ekspresi yang membuat instansi baru dari tipe komposit setiap kali dievaluasi.

Tidak seperti C, dalam Go kita dapat mengembalikan alamat dari variabel lokal; alokasi dari variabel bertahan setelah fungsi berakhir. Malah, mengambil alamat dari inisialisasi komposit akan mengalokasi instansi yang baru setiap kali dievaluasi, sehingga kita dapat menggabungkan dua baris terakhir.

Field dari inisialisasi komposit diset berurutan dan semuanya harus ada. Namun, dengan memberi label pada setiap elemen secara eksplisit dengan cara field:nilai, inisialisasi dapat dibentuk tanpa harus berurutan, dengan field yang tidak dicantumkan akan diberi nilai kosong. Sehingga kita dapat tulis

Jika inisialisasi komposit tidak memiliki field apapun, ia akan otomatis diinisialisasi dengan nilai kosong dari tipenya. Ekspresi new(File) dan &File{} adalah sama.

Inisialisasi komposit juga berlaku pada array, slice, dan map, dengan label pada field adalah indeks atau key dari map. Pada contoh berikut, inisialisasi bekerja sesuai dengan nilai Enone, Eio, dan Einval, selama nilainya berbeda.

Kembali ke alokasi. Fungsi bawaan make(T, args) memiliki fungsi yang berbeda dari new(T). Ia hanya dapat digunakan pada slice, map, dan channel, yang mengembalikan inisialisasi (bukan nilai kosong) dari tipe T (bukan *T). Alasan dari perbedaan ini adalah ketiga tipe tersebut merepresentasikan referensi ke struktur data yang harus diinisialisasi sebelum digunakan. Sebuah slice, sebagai contohnya, adalah sebuah struktur data yang memiliki tiga field internal (yang tidak diekspor), yang terdiri dari sebuah pointer ke data (sebuah array), panjang, dan kapasitas; dan sebelum item-item tersebut diinisialisasi, maka slice bernilai nil. Untuk slice, map, dan channel, make menginisialisasi struktur data internal mereka dan menyiapkan nilainya. Misalnya,

mengalokasikan sebuah array 100 buah int dan membuat sebuah struktur slice dengan panjang 10 dan kapasitas 100, yang menunjuk ke elemen pertama dari 10 elemen dari array. (Saat membuat slice, kapasitasnya bisa diindahkan; lihat bagian tentang slice untuk informasi lebih lanjut.) Kebalikannya, new([]int) mengembalikan sebuah pointer ke struktur slice yang baru dialokasikan dan dikosongkan, yaitu, sebuah pointer ke sebuah slice bernilai nil.

Contoh berikut mengilustrasikan perbedaan antara new dan make.

Ingatlah bahwa make hanya berlaku untuk map, slice, dan channel dan tidak mengembalikan sebuah pointer. Untuk mendapatkan pointer, alokasikan dengan new atau ambil alamat dari variabel secara langsung.

Array berguna saat merancang susunan memory yang lebih rinci dan terkadang membantu menghindari alokasi memory, tapi pada umumnya ia adalah elemen pembentuk dari slice, yang akan kita bahas di bagian berikutnya. Untuk membantu memahami bagian selanjutnya, berikut beberapa penjelasan tentang array.

Ada tiga perbedaan utama untuk array antara Go dan C. Dalam Go,

Properti "array adalah nilai" terkadang bisa berguna namun cukup memakan sumber daya; jika ingin perilaku dan efisiensi seperti C, kita bisa mengirim pointer ke array.

Namun gaya kode seperti ini (pointer ke sebuah array pada argumen dari fungsi) tidak idiomatis pada Go. Lebih baik gunakan slice.

Slice membungkus array untuk memberikan sebuah antar muka yang lebih umum, kuat, dan mudah dari data yang berurutan. Kecuali untuk item-item dengan dimensi yang jelas seperti matriks, umumnya pemrograman array dalam Go menggunakan slice bukan array.

Slice menyimpan referensi dari array yang menjadi dasarnya, dan jika menempatkan sebuah slice ke slice yang lainnya, keduanya akan mengacu pada array yang sama. Jika sebuah fungsi menerima argumen berupa slice, perubahan yang dilakukan terhadap elemen dari slice akan dapat dilihat oleh yang memanggil fungsi, analoginya sama dengan mengirim pointer ke array di dalamnya. Oleh karena itu, sebuah fungsi Read dapat menerima argumen slice bukan pointer dan sebuah hitungan; panjang dari slice menentukan batas atas dari berapa banyak data yang akan dibaca. Berikut method Read dari tipe File dalam packet os:

Method tersebut mengembalikan jumlah byte yang dibaca dan sebuah nilai eror. Untuk membaca 32 byte pertama ke dalam sebuah buffer buf, potong buffer tersebut.

Pemotongan seperti di atas umum dan efisien. Bahkan, lupakan efisiensi untuk sementara, potongan kode berikut juga membaca 32 byte pertama ke dalam buffer.

Panjang dari sebuah slice bisa diubah selama ia masih selaras dengan limit dari array yang dikandungnya. Kapasitas dari slice, dapat diakses dengan fungsi bawaan cap, menandakan panjang maksimum dari slice. Berikut fungsi untuk menambahkan data ke sebuah slice. Jika data melebihi kapasitas, maka slice tersebut akan direalokasikan. Dan hasil dari alokasi baru akan dikembalikan. Fungsi berikut memberitahu bahwa len dan cap bisa digunakan pada slice yang nil, dan nilai kembaliannya adalah 0.

Kita harus mengembalikan slice sesudahnya karena, walaupun Append dapat memodifikasi elemen dari slice, slice itu sendiri (struktur data yang menyimpan pointer, panjang, dan kapasitas) dikirim secara nilai.

Fungsi penambahan terhadap slice ini sangat berguna, ia juga dapat digantikan dengan fungsi bawaan append. Untuk memahami rancangan fungsi di atas, kita membutuhkan sedikit informasi tambahan, jadi kita akan kembali ke fungsi tersebut nanti.

Array dan slice pada Go berdimensi tunggal. Untuk membuat array atau slice dua dimensi (2D), definisikan array-dari-array atau slice-dari-slice, seperti berikut:

Karena slice memiliki variabel panjang, maka memungkinkan setiap bagian dalam slice memiliki panjang yang berbeda. Situasi tersebut sangat umum, seperti pada contoh LinesOfText: setiap baris memiliki panjangnya sendiri-sendiri.

Terkadang perlu juga mengalokasikan slice 2D, situasi seperti ini bisa digunakan saat memindai barisan pixel, misalnya. Ada dua cara untuk menyelesaikan masalah ini. Salah satunya yaitu dengan mengalokasikan setiap slice tersendiri; cara lainnya yaitu dengan mengalokasikan sebuah array yang menunjuk ke setiap slice. Yang mana yang mau digunakan bergantung kepada aplikasi yang dibuat. Jika slice bisa bertambah atau berkurang, maka mereka harus dialokasikan tersendiri untuk menghindari menimpa baris selanjutnya; jika tidak, akan lebih efisien mengkonstruksi objek dengan alokasi tunggal. Sebagai referensi, berikut bentuk dari kedua cara tersebut. Pertama, dengan cara alokasi tersendiri,

Dan cara dengan alokasi tunggal, dipotong menjadi baris,

Map adalah struktur data bawaan yang mudah dan kuat yang mengasosiasikan sebuah tipe (kunci) dengan nilai tipe lainnya (elemen atau nilai). Kunci dari map bisa bertipe apa saja selama operator ekualitas (==) berlaku, seperti integer, float dan bilangan komples, string, pointer, interface (selama tipe dinamis mendukung ekualitas), struct dan array. Slice tidak bisa dipakai sebagai kunci dari map, karena sifat ekualitas tidak terdefinisi pada slice. Seperti slice, map menyimpan referensi ke struktur data di dalamnya. Jika mengirim sebuah map ke sebuah fungsi yang mengubah isi dari map, perubahan tersebut akan dapat dilihat oleh yang memanggil fungsi.

Map dapat dibuat menggunakan sintaks inisialisasi komposit dengan pasangan kunci-nilai yang dipisahkan oleh titik dua, sehingga sangat mudah membuat map dengan inisialisasi.

Menset dan mengambil nilai map secara sintaks mirip dengan array dan slice kecuali indeksnya tidak harus sebuah integer.

Bila kunci dari map tidak ada, ia akan mengembalikan nilai kosong dari tipe nilai dari map. Misalnya, jika map berisi integer, mengambil nilai dari kunci yang tidak ada akan mengembalikan 0. Sebuah pengelompokan dapat diimplementasikan dengan map yang nilainya bertipe bool. Set nilai map dengan true untuk menyimpan sebuah nilai ke dalam kelompok, dan kemudian periksa dengan pengindeksan biasa.

Terkadang perlu membedakan antara nilai yang tidak ada dengan nilai kosong. Apakah ada isi untuk "UTC" atau ia 0 karena tidak ada di dalam map sama sekali? Anda bisa membedakan ini dengan cara kembalian multipel.

Untuk alasan khusus cara ini disebut dengan idiom "comma ok". Pada contoh berikut, jika tz ada, nilai seconds akan di set dan ok akan bernilai true; jika tidak, seconds akan di set dengan 0 dan ok akan bernilai false. Berikut fungsi yang mengimplementasikannya dengan laporan kesalahan:

Untuk menguji keberadaan sebuah nilai dalam map tanpa perlu tahu nilai sebenarnya, kita bisa menggunakan identifikasi kosong (_) di variabel tempat nilai disimpan.

Untuk menghapus sebuah isi map, gunakan fungsi bawaan delete, yang argumennya adalah map dan kunci yang akan dihapus. Cara ini aman bahkan bila kunci tidak ada dalam map.

Pencetakan berformat dalam Go menggunakan gaya yang mirip dengan printf pada C tapi lebih kaya dengan format dan lebih generik. Fungsi pencetakan ada dalam paket fmt: fmt.Printf, fmt.Fprintf, fmt.Sprintf, dan seterusnya. Fungsi string (Sprintf dll.) mengembalikan sebuah string bukan mengisi buffer pada argumen.

Anda tidak perlu menyediakan string yang berformat. Untuk setiap Printf, Fprintf, dan Sprintf ada pasangan fungsi lain, yaitu Print dan Println. Fungsi tersebut tidak menerima string berformat melainkan membangkitkan format standar untuk setiap argumennya. Versi dari Println menyisipkan sebuah spasi antara argumen dan menambahkan baris baru di akhir, sementara versi Print hanya menyisipkan spasi jika argumen dikedua sisi adalah string. Dalam contoh berikut setiap baris perintah menghasilkan keluaran yang sama.

Fungsi berformat fmt.Fprint dan teman-temannya menerima objek apapun yang mengimplementasikan interface io.Writer; Contoh yang paling awam yaitu variabel os.Stdout dan os.Stderr.

Dari sini kita mulai menyimpang dari C. Pertama, format numerik seperti %d tidak menerima tanda ukuran atau tanda signed atau unsigned; namun, fungsi dari pencetakan akan menggunakan tipe dari argumen untuk menentukan properti tersebut.

mencetak

Jika hanya menginginkan konversi standar, seperti desimal untuk integer, kita bisa menggunakan format keseluruhan %v (untuk "value"); hasilnya persis seperti yang Print dan Println akan keluarkan. Lebih lanjut, format tersebut dapat mencetak nilai apapun, bahkan array, slice, struct, dan map. Berikut perintah pencetakan untuk map zona waktu yang didefinisikan pada bagian sebelumnya.

yang mengeluarkan

Untuk map, kuncinya akan dicetak tidak berurutan. Pada struct, format %+v mencetak nama field, dan untuk nilai apapun format %#v akan mencetak nilai dengan sintaks Go.

mencetak

(Perhatikan tanda "&".) Format dengan tanda kutip ganda juga tersedia lewat %q saat digunakan pada tipe string atau []byte. Format %#q akan menggunakan kutip terbalik "” jika memungkinkan. (Format %q juga berlaku untuk integer dan rune, menghasilkan konstanta rune dengan tanda kutip tunggal.) Selain itu, format %x dapat digunakan juga untuk string, array dari byte, dan slice dari byte, sebagaimana juga integer, menghasilkan string dengan heksadesimal, dan bila sebuah spasi ditambahkan dalam format (% x) ia akan mencetak spasi antara byte.

Format berguna lainnya yaitu %T, yang mencetak tipe dari sebuah nilai.

mencetak

Jika ingin mengontrol format untuk sebuah tipe kostum, cukup dengan mendefinisikan sebuah method String() string pada tipe tersebut. Untuk tipe sederhana type T berikut, bentuknya seperti ini.

yang mencetak dengan format

Jika ingin mencetak nilai dari tipe T atau pointer ke T, maka receiver dari String haruslah nilai dari tipe; contoh di atas menggunakan pointer karena ia lebih efisien dan idiomatis untuk tipe dengan struct. Lihat bagian di bawah tentang pointer dan nilai untuk informasi lebih lanjut.

Method String bisa memanggil Sprintf karena fungsi pencetakan secara penuh berdiri sendiri dan bisa dibungkus dengan cara tersebut. Ada hal penting yang harus dipahami mengenai pendekatan ini: jangan membuat method String dengan memanggil Sprintf yang mana akan mengulang method String terus menerus. Hal ini bisa terjadi jika pemanggilan Sprintf mencoba mencetak langsung receiver sebagai sebuah string, yang mana akan memanggil method itu kembali. Hal ini umum dan kesalahan yang mudah terjadi, seperti yang diperlihatkan pada contoh berikut.

Perbaikannya cukup mudah: konversi argumen ke tipe dasar string, yang tidak memiliki method String.

Pada bagian inisialisasi kita akan melihat teknik lain untuk menghindari rekursi ini.

Teknik pencetakan lainnya yaitu dengan mengirim argumen dari fungsi pencetakan langsung ke fungsi lain. Fungsi Printf menggunakan tipe …​interface{} pada argumen terakhirnya untuk dapat menerima beragam jumlah parameter (dari berbagai tipe) yang dapat muncul setelah format.

Dalam fungsi Printf, v berlaku seperti sebuah varibel bertipe []interface{} namun bila dikirim ke fungsi variadic lainnya, ia bersifat sama seperti daftar argumen biasa. Berikut implementasi dari fungsi log.Println yang kita gunakan di atas. Ia mengirim argumennya langsung ke fmt.Sprintln untuk melakukan pemformatan.

Kita menulis …​ setelah v pada pemanggilan ke Sprintln untuk memberi tahu compiler memperlakukan v sebagai daftar argumen; kalau tidak ia akan mengirim v sebagai sebuah slice.

Ada lebih banyak lagi mengenai pencetakan dari yang sudah kita bahas di sini. Lihat dokumentasi godoc pada paket fmt untuk lebih detilnya.

Sebuah parameter …​ bisa spesifik pada tipe tertentu, misalnya …​int pada fungsi Min yang memilih bilang terendah dari sejumlah bilangan integer:

Sekarang kita memiliki pengetahuan yang diperlukan untuk menjelaskan rancangan dari fungsi bawaan append. Fungsi append berbeda dari fungsi bentukan Append di atas. Secara skematis, bentuknya seperti berikut:

yang mana T adalah penampung dari tipe apapun. Anda tidak bisa menulis sebuah fungsi dalam Go yang mana tipe T ditentukan oleh yang memanggil. Itulah kenapa append adalah bawaan: ia butuh dukungan dari compiler.

Yang append lakukan adalah menambahkan elemen-elemen pada akhir dari sebuah slice dan mengembalikan hasilnya. Hasilnya perlu dikembalikan karena, seperti pada fungsi bentukan Append, array yang dikandung oleh slice kemungkinan berubah. Contoh sederhana berikut

mencetak [1 2 3 4 5 6]. Jadi append bekerja mirip seperti Printf, mengoleksi beragam jumlah argumen.

Namun bagaimana bila kita ingin menambahkan slice ke sebuah slice? Mudah: gunakan …​ pada saat pemanggilan, seperti yang kita lakukan pada Output sebelumnya. Potongan kode berikut menghasilkan keluaran yang sama dengan yang di atas.

Tanpa …​, kode tersebut tidak akan bisa di- compile karena tipenya salah; y bukan bertipe int.

Konstan pada Go dibuat pada waktu di- compile (bahkan saat didefinisikan sebagai lokal konstan dalam fungsi), dan hanya berlaku untuk bilangan, karakter (rune), string, atau boolean. Karena batasan dari compile-time tersebut, ekspresi yang mendefinisikan mereka haruslah ekspresi konstan, yang dapat di evaluasi oleh compiler. Misalnya, 1<<3 adalah ekspresi konstan, sementara math.Sin(math.Pi/4) bukan konstan karena pemanggilan fungsi math.Sin harus terjadi pada saat program berjalan.

Pada Go, konstan enumerasi dibuat menggunakan operator iota (disebut juga dengan enumerator). Secara iota merupakan bagian dari ekspresi dan ekspresi secara implisit bisa diulang, maka sangat mudah untuk membuat sekumpulan nilai intrinsik.

Adanya method seperti String yang bisa ditambahkan ke tipe kostum apapun membuatnya memungkinan bagi nilai yang beragam untuk memformat dirinya sendiri untuk pencetakan. Meskipun akan sering melihatnya hanya digunakan pada struct, teknik ini juga berguna untuk tipe skalar seperti tipe floating-point seperti ByteSize.

Ekspresi YB mencetak 1.00YB, sementara ByteSize(1e13) mencetak 9.09TB.

Penggunaan Sprintf untuk mengimplementasikan method String pada ByteSize adalah aman (menghindari rekursif tanpa henti) bukan karena konversi itu sendiri namun karena Sprintf dengan %f, yang mana bukan format dari sebuah string: Sprintf hanya akan memanggil method String saat ia menginginkan sebuah string, dan %f menginginkan nilai floating-point.

Variabel bisa diinisialisasi seperti konstan namun penginisialisasinya bisa sebuah ekspresi generik yang dieksekusi saat program berjalan.

Terakhir, setiap berkas sumber kode bisa mendefinisikan fungsi init -nya sendiri untuk mempersiapkan apapun yang dibutuhkan. (Sebenarnya, setiap berkas bisa memiliki lebih dari satu fungsi init.) Fungsi init dipanggil setelah semua deklarasi variabel dalam paket tersebut telah dievaluasi, dan setelah semua paket yang diimpor telah diinisialisasi.

Selain membuat inisialisasi yang tidak dapat diekspresikan sebagai deklarasi, penggunaan umum dari fungsi init adalah untuk memverifikasi atau memperbaiki keadaan dari program sebelum eksekusi sebenarnya dimulai.

Seperti yang kita lihat pada ByteSize, method dapat didefinisikan untuk tipe apapun (kecuali pointer atau interface); receiver -nya tidak harus sebuah struct.

Pada diskusi mengenai slice di atas, kita menulis sebuah fungsi Append. Kita bisa mendefinisikannya sebagai sebuah method dari slice. Untuk itu, pertama kita mendeklarasikan sebuah tipe bernama yang akan ditambahkan dengan method, dan menjadikan receiver -nya sebagai nilai dari tipe tersebut.

Yang dimaksud dengan receiver dari contoh di atas yaitu slice ByteSlice. Pada contoh tersebut receiver -nya berbentuk receiver dengan nilai, atau singkatnya, receiver nilai.

Cara ini masih membutuhkan method untuk mengembalikan slice yang diperbarui. Kita bisa menghilangkan nilai kembalian dengan mendefinisikan ulang method tersebut dengan menggunakan pointer pada ByteSlice sebagai receiver -nya, sehingga method dapat menimpa slice.

Jika kita mengubah fungsi Append tersebut seperti standar method Write, seperti berikut,

maka tipe *ByteSlice memenuhi interface standar io.Writer. Misalnya, kita dapat mencetak ke dalam ByteSlice.

Kita mengirim alamat dari sebuah ByteSlice karena hanya *ByteSlice yang memenuhi io.Writer. Aturan tentang pointer atau nilai untuk receiver yaitu receiver nilai dapat memanggil method yang dideklarasikan dengan pointer dan nilai, tapi receiver pointer hanya dapat memanggil method yang dideklarasikan sebagai pointer.

Aturan ini ada karena method dengan pointer dapat mengubahi receiver; memanggil method dengan nilai akan menyebabkani method tersebut menerima salinan dari nilai, sehingga perubahan apapun akan diindahkan. Oleh karena itu, bahasa Go tidak membolehkan kesalahan ini. Ada sebuah pengecualian. Saat nilai dapat diambil alamatnya, bahasa Go akan mengurus pemanggilan method dengan pointer dengan menyisipkan operator alamat secara otomatis. Dalam contoh di atas, variabel b dapat diambil alamatnya, sehingga kita dapat memanggil method Write -nya dengan b.Write. Compiler akan mengubahnya menjadi (&b).Write.

Selain itu, gagasan menggunakan Write terhadap sebuah byte slice adalah pusat dari implementasi bytes.Buffer.

Dalam Go, interface menyediakan sebuah cara untuk menentukan perilaku dari sebuah objek: "jika sesuatu dapat melakukan ini, maka ia dapat digunakan di sini." Kita telah melihat beberapa contohnya; pencetakan kostum yang diimplementasikan dengan method String, Fprintf yang dapat membangkitkan keluaran apapun dengan method Write. Interface dengan satu atau dua method sangat umum dalam kode Go, dan biasanya diberikan nama yang diturunkan dari nama method -nya, seperti io.Writer untuk sesuatu yang mengimplementasikan Write.

Sebuah tipe dapat mengimplementasikan banyak interface. Misalnya, sebuah koleksi dapat diurutkan oleh fungsi-fungsi dalam paket sort jika ia mengimplementasikan sort.Interface, yang terdiri dari Len(), Less(i, j int) bool, dan Swap(i, j int), dan ia juga bisa memiliki sebuah fungsi pencetakan tersendiri. Pada contoh berikut Sequence memenuhi kedua interface tersebut.

Method String pada tipe kostum Sequence di atas membuat ulang fungsi Sprint yang dapat bekerja pada slice. (Ia juga memiliki kompleksitas O(N²), yang mana sangat lambat.) Kita dapat mengurangi kode tersebut (dan mempercepatnya) jika kita mengonversi Sequence menjadi []int sebelum memanggil Sprint.

Method di atas adalah contoh lain dari teknik konversi untuk dapat memanggil Sprintf dengan aman dari sebuah method String. Karena kedua tipe (Sequence dan []int) adalah sama (jika kita indahkan nama tipe), maka boleh mengonversi antara mereka. Konversi tidak membuat nilai baru, ia berperilaku seperti nilai yang ada memiliki tipe baru. (Ada beberapa konversi legal lainnya, seperti dari integer ke bilangan float, namun membuat nilai baru).

Adalah sebuah idiom dalam program Go untuk mengonversi tipe dari sebuah ekspresi untuk mengakses sekumpulan method yang berbeda. Sebagai contoh, kita dapat menggunakan tipe sort.IntSlice untuk mengurangi contoh kode menjadi:

Sekarang, daripada membuat Sequence mengimplementasikan beberapa interface (pengurutan dan pencetakan), kita menggunakan kemampuan sebuah item data untuk dikonversi ke beragam tipe (Sequence, sort.IntSlice, dan []int), tiap-tiapnya melakukan bagian kerjanya sendiri. Hal seperti ini jarang biasanya dalam dunia nyata namun efektif.

Switch dengan tipe adalah sebuah bentuk dari konversi: ia mengambil sebuah interface dan, untuk setiap case pada switch, mencoba mengonversinya ke tipe di dalam case tersebut. Jika sebuah interface adalah string, kita ingin nilai string sebenarnya, namun bila ia memiliki method String kita ingin nilai dari pemanggilan method String().

case yang pertama mencari nilai string sebenarnya; case yang kedua mengonversi interface ke dalam interface yang lain. Adalah hal yang biasa menggabungkan tipe seperti di atas.

Bagaimana jika hanya satu tipe yang kita inginkan? Jika kita tahu bahwa nilai dari interface benar-benar string dan kita hanya ingin mengekstraksinya? Hal ini dapat dilakukan dengan switch bertipe dengan satu case, cara lainnya yaitu dengan pernyataan tipe langsung. Pernyataan tipe langsung menerima sebuah nilai interface dan mengekstrak sebuah nilai dari tipe eksplisitnya. Sintaksnya diturunkan dari klausa pembukaan dari switch bertipe, tapi dengan tipe eksplisit bukan dengan kata kunci type:

dan hasilnya adalah nilai baru bertipe statis typeName. Tipe tersebut haruslah tipe nyata yang dipegang oleh interface, atau sebuah tipe interface yang nilainya dapat dikonversi.

Namun bila nilainya bukanlah sebuah string, program akan eror. Untuk mengatasi ini, gunakan idiom "koma, ok" untuk menguji, secara aman, apakah nilainya adalah sebuah string:

Jika pernyataan tipe gagal, str akan tetap ada dan bertipe string, namun nilainya akan kosong (sebuah string kosong).

Sebagai ilustrasi dari kemampuan dari pernyataan tipe langsung, berikut sebuah perintah if-else yang sama dengan switch bertipe seperti contoh pada bagian awal.

Jika sebuah tipe ada hanya untuk mengimplementasikan sebuah interface dan tidak akan memiliki method yang diekspor (selain dari method pada interface) maka tidak perlu mengekspor tipe tersebut. Mengekspor interface saja memperjelas bahwa nilainya tidak memiliki makna selain yang dideskripsikan dalam interface. Ia juga mengurangi perlunya mengulang dokumentasi untuk setiap instansi dari method.

Dalam kasus seperti ini, konstruktor sebaiknya mengembalikan sebuah nilai interface bukan mengimplementasikan tipe. Sebagai contohnya, dalam pustaka crc32.NewIEEE dan adler32.New mengembalikan interface dengan tipe hash.Hash32. Mengganti sebuah algoritma dari CRC-32 ke Adler-32 dalam sebuah program Go membutuhkan hanya perubahan dari pemanggilan konstruksi; sisa kode selebihnya tidak terpengaruh dengan perubahan algoritma.

Pendekatan yang sama membuat algoritma cipher dalam berbagai paket crypto menjadi terpisah dari blok cipher yang mengikatnya. Interface Block dalam paket crypto/cipher menentukan perilaku dari sebuah blok cipher, yang menyediakan enkripsi dari sebuah blok data. Kemudian, secara analogi dengan paket bufio, paket cipher yang mengimplementasikan interface ini dapat digunakan untuk membangun aliran cipher, direpresentasikan oleh interface Stream, tanpa perlu tahu rincian dari blok enkripsinya.

Interface dari crypto/cipher berbentuk seperti berikut:

Berikut definisi dari aliran counter mode (CTR), yang mengubah blok cipher menjadi aliran cipher; perhatikan bahwa detil dari blok cipher diabstraksikan:

NewCTR tidak hanya berlaku untuk algoritma enkripsi dan sumber data tertentu namun untuk semua implementasi dari interface Block dan Stream. Karena ia mengembalikan nilai interface, mengganti enkripsi CTR dengan mode enkripsi lainnya menjadi perubahan dilokal saja. Pemanggilan dari konstruksi haruslah diubah, namun karena kode yang disekelilingnya harus memperlakukan kembalian sebagai sebuah Stream, maka perubahannya tidak terlalu banyak terlihat.

Secara semua tipe kostum dapat memiliki method, maka hampir semuanya memenuhi sebuah interface. Salah satu contohnya adalah dalam paket http, yang mendefinisikan interface Handler. Objek apapun yang mengimplementasikan Handler dapat melayani permintaan HTTP.

ResponseWriter itu sendiri adalah sebuah interface yang menyediakan akses terhadap method yang diperlukan untuk mengembalikan respon kepada klien (HTTP). Method-method tersebut termasuk standar Write, jadi http.ResponseWriter bisa digunakan dimanapun io.Writer dapat digunakan. Request adalah sebuah struct yang berisi representasi hasil penguraian permintaan HTTP dari klien.

Untuk lebih jelas, mari kita indahkan POST dan asumsikan permintaan HTTP selalu GET; penyederhanaan ini tidak mempengaruhi bagaimana handler disiapkan. Berikut implementasi lengkap dari sebuah handler untuk menghitung jumlah sebuah halaman dikunjungi.

(Perhatikan bagaimana Fprintf dapat mencetak ke http.ResponseWriter.) Sebagai referensi, berikut cara menyambungkan sebuah server terhadap sebuah URL.

Tapi kenapa Counter itu adalah sebuah struct? Sebuah integer saja sebenarnya sudah cukup. (receiver haruslah pointer supaya penambahan dapat dilihat oleh pemanggilnya.)

Bagaimana bila program memiliki sebuah keadaan internal yang perlu diberitahu bila sebuah halaman telah dikunjungi? Sambungkan sebuah channel ke halaman web tersebut.

Terakhir, katakanlah kita ingin menampilkan semua argumen yang digunakan saat menjalankan program server dalam halaman yang diakses lewat URL /args. Cukup mudah untuk menulis sebuah fungsi yang mencetak argumen tersebut.

Terus bagaimana cara mengubahnya menjadi sebuah server HTTP? Kita bisa buat ArgServer sebuah method dari tipe yang nilainya kita indahkan, namun ada cara yang lebih bersih. Karena kita dapat mendefinisikan sebuah method untuk semua tipe kecuali pointer dan interface, maka kita dapat menulis sebuah method untuk sebuah fungsi. Paket http memiliki contoh kode seperti ini:

HandlerFunc adalah sebuah tipe dengan sebuah method, ServerHTTP, sehingga nilai dari tipe tersebut dapat melayani permintaan HTTP. Lihat implementasi dari method tersebut: receiver -nya adalah sebuah fungsi, f, dan method -nya memanggil f kembali. Hal ini tampak ganjil tapi tidak ada bedanya dengan, katakanlah, receiver -nya adalah sebuah channel dan method mengirim ke channel tersebut.

Untuk membuat ArgServer menjadi sebuah server HTTP, pertama kita ubah supaya memiliki penanda yang sesuai.

ArgServer sekarang memiliki penanda yang sama dengan HandlerFunc, sehingga ia bisa dikonversi ke tipe tersebut untuk mengakses method -nya, seperti saat kita mengonversi Sequence ke IntSlice untuk mengakses IntSlice.Sort. Kode untuk mengatur semua ini cukup ringkas:

Saat seseorang mengunjungi halaman /args, handler yang terpasang pada halaman tersebut memiliki nilai ArgServer dan bertipe HandlerFunc. Server HTTP akan memanggil method ServeHTTP dalam tipe tersebut, dengan ArgServer sebagai receiver -nya, yang mana akan memanggil ArgServer (lewat f(w, req) di dalam HandlerFunc.ServeHTTP). Argumen dari program nanti akan ditampilkan.

Dalam bagian ini kita telah membuat sebuah server HTTP dari sebuah struct, sebuah integer, sebuah channel, dan sebuah fungsi, semua itu karena interface hanyalah sekumpulan method, yang dapat didefinisikan untuk (hampir) semua tipe.

Penggunaan pengidentifikasi kosong dalam sebuah pengulangan for range adalah kasus khusus dari situasi umum: penempatan multipel.

Jika sebuah penempatan membutuhkan nilai yang banyak pada bagian kiri, namun satu dari nilai tersebut tidak akan digunakan pada program, pengidentifikasi kosong pada bagian kiri penempatan mengabaikan perlunya membuat sebuah variabel dan memperjelas bahwa nilai tersebut diabaikan. Misalnya, saat memanggil sebuah fungsi yang mengembalikan nilai dan eror, namun hanya eror yang diperlukan, gunakan pengidentifikasi kosong untuk mengindahkan nilai yang tidak penting.

Terkadang kita akan melihat kode yang mengabaikan nilai eror; hal ini adalah cara yang tidak bagus. Selalu periksa kembalian eror; mereka ada karena alasan tertentu.

Go akan eror saat mengimpor paket atau mendeklarasikan variabel yang tidak dipakai. Impor yang tidak dipakai akan mengembungkan program dan memperlambat kompilasi, sementara variabel yang diinisialisasi tapi tidak dipakai setidaknya memboroskan komputasi dan bisa saja mengindikasikan sebuah bug yang besar. Saat sebuah program dalam keadaan aktif dikembangkan, variabel dan impor yang tidak dipakai terkadang muncul dan ia terkadang bisa menjengkelkan untuk menghapusnya hanya supaya kompilasi dapat berjalan, namun dibutuhkan lagi nanti. Pengidentifikasi kosong menyediakan solusi untuk masalah ini.

Program setengah-jadi berikut memiliki dua impor tidak dipakai (fmt dan io) dan sebuah variabel tak dipakai (fd), sehingga ia tidak bisa dikompilasi, namun cukup bagus untuk melihat jika kode sejauh ini benar.

Untuk melenyapkan komplain tentang impor tak terpakai, gunakan pengidentifikasi kosong untuk mengacu ke simbol dari paket yang diimpor. Cara yang sama, penempatan pada variabel tak terpakai fd ke pengidentifikasi kosong akan melenyapkan eror dari variabel tak terpakai. Versi program berikut dapat di- compile.

Secara konvensinya, deklarasi global untuk melenyapkan eror pada impor sebaiknya setelah deklarasi import dan diberi komentar, supaya mudah dicari dan sebagai pengingat untuk dibersihkan nantinya.

Impor yang tak terpakai seperti fmt atau io pada contoh sebelumnya seharusnya digunakan lagi kembali atau dihapus: penempatan kosong mengindikasikan kode sedang dikerjakan. Namun terkadang berguna mengimpor paket hanya untuk efek sampingnya, tanpa ada penggunaan eksplisit. Sebagai contohnya, dalam fungsi init, paket net/http/pprof meregistrasi beberapa handler untuk HTTP yang menyediakan informasi untuk melakukan debug. Ia memiliki API yang diekspor, namun kebanyakan klien hanya memerlukan registrasi handler dan akses ke data lewat halaman web. Untuk mengimpor paket hanya untuk efek sampingnya, ubah nama paket menjadi pengidentifikasi kosong:

Bentuk import seperti ini memperjelas bahwa paket diimpor untuk efek sampingnya, karena tidak ada penggunaan langsung dari paket tersebut: dalam berkas ini, ia tidak memiliki sebuah nama. (Jika memiliki nama, dan kita tidak menggunakannya, maka compiler akan menolak program saat di- compile.)

Seperti yang telah kita lihat dalam diskusi tentang interface di atas, sebuah tipe tidak perlu secara eksplisit mendeklarasikan bahwa ia mengimplementasikan sebuah interface. Sebuah tipe dikatakan implementasi dari interface bila ia mengimplementasikan semua method dari interface. Pada praktiknya, konversi dari interface adalah statis dan oleh karena itu diperiksa saat program di- compile. Sebagai contohnya, mengirim *os.File ke sebuah fungsi yang mengharapkan io.Reader tidak akan bisa di- compile kecuali bila *os.File mengimplementasikan interface dari io.Reader.

Beberapa pemeriksaan interface terjadi pada saat program berjalan. Salah satu contohnya yaitu dalam paket encoding/json, yang mendefinisikan sebuah interface Marshaler. Saat encoder dari JSON menerima sebuah nilai yang mengimplementasikan interface tersebut, encoder memanggil method untuk melakukan konversi untuk mengubahnya ke JSON bukan dengan melakukan konversi biasa. encoder memeriksa properti tersebut saat program berjalan dengan pengecekan tipe seperti:

Jika perlu untuk memeriksa apakah sebuah tipe mengimplementasikan sebuah interface, tanpa perlu menggunakan interface itu sendiri, mungkin sebagai bagian dari pemeriksaan eror, gunakan pengidentifikasi kosong untuk mengabaikan nilai yang ditempatkan dari tipe:

Salah satu situasi seperti ini bisa muncul adalah saat diperlukannya jaminan pada paket yang mengimplementasikan tipe bahwa ia benar-benar memenuhi interface. Jika sebuah tipe—sebagai contoh, json.RawMessage—membutuhkan sebuah representasi kostum dari JSON, ia seharusnya mengimplementasikan json.Marshaler, tapi tidak ada konversi statis yang dapat menyebabkan compiler untuk dapat memverifikasi hal ini secara otomatis. Jika tipe secara tidak sengaja gagal memenuhi interface, encoder JSON tetap bekerja, namun tidak akan menggunakan implementasi kostum. Untuk menjamin supaya implementasinya benar, sebuah deklarasi global menggunakan pengidentifikasi kosong dapat digunakan dalam paket:

Dalam deklarasi ini, penempatan mengikutkan sebuah konversi dari *RawMessage ke Marshaler mengharuskan *RawMessage mengimplementasikan Marshaler, dan properti tersebut akan diperiksa saat program dikompilasi. Jika interface dari json.Marshaler berubah, paket ini tidak akan bisa di- compile lagi dan sebagai pemberitahuan bahwa ia perlu diperbarui.

Adanya pengidentifikasi kosong dalam konstruksi di atas mengindikasikan bahwa deklarasi hanya ada untuk pemeriksaan tipe, bukan untuk membuat sebuah variabel. Namun, jangan lakukan hal ini untuk setiap tipe yang memenuhi sebuah interface. Secara konvensi, deklarasi seperti itu hanya digunakan bila tidak ada konversi statis yang ada dalam kode, yang mana biasanya jarang terjadi.

Pemrograman konkuren adalah topik yang luas dan bagian ini khusus untuk menjelaskan cara melakukan pemrograman konkuren hanya untuk Go.

Pemrograman konkuren pada bahasa pemrograman lain menjadi susah dengan peliknya kebutuhan untuk mengimplementasikan akses yang benar untuk variabel yang dibagi. Go menyarankan pendekatan yang berbeda yang mana nilai yang dibagi dikirim lewat channel dan, tidak pernah dibagi dengan eksekusi thread yang lain. Hanya ada satu goroutine yang memiliki akses terhadap nilai dalam satu waktu. Konflik pada data tidak bakal terjadi, secara sengaja. Untuk mendorong cara berpikir seperti ini kita menyederhanakannya menjadi sebuah slogan:

Pendekatan ini bisa berlebihan. Penghitungan referensi lebih baik dilakukan dengan menggunakan mutex dalam sebuah variabel integer, misalnya. Namun dalam pendekatan yang lebih tinggi, menggunakan channel untuk mengontrol akses membuatnya lebih mudah untuk menulis program yang benar dan jelas.

Salah satu cara untuk berpikir dengan model seperti ini yaitu dengan membayangkan program dalam satu thread yang berjalan dalam satu CPU. Ia tidak memerlukan sinkronisasi primitif. Sekarang coba jalankan instansi yang sama; ia juga tidak membutuhkan sinkronisasi. Sekarang buat mereka berkomunikasi; jika komunikasi adalah sebuah sinkronisasi, maka tidak perlu ada lagi sinkronisasi yang lain. Pipeline pada Unix, sebagai contohnya, cocok dengan model ini. Pendekatan konkurensi pada Go berasal dari Communicating Sequential Processes (CSP) pada Hoare, ia juga bisa dilihat sebagai generalisasi tipe pipe pada Unix.

Dinamakan goroutine karena istilah yang ada seperti thread, coroutine, proses, dan lainnya, membawa konotasi yang tidak akurat. Sebuah goroutine memiliki model sederhana: ia adalah sebuah fungsi yang dieksekusi secara bersamaan dengan goroutine lainnya dalam ruang alamat yang sama. Goroutine ringan, membutuhkan tidak lebih dari alokasi dari ruang stack. Dan stack -nya dimulai dari ukuran yang kecil, sehingga ia cukup murah, dan berkembang dengan mengalokasikan (dan melepaskan) penyimpanan pada heap seperlunya.

Goroutine disebar ke berbagai thread pada sistem operasi, sehingga bila salah satu dari mereka diblok, seperti menunggu untuk masukan/keluaran, yang lainnya akan tetap berjalan. Rancangan dari goroutine menyembunyikan kompleksitas dari pembuatan dan manajemen thread.

Untuk menggunakan goroutine, awali pemanggilan fungsi atau method dengan kata kunci go. Saat fungsi atau method selesai, goroutine akan berhenti dengan sendirinya. (Efeknya mirip dengan notasi & pada Unix shell untuk menjalankan sebuah perintah secara terpisah.)

Sebuah fungsi anonim dapat juga dipanggil dengan goroutine.

Dalam Go, fungsi anonim adalah sebuah closure: implementasi harus memastikan variabel yang diacu oleh fungsi tersebut bertahan selama mereka aktif.

Contoh di atas tidak terlalu praktis karena fungsi tidak memiliki cara untuk memberi sinyal pada saat berhenti. Untuk itu, kita membutuhkan channel.

Seperti map, channel dialokasikan dengan make, dan nilai kembaliannya adalah referensi ke struktur data internalnya. Jika sebuah parameter integer diberikan, ia akan menset ukuran buffer dari channel. Nilai bakunya adalah nol, untuk channel tanpa buffer dan bersifat sinkron.

channel tanpa buffer menggabungkan komunikasi (pertukaran sebuah nilai) dengan sinkronisasi—menjamin dua buah kalkulasi (goroutine) berada dalam status yang tetap.

Ada banyak idiom menarik dari penggunaan channel. Berikut salah satunya. Dalam bagian sebelumnya kita melakukan pengurutan dengan proses yang dijalankan terpisah, di belakang. Sebuah channel membolehkan peluncuran goroutine untuk menunggu pengurutan selesai.

Penerima selalu diblok sampai ada data yang diterima. Jika channel tanpa buffer, maka pengirim diblok sampai penerima menerima nilainya. Jika channel memiliki buffer, pengirim diblok hanya sampai nilai telah disalin ke buffer; jika buffer -nya penuh, berarti menunggu sampai penerima setidaknya telah menerima sebuah nilai.

channel dengan buffer dapat digunakan untuk semafor, misalnya untuk membatasi hasil keluaran. Pada contoh berikut, permintaan yang masuk dikirim ke sebuah handle, yang mengirim sebuah nilai ke channel, memproses permintaan, dan kemudian menerima sebuah nilai dari channel untuk menyiapkan semafor bagi konsumer selanjutnya. Kapasitas dari buffer pada channel membatasi jumlah pemanggilan proses secara bersamaan.

Saat sejumlah handler diproses sebanyak MaxOutstanding, handler selanjutnya akan diblok, sampai salah satu handler selesai.

Kode diatas memiliki sebuah masalah: fungsi Serve membuat sebuah goroutine untuk setiap permintaan yang masuk, walaupun dibatasi oleh jumlah MaxOutstanding yang dapat berjalan bersamaan. Akibatnya, program dapat mengkonsumsi sumber daya tanpa batas jika permintaan datang terlalu cepat. Kita dapat mengatasi ini dengan mengubah Serve membatasi pembuatan dari goroutine. Berikut solusinya, namun ia memiliki bug yang akan kita perbaiki lagi nanti:

Bug -nya ada dalam pengulangan for, variabel lokal req pada pengulangan digunakan pada setiap iterasi, sehingga variabel req dibagi dengan setiap goroutine. Hal seperti ini bukanlah yang kita inginkan. Kita harus memastikan bahwa req adalah unik untuk setiap goroutine. Berikut salah satu cara untuk melakukannya, dengan mengirim nilai dari req sebagai argumen dari closure dalam goroutine:

Bandingkan versi ini dengan sebelumnya untuk melihat perbedaan bagaimana closure dideklarasikan dan dijalankan. Solusi lainnya adalah dengan membuat variabel baru dengan nama yang sama, seperti pada contoh berikut:

Tampak ganjil saat menulis

namun hal seperti ini legal dan idiomatis dalam Go. Kita mendapatkan versi variabel yang baru dengan nama yang sama, yang dengan sengaja menutup variabel pada pengulangan secara lokal namun unik untuk setiap goroutine.

Kembali lagi ke permasalahan tentang membuat server tadi, pendekatan lain untuk mengatur sumber daya yaitu dengan menjalankan sejumlah goroutine terhadap handler yang semuanya membaca dari channel permintaan. Jumlah goroutine membatasi jumlah dari pemanggilan proses secara bersamaan. Fungsi Serve berikut menerima sebuah channel yang mana memberitahunya untuk berhenti; setelah meluncurkan goroutine, ia akan berhenti menerima dari channel tersebut.

Salah satu properti penting dari Go yaitu sebuah channel adalah nilai yang bisa dialokasikan dan dikirim seperti nilai lainnya. Penggunaan umum dari properti ini yaitu untuk mengimplementasikan demultiplexing yang paralel dan aman.

Pada contoh sebelumnya, handle menangani permintaan tapi kita tidak mendefinisikan tipe yang ditanganinya. Jika tipe tersebut mengikutkan sebuah channel untuk mengirim balasan, setiap klien memiliki jalurnya sendiri untuk mengirim balasan. Berikut definisi skematis dari tipe Request.

Klien menyediakan sebuah fungsi dan argumennya, berikut dengan sebuah channel di dalam objek permintaan yang akan menerima balasan.

Di sisi server, hanya fungsi penanganannya yang berubah.

Tentu saja banyak yang harus dilakukan untuk membuatnya lebih realistis, namun kode di atas adalah sebuah kerangka untuk sistem RPC dengan batasan, paralel, tanpa diblok; tanpa adanya penggunaan sebuah mutex.

Penerapan lainnya dari gagasan di atas yaitu untuk memparalelkan kalkulasi diantara core pada multipel CPU. Jika kalkulasi dapat dipecah menjadi bagian-bagian yang dapat dieksekusi secara independen, maka ia dapat diparalelkan, dengan sebuah channel untuk memberi sinyal saat bagian tersebut selesai.

Katakanlah kita memiliki sebuah operasi yang mahal untuk dilakukan pada sejumlah besar item, dan nilai dari operasi dari setiap item adalah independen, seperti pada contoh berikut.

Kita luncurkan setiap bagian secara independen di dalam sebuah pengulangan, satu per CPU. Mereka dapat selesai tanpa berurutan; kita cukup hitung sinyal yang selesai dengan menguras channel setelah meluncurkan semua goroutine.

Daripada menggunakan sebuah nilai konstan untuk numCPU, kita dapat menanyakan pada runtime nilai yang sesuai dengan sistem kita. Fungsi runtime.NumCPU mengembalikan jumlah core CPU pada mesin, jadi kita bisa tulis

Ada juga fungsi runtime.GOMAXPROCS, yang melaporkan (atau menset) jumlah core yang dispesifikasikan oleh pengguna untuk membatasi jumlah core yang dapat berjalan secara bersamaan dalam sebuah program Go. Nilai bawaannya yaitu nilai dari runtime.NumCPU namun dapat ditimpa dengan menset variabel lingkungan dengan nama yang sama GOMAXPROCS atau dengan memanggil fungsi tersebut dengan nilai positif. Memanggilnya dengan nilai nol akan mengembalikan nilai yang dikandungnya. Oleh karena itu, untuk menghargai permintaan sumber dari pengguna, kita sebaiknya menulis

Pastikan tidak bingung dengan gagasan dari konkurensi (membentuk sebuah program untuk mengeksekusi komponen-komponen secara independen) dan paralelisme (mengeksekusi kalkulasi dengan paralel untuk efisiensi multipel CPU.) Walaupun fitur konkurensi dari Go dapat mempermudah membentuk komputasi secara paralel, Go adalah bahasa yang konkuren, bukan paralel, dan tidak semua permasalahan paralelisasi cocok dengan model Go. Untuk diskusi mengenai perbedaan dari keduanya, lihat pembicaraan dalam blog berikut.

Perkakas dari pemrograman konkuren dapat membuat pemrograman non-konkuren mudah diekspresikan. Berikut sebuah contoh yang diabstraksikan dari paket RPC. Pengulangan pada klien goroutine menerima data dari beberapa sumber, bisa dari jaringan. Untuk menghindari alokasi dan pelepasan buffer, ia menyimpannya dalam sebuah daftar buffer, dan menggunakan channel dengan buffer untuk merepresentasikannya. Jika channel kosong, sebuah buffer baru dialokasikan. Saat pesan buffer siap digunakan, ia dikirim ke server lewat serverChan.

Pengulangan pada server menerima setiap pesan dari klien, memprosesnya, dan mengembalikan buffer lewat daftar buffer.

Klien mencoba mengambil sebuah buffer dari freeList; jika tidak ada, ia akan mengalokasikan yang baru. Server menaruh b kembali ke freeList kecuali bila daftar buffer telah penuh, maka buffer b akan dibebaskan untuk diklaim oleh garbage collector . (Klausa default pada perintah switch dieksekusi bila tidak ada case yang siap atau bernilai true, artinya perintah select tidak akan pernah diblok.) Implementasi seperti ini membangun sebuah daftar penampung yang lepas hanya dengan beberapa baris kode, yang bergantung pada channel dengan buffer dan garbage collector.

Cara yang umum untuk melaporkan sebuah eror ke pemanggilnya adalah dengan mengembalikan sebuah error sebagai nilai kembalian tambahan. Method Read adalah salah satu contohnya; ia mengembalikan jumlah byte dan error. Namun bagaimana jika eror tidak bisa ditangani? Terkadang program sebaiknya tidak dilanjutkan (dipaksa berhenti saat itu juga).

Untuk tujuan ini, ada fungsi bawaan panic yang efeknya membuat sebuah eror run-time yang akan menghentikan program (namun lihat juga seksi berikutnya). Fungsi panic menerima sebuah argumen bertipe apapun—biasanya string—untuk dicetak saat program mati. Cara ini untuk mengindikasikan bahwa sesuatu yang tidak diharapkan terjadi, seperti keluar dari pengulangan tanpa batas.

Kode di atas hanyalah contoh namun fungsi-fungsi dalam sebuah pustaka seharusnya tidak menggunakan panic. Jika kesalahan dapat ditutupi atau diperbaiki, akan lebih baik untuk dilanjutkan daripada menghentikan seluruh program. Salah satu contohnya yaitu saat inisialisasi: jika sebuah pustaka tidak dapat menset dirinya sendiri, maka masuk akal untuk panic.

Saat panic dipanggil, misalnya karena adanya kesalahan akses indeks pada slice atau kegagalan saat melakukan konversi tipe, Go runtime langsung menyetop eksekusi dari fungsi dan mulai memutar ulang stack dari goroutine, dan menjalankan fungsi-fungsi yang ditunda dengan defer disaat bersamaan. Jika proses pemutaran ulang mencapai tingkat paling atas dari stack goroutine, program akan mati. Namun, memungkinan menggunakan fungsi bawaan recover untuk mengambil kontrol dari goroutine dan mengulangi eksekusi secara normal.

Pemanggilan recover menyetop pemutaran ulang dan mengembalikan argumen yang dikirim saat pemanggilan panic. Secara kode yang berjalan selama proses pemutaran ulang adalah fungsi-fungsi yang di- defer, recover hanya berguna dalam fungsi yang di- defer.

Salah satu penerapan dari recover yaitu menutup goroutine yang gagal di dalam sebuah server tanpa menghentikan goroutine lain yang sedang dieksekusi.

Pada contoh ini, jika do(work) ternyata panic, kembaliannya akan dicatat dan goroutine akan keluar dengan bersih tanpa mengganggu yang lainnya. Tidak perlu melakukan hal lain dalam closure yang di- defer; memanggil recover akan menangani kondisi tersebut sepenuhnya.

Karena recover selalu mengembalikan nil kecuali dipanggil langsung dari fungsi yang di- defer, kode yang di- defer dapat memanggil fungsi pustaka yang di dalamnya juga menggunakan panic dan recover tanpa gagal. Sebagai contoh, fungsi defer pada safelyDo bisa saja memanggil fungsi pencatatan log.Println sebelum memanggil recover, dan kode pencatatan tersebut akan berjalan tanpa dipengaruhi oleh keadaan yang panic.

Dengan pola pemulihan seperti ini, fungsi do (dan apapun yang dipanggilnya) dapat keluar dari situasi yang buruk dengan bersih dengan memanggil panic. Kita dapat menggunakan pola ini untuk menyederhanakan penanganan eror dalam sebuah perangkat lunak yang kompleks. Mari kita lihat versi ideal dari sebuah paket regexp, yang melaporkan eror penguraian dengan memanggil panic dengan tipe eror lokal. Berikut definisi dari Error, sebuah method error, dan fungsi Compile.

jika doParse panik, blok pemulihan akan menset nilai kembalian menjadi nil—fungsi yang di- defer dapat mengubah nilai kembalian bernama. Ia kemudian akan memeriksa, pada saat penempatan ke err, bahwa permasalahannya adalah eror penguraian dengan mengkonversi ke tipe Error lokal. Jika konversi tipe gagal err = e.(Error), menyebabkan eror run-time yang melanjutkan pemutaran ulang stack. Pemeriksaan ini artinya jika sesuatu yang tidak diharapkan terjadi, seperti pengaksesan indeks di luar batas, kode tersebut akan tetap panik walaupun kita menggunakan panic dan recover untuk menangani eror pada saat penguraian.

Dengan adanya penanganan eror, method error (karena ia adalah sebuah method yang terikat ke sebuah tipe, maka ia dibolehkan memiliki nama yang sama dengan tipe error bawaan) mempermudah melaporkan eror penguraian tanpa khawatir pada proses pemutaran ulang pada stack:

Pola seperti ini sebaiknya digunakan hanya dalam sebuah paket. Parse mengubah pemanggilan internal panic -nya menjadi nilai error; ia tidak mengekspos panik ke klien. Hal tersebut adalah sebuah aturan yang bagus untuk diikuti.

Idiom dari re- panic ini mengubah nilai panic jika eror sebenarnya terjadi. Namun, kedua kesalahan yang asli dan baru akan tetap tercatat dalam laporan crash, sehingga akar penyebab dari permasalahan akan tetap dapat dilihat. Maka pendekatan sederhana dari re- panic biasanya cukup efisien—ia sebenarnya sebuah crash—tapi jika kita hanya ingin menampilkan nilai aslinya, kita dapat menulis sedikit kode tambahan untuk memfilter permasalahan yang tidak terduga dan mengulang panic dengan nilai error aslinya. Hal ini merupakan latihan bagi pembaca.