Spesifikasi Bahasa Pemrograman Go

Spesifikasi sintaksis menggunakan Extended Backus-Naur Form (EBNF):

Production adalah ekspresi yang dibangun dari sekumpulan term dan operator pendukung berikut, secara berurut:

Nama production_name dengan huruf kecil digunakan untuk mengidentifikasi token leksikal. production_name dengan CamelCase adalah non-terminal (tidak berakhir). Token leksikal dibungkus dalam tanda kutip ganda " " atau kutip terbalik .

Bentuk a … b merepresentasikan kumpulan huruf alternatif dari a sampai b. Elipsis horizontal … juga digunakan dalam spesifikasi ini untuk secara informal menandakan enumerasi atau kode yang dipotong. Karakter … (berlawanan dengan tiga karakter …​) bukanlah token dari bahasa Go.

Istilah berikut digunakan untuk menandakan kelas karakter Unicode tertentu:

The Unicode Standard 8.0, Bagian 4.5 "General Category" mendefinisikan sekumpulan kategori karakter. Go mengenali semua karakter dalam kategori Letter berikut Lu, Ll, Lt, Lm, atau Lo sebagai huruf Unicode, dan yang berada dalam kategori Number Nd sebagai angka Unicode.

Karakter garis bawah _ (U+005F) dianggap sebagai huruf.

Komentar berfungsi sebagai dokumentasi program. Ada dua bentuk komentar:

Komentar tidak boleh dimulai dalam sebuah rune atau string, atau di dalam komentar yang lain. Komentar umum tanpa baris baru berarti memiliki sebuah spasi. Komentar lainnya akan diartikan berada pada baris baru.

Token-token membentuk kosakata dari bahasa Go. Ada empat kelas token: identifiers (pengidentifikasi), keywords (kata-kunci), operators dan punctuation (operator dan tanda baca), dan literal (literal). Karakter kosong yang dibentuk dari spasi (U+0020), tab horizontal (U+0009), carriage returns (U+0009), dan baris baru (U+000A), diindahkan kecuali ia memisahkan token-token yang bila digabungkan menjadi sebuah token. Juga, sebuah baris baru atau akhir dari berkas bisa memicu titik-koma. Saat memecah input menjadi token-token, token selanjutnya adalah urutan karakter terpanjang yang membentuk sebuah token yang valid.

Tata-bahasa formal menggunakan titik-koma ";" sebagai penanda akhir pada beberapa pernyataan. Program Go bisa menghilangkan titik-koma tersebut menggunakan dua aturan berikut:

Untuk merefleksikan penggunaan idiomatis, contoh kode dalam dokumen ini tidak menggunakan titik-koma menggunakan aturan di atas.

Pengidentifikasi memberi nama entitas seperti variabel dan tipe. Sebuah pengidentifikasi adalah sebuah urutan satu atau lebih huruf dan angka. Karakter pertama dalam sebuah pengidentifikasi haruslah huruf.

Beberapa pengidentifikasi telah dideklarasikan sebelumnya.

Kata kunci berikut telah disiapkan dan tidak bisa digunakan sebagai pengidentifikasi:

Urutan karakter berikut merepresentasikan operator (termasuk operator penempatan) dan tanda baca:

Literal integer adalah urutan angka merepresentasikan sebuah konstan integer. Beberapa opsi prefiks menyatakan basis non-desimal: 0 untuk oktal, 0x atau 0x untuk heksadesimal. Dalam literal heksadesimal, huruf a-f dan A-F merepresentasikan nilai antara 10 sampai 155.

Literal floating-point adalah representasi desimal dari konstan floating-point. Ia memiliki bagian integer, titik desimal, bagian pecahan, dan bagian eksponen. Bagian integer dan pecahan terdiri dari angka desimal; bagian eksponen yaitu e atau E diikuti dengan nilai eksponen. Salah satu bagian integer atau pecahan bisa diindahkan; salah satu bagian pecahan atau eksponen bisa diindahkan juga.

Literal imajiner merepresentasikan bagian imajiner dari konstan kompleks. Ia terdiri dari literal integer atau floating-point diikuti oleh huruf kecil i. Nilai dari literal imajiner yaitu nilai dari literal integer atau floating-point dikalikan dengan unit imajiner i.

Untuk kompatibilitas, bagian integer dari literal imajiner yang semuanya terdiri dari angka desimal (dan kemungkinan garis bawah) dianggap sebagai integer desimal, walaupun dimulai dengan 0.

Literal rune merepresentasikan sebuah konstan rune, sebuah nilai integer yang mengidentifikasi sebuah kode poin Unicode. Literal rune diekspresikan dengan satu atau lebih karakter yang ditutup dengan tanda kutip tunggal, seperti ’x’` atau ’n'`. Di dalam tanda kutip tersebut, karakter apa pun dapat ditulis kecuali baris baru dan tanda kutip tunggal itu sendiri. Sebuah karakter dengan kutip merepresentasikan nilai Unicode dari karakter itu sendiri, sementara seurutan karakter yang dimulai dengan garis miring terbalik (backslash) akan ditulis nilainya menjadi beragam format.

Bentuk sederhana dari rune merepresentasikan karakter tunggal antara tanda kutip; secara teks sumber kode dari Go adalah karakter Unicode yang ditulis dalam UTF-8, multipel UTF-8 byte bisa merepresentasikan sebuah nilai integer. Misalnya, literal ’a’` menyimpan sebuah byte yang merepresentasikan sebuah literal a, Unicode U+0061, dengan nilai 0x61; sementara ’ä'` menyimpan dua byte (0xc3 0xa4) yang merepresentasikan literal a-dwititik, U+00E4, nilai 0xe4.

Beberapa backslash membolehkan nilai beragam ditulis sebagai teks ASCII. Ada empat cara untuk merepresentasikan nilai integer sebagai konstan numerik: `x` diikuti dengan dua digit heksadesimal; `u` diikuti dengan empat digit heksadesimal; `U` diikuti dengan delapan heksadesimal, dan backslash kosong `` diikuti dengan tiga digit oktal. Pada setiap kasus tersebut nilai dari literal adalah nilai yang direpresentasikan oleh digit pada basis yang berhubungan.

Walaupun representasi tersebut semua hasilnya adalah sebuah integer, mereka memiliki rentang yang berbeda. Oktal harus merepresentasikan sebuah nilai antara 0 dan 255 secara inklusif. Heksadesimal memenuhi kondisi ini secara konstruksi. u` dan `U` merepresentasikan kode poin Unicode sehingga beberapa nilai adalah ilegal, khususnya nilai di atas `0x10FFFF dan surrogate half (bagian setengah atas dari empat heksadesimal).

Setelah tanda backslash, beberapa karakter tunggal merepresentasikan nilai spesial:

Urutan karakter lain yang dimulai dengan sebuah backslash adalah ilegal di dalam literal rune.

Literal string merepresentasikan konstan string yang didapat dari menggabungkan seurutan karakter-karakter. Ada dua bentuk string: literal string mentah dan literal string interpretasi.

Literal string mentah yaitu seurutan karakter antara kutip terbalik (aksen nontirus), seperti dalam foo . Di antara tanda kutip terbalik, karakter apa pun dapat muncul kecuali tanda kutip terbalik itu sendiri. Nilai dari literal string mentah tersebut yaitu string yang terdiri dari karakter-karakter yang tidak diinterpretasi (implisit UTF-8) di antara tanda kutip; pada khususnya, backslash tidak berfungsi dan string bisa memiliki baris baru. Karakter carriage return (’r'`) di dalam literal string mentah diindahkan dari nilai string mentah.

Literal string interpretasi yaitu seurutan karakter antara tanda kutip ganda, seperti dalam”bar". Di antara tanda kutip, karakter apa pun bisa muncul kecuali baris baru dan tanda kutip ganda lepas (tanpa backslash). Teks antara tanda kutip membentuk nilai dari literal, dengan backslash diartikan seperti halnya dalam literal rune (kecuali `' adalah ilegal dan " adalah legal), dengan batasan-batasan yang sama. Tiga-digit oktal (nnn_) dan dua-digit heksadesimal (x_nn) merepresentasikan byte individu dari string; karakter lepas lainnya merepresentasikan encoding UTF-8 (bisa jadi multi-byte) dari karakter-karakter tersebut. Maka di dalam literal string, 377` dan `xFF` merepresentasikan nilai `0xFF=255, sementara ÿ, `u00FF`, `U000000FF` dan `xc3\xbf merepresentasikan dua byte 0xc3 0xbf dari encoding karakter UTF-8 U+00FF.

Contoh berikut merepresentasikan string yang sama:

Jika sumber kode merepresentasikan sebuah karakter sebagai dua kode poin, seperti sebuah gabungan bentuk mengikutkan aksen dan sebuah huruf, hasilnya akan eror jika ditempatkan dalam sebuah literal rune (karena bukanlah kode poin tunggal), dan akan muncul sebagai dua kode poin jika ditempatkan dalam literal string.

Sebuah tipe bisa memiliki sekumpulan method. Kumpulan method dari tipe interface yaitu interface-nya sendiri. Kumpulan method dari tipe T terdiri dari semua method-method yang dideklarasikan pada penerima (receiver) tipe T. Kumpulan method dari tipe pointer *T yaitu semua method yang dideklarasikan dengan penerima *T atau T (ia berisi juga kumpulan method dari T). Aturan yang sama juga berlaku untuk struct yang berisi field-field yang ditanam (embed), seperti yang dijelaskan dalam bagian tipe struct. Tipe apa pun memiliki kumpulan method kosong. Di dalam sebuah kumpulan method, setiap method harus memiliki nama method yang unik dan tidak kosong.

Kumpulan method dari sebuah tipe menentukan interface yang diimplementasi oleh tipe tersebut dan method tersebut bisa dipanggil menggunakan penerima dari tipe tersebut.

Sebuah tipe boolean merepresentasikan kumpulan nilai Boolean yang dilambangkan oleh konstan true dan false. Tipe boolean dikenal sebagai bool; ia adalah tipe terdefinisi.

Tipe numerik merepresentasikan kumpulan nilai integer atau floating-point. Deklarasi dari tipe numerik, yang bergantung pada arsitektur, yaitu:

Nilai dari n-bit integer yaitu n bit lebarnya dan direpresentasikan menggunakan aritmetika komplemen ganda.

Ada juga kumpulan tipe numerik yang ukurannya tergantung pada arsitektur:

Untuk menghindari masalah portabilitas semua tipe numerik adalah tipe terdefinisi dan makanya berbeda kecuali byte, yang merupakan alias dari uint8, dan rune, yang merupakan alias untuk uint32. Konversi eksplisit dibutuhkan saat tipe numerik berbeda bertemu pada sebuah ekspresi atau pernyataan. Misalnya, int32 dan int bukanlah tipe yang sama walaupun keduanya berukuran sama pada arsitektur tertentu.

Tipe string merepresentasikan kumpulan nilai string. Nilai sebuah string yaitu (bisa kosong) urutan dari byte. Jumlah byte disebut juga panjang dari string dan tidak pernah negatif. String adalah immutable (tetap): sekali dibuat, maka tidak akan bisa lagi diubah isinya. Tipe string yaitu string; ia adalah tipe terdefinisi.

Panjang dari string s dapat diketahui lewat fungsi bawaan len. Panjangnya akan konstan bila string tersebut adalah konstan. Isi byte dari string dapat diakses dengan indeks 0 sampai len(s)-1. Mengambil alamat byte pada string adalah ilegal; jika s[i] adalah byte ke i dari string, maka &s[i] tidak valid.

Sebuah array yaitu urutan elemen dari sebuah tipe yang jumlahnya tetap. Jumlah dari elemen disebut juga dengan panjang array dan tidak pernah negatif.

Panjang array adalah bagian dari tipe array; Ia harus berupa konstanta non-negatif yang direpresentasikan oleh nilai bertipe int. Panjang dari array a dapat diketahui dengan fungsi bawaan len. Setiap elemen array dapat diakses lewat indeks 0 sampai len(a)-1. Tipe array selalu satu dimensi namun bisa digabung untuk membentuk tipe multi-dimensi.

Sebuah slice adalah penampung dari segmen bersambungan dari sebuah array dasar dan menyediakan akses ke elemen dari array tersebut. Sebuah tipe slice menandakan kumpulan dari semua bagian dari array dari tipe elemennya. Jumlah elemen disebut dengan panjang slice dan tidak pernah negatif. Nilai dari slice yang tidak diinisiasi yaitu nil.

Panjang dari slice diketahui lewat fungsi bawaan len; tidak seperti array ia bisa berubah selama eksekusi. Elemen slice bisa diakses lewat integer indeks 0 sampai len(s)-1. Indeks slice dari elemen bisa kecil dari indeks dari elemen yang sama di array dasarnya.

Sebuah slice, setelah diinisiasi, selalu berasosiasi dengan array dasar yang menyimpan elemen-elemennya. Oleh karena itu sebuah slice berbagi tempat penyimpanan dengan array-nya dan dengan slice lain dari array yang sama; sebaliknya, array yang berbeda merepresentasikan tempat penyimpanan yang berbeda.

Array yang mendasari sebuah slice bisa diperlebar melebihi akhir dari slice. Konsep ini dikenal dengan kapasitas: ia adalah jumlah panjang dari slice dan panjang dari array-dasar slice; Sebuah slice yang panjangnya lebih dari kapasitas bisa dibuat dengan slicing (memotong) yang baru dari slice asli. Kapasitas dari slice a dapat diketahui menggunakan fungsi bawaan `cap(a)`.

Slice baru bertipe T dapat diinisiasi menggunakan fungsi bawaan make, yang menerima tipe slice dan parameter yang menentukan panjang, dan opsi kapasitas. Sebuah slice yang dibuat dengan make selalu mengalokasikan array yang baru yang diacu oleh slice yang dikembalikan. Sehingga, mengeksekusi

menghasilkan slice yang sama seperti membuat array dan memotongnya, sehingga dua ekspresi berikut adalah sama:

Seperti halnya array, slice selalu satu-dimensi namun bisa bergabung membentuk objek dengan dimensi lebih tinggi. Lewat array dari array, array di dalamnya, selalu memiliki panjang yang sama; namun dengan slice dari slice (atau array dari slice), panjang di dalamnya bisa beragam secara dinamis. Lebih lanjut, slice paling dalam harus diinisiasi secara sendiri-sendiri.

Sebuah struct yaitu urutan dari elemen bernama, disebut field, tiap-tiap field memiliki nama dan tipe. Nama field bisa secara eksplisit (IdentifierList) atau secara implisit (EmbeddedField). Dalam sebuah struct, nama field yang tidak kosong haruslah unik.

Field dengan tipe namun tanpa nama disebut dengan field tertanam. Field tertanam haruslah tipe bernama T atau sebagai pointer ke tipe bernama yang bukan interface *T, dan T itu sendiri bisa saja bukan tipe pointer. Nama tipe pada field tertanam berlaku sebagai nama field.

Deklarasi berikut ilegal karena nama field harus unik dalam sebuah tipe struct:

Sebuah field atau method f dari field tertanam dalam sebuah struct x disebut dipromosikan jika x.f adalah selektor yang legal yang menandakan field atau method f tersebut.

Field yang dipromosikan berlaku seperti field biasa kecuali ia tidak bisa digunakan sebagai nama field di dalam literal komposit dari struct.

Diberikan sebuah tipe struct S dan tipe terdefinisi T, method-method yang dipromosikan yang masuk ke dalam kumpulan method dari struct S yaitu:

Deklarasi field bisa ditambah dengan literal string tag, yang menjadi atribut dari field. Tag kosong berarti tidak ada tag. Tag bisa diakses lewat interface refleksi dan ambil bagian dalam identitas tipe dari struct.

Tipe pointer menandakan kumpulan semua pointer terhadap variabel dari tipe yang diberikan, disebut juga dengan tipe dasar dari pointer. Nilai dari pointer yang tidak diinisiasi adalah nil.

Tipe fungsi menandakan kumpulan semua fungsi dengan tipe parameter dan kembalian yang sama. Nilai dari variabel bertipe fungsi yang tidak diinisiasi yaitu nil.

Dalam parameter atau kembalian, nama (IdentifierList) haruslah ada atau tidak ada sama sekali. Jika ada, setiap nama mengacu untuk satu item (parameter atau kembalian) dari tipe dan semua nama haruslah unik. Jika tanpa nama, setiap tipe merepresentasikan satu item untuk tipe tersebut. Daftar parameter dan kembalian selalu dalam tanda kurung kecuali pada kembalian tunggal tanpa nama, ia bisa ditulis tanpa tanda kurung.

Parameter terakhir dalam penanda fungsi bisa memiliki tipe yang dimulai dengan "…​" . Fungsi dengan parameter tersebut disebut variadic dan bisa dipanggil tanpa atau lebih argumen dengan tipe yang sama.

Tipe interface menspesifikasikan sekumpulan method yang disebut dengan interface. Sebuah variabel bertipe interface dapat menyimpan tipe apa pun asalkan memiliki kumpulan method yang dimiliki oleh interface tersebut. Tipe tersebut dikatakan mengimplementasikan interface. Nilai dari variabel interface yang tidak diinisiasi adalah nil.

Sebuah tipe interface bisa menspesifikasikan beberapa method secara eksplisit lewat spesifikasi method, atau ia bisa menanam method-method dari interface yang lain lewat nama tipe interface.

Nama dari setiap method yang secara eksplisit dispesifikasikan haruslah unik dan tidak kosong.

Satu atau lebih tipe yang berbeda dapat mengimplementasikan sebuah interface. Misalnya, jika dua tipe S1 dan S2 memiliki sekumpulan method

(yang mana T bisa S1 atau S2) maka interface File dikatakan diimplementasikan oleh S1 dan S2, walaupun S1 dan S2 bisa saja punya method yang lain.

Sebuah tipe bisa mengimplementasikan satu atau lebih interface yang berbeda. Misalnya, semua tipe mengimplementasikan interface kosong:

Hal yang sama, pada spesifikasi interface berikut, yang muncul dalam deklarasi tipe yang mendefinisikan sebuah interface bernama Locker:

Jika S1 dan S2 juga mengimplementasikan

maka mereka juga mengimplementasikan interface Locker dan juga interface File.

Sebuah interface T bisa menanam tipe interface bernama E. Hal ini disebut penanaman interface E dalam T. Kumpulan method dari T adalah gabungan dari kumpulan method T yang secara eksplisit dan interface-interface yang tertanam pada T.

Gabungan dari kumpulan method berisi method-method (yang diekspor atau tidak diekspor) yang mana setiap method di set sekali saja, dan method-method dengan nama yang sama haruslah memiliki penanda yang identik.

Interface bertipe T tidak bisa secara rekursif menanam dirinya sendiri atau interface lain yang menanam T.

Sebuah map adalah gabungan tak urut dari elemen dari satu tipe, yang disebut tipe elemen, yang memiliki indeks berupa sekumpulan key unik dari tipe lainnya, disebut tipe key. Nilai dari map yang tidak diinisiasi yaitu nil.

Operator pembanding == dan != haruslah terdefinisi untuk operan dari tipe key; oleh karena itu tipe key tidak bisa berupa fungsi, map, atau slice. Jika tipe key adalah sebuah tipe interface, maka operator pembanding harus terdefinisi untuk nilai key dinamis; jika tidak akan menyebabkan run-time panic.

Jumlah elemen map disebut panjang. Untuk map m, jumlahnya bisa diambil dengan fungsi bawaan len dan ia bisa berubah selama eksekusi. Elemen bisa ditambah selama eksekusi menggunakan penempatan dan diambil dengan ekspresi indeks; dan elemen bisa dihapus dengan fungsi bawaan delete.

Nilai map yang baru dan kosong dibuat dengan fungsi bawaan make, yang menerima tipe map dan kapasitas opsional sebagai argumen:

Kapasitas awal tidak ada batas ukurannya: map berkembang untuk mengakomodasi sejumlah item yang disimpannya, kecuali pada map yang nil. Map yang nil sama dengan map kosong kecuali ia tidak bisa ditambahkan dengan elemen.

Sebuah channel menyediakan sebuah mekanisme untuk mengeksekusi fungsi secara konkuren untuk berkomunikasi dengan mengirim dan menerima nilai dari tipe elemen yang ditentukan. Nilai dari channel yang tidak diinisiasi yaitu nil.

Operator opsional ← menspesifikasikan arah channel, kirim atau terima. Jika tidak ada arah yang diberikan, maka channel adalah bidirectional (dua arah). Sebuah channel bisa dibatasi hanya untuk mengirim atau menerima saja dengan penempatan atau konversi eksplisit.

Operator ← berhubungan dengan chan yang paling kiri:

Inisiasi nilai channel yang baru bisa dibuat dengan fungsi bawaan make yang menerima tipe channel dan kapasitas opsional sebagai argumen:

Kapasitas, atau jumlah elemen, mengatur ukuran buffer dalam channel. Jika kapasitasnya kosong atau tidak ada, channel adalah tanpa buffer dan komunikasi akan sukses saat pengirim dan penerima telah siap. Sebaliknya, bila kapasitas tidak kosong, maka channel adalah ber-buffer dan komunikasi akan sukses tanpa ditahan jika buffer tidak penuh (mengirim) atau tidak kosong (menerima). Channel yang nil tidak akan pernah bisa berkomunikasi.

Channel bisa ditutup dengan fungsi bawaan close. Bentuk penempatan banyak-nilai dari operator penerima melaporkan apakah nilai yang diterima dikirim sebelum channel ditutup.

Sebuah channel bisa digunakan untuk mengirim, menerima, dan memanggil fungsi bawaan cap dan len oleh sejumlah goroutine berbeda tanpa perlu sinkronisasi. Channel bersifat antrean first-in-first-out (yang pertama masuk, yang pertama keluar). Misalnya, jika sebuah goroutine mengirim nilai ke channel dan goroutine kedua menerimanya, nilai diterima sesuai urutan yang dikirim.

Dua buah tipe akan identik atau berbeda.

Tipe terdefinisi selalu berbeda dengan tipe lainnya. Sebaliknya, dua tipe adalah identik jika tipe dasar mereka secara struktural sama; yaitu, memiliki struktur literal yang sama dan komponen yang berhubungan memiliki tipe yang sama. Secara lebih rinci:

Diberikan deklarasi berikut,

tipe-tipe berikut adalah identik:

B0 dan B1 berbeda karena mereka adalah tipe baru yang dibuat dengan definisi tipe yang berbeda; func(int, float64) *B0 dan func(x int, y float64) *[]string adalah berbeda karena B0 berbeda dari []string.

Sebuah nilai x bisa ditempatkan ke sebuah variabel bertipe T ("x bisa diisi ke T") jika salah satu kondisi berikut berlaku:

Sebuah konstan x bisa direpresentasikan oleh sebuah nilai bertipe T jika salah satu kondisi berikut berlaku:

Label dideklarasikan oleh perintah label dan digunakan dalam perintah "break", "continue", dan "goto". Adalah ilegal mendefinisikan sebuah label yang tidak pernah digunakan. Berbeda dengan pengidentifikasi lainnya, label tidaklah dibatasi oleh skip dan tidak konflik dengan pengidentifikasi yang bukan label. Skop dari label yaitu badan dari fungsi di mana ia dideklarasikan dan tidak mengikutkan badan dari fungsi yang bersarang.

Pengidentifikasi kosong direpresentasikan oleh karakter garis bawah _. Ia berfungsi sebagai penampung anonim bukan sebagai pengidentifikasi biasa (yang bukan kosong) dan memiliki arti khusus dalam deklarasi, seperti sebuah operan, dan dalam penempatan.

Pengidentifikasi berikut secara implisit dideklarasikan dalam blok universal:

Sebuah pengidentifikasi bisa diekspor untuk membolehkan akses kepadanya dari paket lainnya. Pengidentifikasi diekspor jika:

1. Karakter pertama dari nama pengidentifikasi adalah huruf besar Unicode (kelas Unicode "Lu"); dan 2. Pengidentifikasi dideklarasikan dalam blok paket atau ia merupakan nama field atau nama method.

Pengidentifikasi lainnya tidak diekspor.

Diberikan sekumpulan pengidentifikasi, sebuah pengidentifikasi dikatakan unik jika ia berbeda dari yang lainnya dalam kumpulan tersebut. Dua pengidentifikasi adalah berbeda jika mereka dieja secara berbeda, atau jika mereka muncul di paket yang berbeda dan tidak diekspor. Selain itu, mereka adalah pengidentifikasi yang sama.

Deklarasi konstan mengikat sejumlah pengidentifikasi (nama-nama dari konstan) terhadap nilai dari daftar dari ekspresi konstan. Jumlah pengidentifikasi harus sama dengan jumlah ekspresi, dan pengidentifikasi ke-n di bagian kiri terikat ke nilai dari ekspresi ke-n di bagian kanan.

Jika tipe didefinisikan, semua konstan memakai tipe tersebut, dan ekspresi nilai haruslah dapat di-assign ke tipe tersebut. Jika tipe diindahkan, maka konstan memiliki tipe berdasarkan ekspresi. Jika nilai ekspresi adalah konstan tanpa tipe, maka konstan tetap tanpa tipe dan pengidentifikasi konstan menyatakan nilai konstan. Misalnya, jika ekspresi adalah literal floating-point, pengidentifikasi konstan menyatakan sebuah konstan floating-point, bahkan bila bagian pecahan adalah nol.

Dalam deklarasi const dengan tanda kurung, daftar ekspresi bisa diindahkan kecuali ConstSpec yang pertama. Daftar kosong seperti ini sama saja dengan penggantian tekstual dari daftar ekspresi pertama yang tidak kosong dan tipenya jika ada. Mengindahkan daftar ekspresi maka sama saja dengan mengulang daftar sebelumnya. Jumlah pengidentifikasi harus sama dengan jumlah ekspresi pada daftar sebelumnya. Bersama dengan `iota` konstan generator mekanisme ini membolehkan deklarasi ringan dari nilai berurutan:

Di dalam sebuah deklarasi konstan, pengidentifikasi iota merepresentasikan konstan integer tanpa-tipe beriringan. Nilainya yaitu indeks dari ConstSpec dalam deklarasi konstan tersebut, dimulai dari nol. Ia bisa digunakan untuk membentuk sekumpulan konstan yang berhubungan:

Secara definisi, penggunaan iota berulang kali di dalam ConstSpec yang sama memiliki nilai yang sama:

Contoh terakhir menggunakan pengulangan implisit dari daftar ekspresi yang tidak kosong.

Sebuah deklarasi tipe mengikat pengidentifikasi, name tipe, ke sebuah tipe Deklarasi tipe ada dua bentuk: deklarasi alias dan definisi tipe.

Deklarasi variabel membuat satu atau lebih variabel, mengikat pengidentifikasi yang berkorespondensi kepadanya, dan memberikan setiap tiap-tiapnya sebuah tipe dan nilai awal.

Jika sebuah daftar ekspresi diberikan, maka variabel diinisiasi dengan ekspresi mengikuti aturan-aturan penempatan. Selain itu, setiap variabel diinisiasi dengan nilai kosong nya.

Jika sebuah tipe diberikan, setiap variabel diberikan tipe tersebut. Selain itu, setiap variabel diberikan tipe dari nilai inisiasi pada penempatan. Jika nilai tersebut sebuah konstan tak bertipe, maka pertama kali ia secara implisit dikonversi ke tipe defaultnya; misalnya, jika variabel adalah nilai boolean tanpa tipe, maka ia secara implisit dikonversi ke tipe bool. Nilai nil tidak bisa digunakan untuk menginisiasi sebuah variabel tanpa tipe eksplisit.

Batasan implementasi: Compiler bisa mengilegalkan deklarasi variabel di dalam badan fungsi jika variabel tersebut tidak pernah digunakan.

Deklarasi variabel singkat menggunakan sintaks:

Ia merupakan cara cepat mendeklarasikan variabel dengan ekspresi inisiasi tanpa tipe:

Tidak seperti deklarasi variabel, deklarasi variabel singkat bisa mendeklarasi ulang variabel setelah ia dideklarasikan sebelumnya di dalam blok yang sama (atau dari daftar parameter jika blok adalah badan fungsi) dengan tipe yang sama, dan paling tidak salah satu dari variabel yang tidak kosong adalah variabel baru. Akibatnya, deklarasi ulang hanya dapat muncul dalam sebuah deklarasi singkat multi-variabel. Deklarasi ulang tidak menyebabkan munculnya variabel baru; ia hanya menempatkan nilai baru ke variabel aslinya.

Deklarasi variabel singkat hanya bisa muncul dalam fungsi. Dalam beberapa konteks seperti inisiasi untuk perintah "if", "for", atau "switch", mereka dapat digunakan untuk mendeklarasikan variabel lokal sementara.

Deklarasi fungsi mengikat pengidentifikasi, nama fungsi, ke sebuah fungsi.

Jika fungsi mengembalikan nilai, daftar perintah pada badan fungsi harus berakhir dengan perintah terminasi.

Deklarasi fungsi bisa tanpa badan. Deklarasi seperti ini menyediakan signature untuk sebuah fungsi yang diimplementasikan di luar Go, seperti rutin assembly.

Sebuah method yaitu sebuah fungsi dengan sebuah receiver (penerima). Deklarasi method mengikat pengidentifikasi, nama method, terhadap sebuah method, dan mengasosiasikan method tersebut dengan tipe dasar receiver.

Si receiver dispesifikasikan lewat bagian parameter sebelum nama method. Bagian parameter tersebut harus mendeklarasikan sebuah parameter tunggal, yang disebut juga dengan receiver. Tipe receiver haruslah tipe terdefinisi T atau sebuah pointer ke tipe terdefinisi T. T disebut juga tipe dasar receiver. Tipe dasar receiver tidak bisa berupa tipe pointer atau interface dan ia harus didefinisikan di dalam paket yang sama dengan method. Method tersebut dikatakan terikat dengan tipe dasar receiver dan nama method hanya dapat dipanggil oleh selector untuk tipe T atau *T.

Pengidentifikasi receiver haruslah unik dalam penanda method. Jika nilai receiver tidak dipakai di dalam badan method, maka pengidentifikasinya bisa dihilangkan dalam deklarasi. Hal yang sama berlaku secara umum terhadap parameter dari fungsi dan method.

Untuk tipe dasar yang sama, nama-nama dari method haruslah unik. Jika tipe dasar adalah sebuah tipe struct, nama method dan field haruslah berbeda.

Diberikan sebuah tipe Point, deklarasi berikut

mengikat method Length() dan Scale(), dengan receiver bertipe *Point, terhadap tipe dasar Point.

Tipe dari sebuah method yaitu tipe dari fungsi dengan receiver sebagai argumen yang pertama. Misalnya, method Scale() bertipe

Namun, fungsi yang dideklarasikan seperti di atas bukanlah sebuah method.

Sebuah pengidentifikasi terbatas yaitu sebuah pengidentifikasi yang dibatasi oleh awalan nama paket. Nama paket dan pengidentifikasi haruslah tidak kosong.

Pengidentifikasi terbatas mengakses pengidentifikasi di paket yang berbeda, yang harus diimpor. Si pengidentifikasi haruslah diekspor dan dideklarasikan dalam blok paket dari paket tersebut.

Literal komposit membentuk nilai-nilai untuk struct, array, slice, dan map; dan membuat sebuah nilai baru setiap kali ia dievaluasi. Ia dibentuk dari tipe dari literal diikuti oleh daftar elemen yang dibatasi oleh kurung kurawal. Setiap elemen bisa diawali dengan kunci yang berkorespondensi.

Tipe dasar dari LiteralType haruslah sebuah tipe struct, array, slice, atau map (gramatika memaksa batasan ini kecuali bisa tipe diberikan sebagai sebuah TypeName). Tipe dari elemen dan kunci harus bisa ditempatkan ke tipe field, elemen, dan kunci dari tipe literal yang bersangkutan; tidak ada konversi tambahan. Kunci diinterpretasikan sebagai sebuah nama field untuk literal struct, sebuah indeks pada literal array dan slice, dan sebuah kunci untuk literal map. Untuk literal map, semua elemen harus memiliki sebuah kunci. Adalah sebuah kesalahan bila menspesifikasikan beragam lemen dengan nama field yang sama atau nilai key menggunakan konstan. Untuk kunci map yang tidak-konstan, lihat bagian pada urutan evaluasi.

Untuk literal struct aturan-aturan berikut berlaku:

Diberikan deklarasi berikut

kita bisa menulis

Untuk array dan slice, aturan-aturan berikut berlaku:

Mengambil alamat dari literal komposit menghasilkan sebuah pointer ke sebuah variabel unik yang diinisiasi dengan nilai literal.

Ingatlah bahwa nilai kosong dari sebuah tipe slice atau map tidak sama dengan slice atau yang map diinisiasi dengan nilai kosong dari tipe yang sama. Akibatnya, mengambil alamat dari literal komposit dari sebuah slice atau map yang kosong tidak sama efeknya dengan mengalokasikan slice atau map yang baru dengan new.

Panjang dari literal array yaitu panjang yang dispesifikasikan pada literal tipe. Jika jumlah elemen yang diberikan kecil dari panjangnya, elemen-elemen yang hilang di set dengan nilai kosong dari tipe elemen array. Adalah sebuah kesalahan mengisi elemen dengan nilai indeks di luar rentang indeks dari array. Notasi …​ menspesifikasikan panjang array yang sama dengan maksimum elemen ditambah satu.

Literal slice mendeskripsikan keseluruhan literal array di belakangnya. Maka panjang dan kapasitas dari literal slice yaitu indeks elemen maksimum ditambah satu. Literal slice memiliki bentuk

yang merupakan cara singkat untuk operasi slice yang diterapkan pada sebuah array:

Dalam sebuah literal komposit dari array, slice, atau map bertipe T, elemen atau kunci map yang juga literal komposit bisa mengindahkan literal tipe jika ia identik dengan tipe elemen atau key dari T. Hal yang sama, elemen atau kunci yang merupakan alamat dari literal komposit bisa mengindahkan &T bila tipe elemen atau kunci adalah *T.

Ambiguitas muncul saat literal komposit menggunakan bentuk TypeName dari LiteralType muncul sebagai operan antara kata kunci dan kurung buka dari blok perintah "if", "for", atau "switch", dan literal komposit tidak ditutup dalam tanda kurung, kurung siku, atau kurung kurawal. Dalam kasus langka ini, kurung buka dari literal dengan keliru dianggap sebagai yang membuka perintah blok. Untuk mengatasi kebingungan ini, literal komposit harus muncul dalam tanda kurung.

Contoh literal array, slice, dan map yang valid:

Sebuah literal fungsi merepresentasikan sebuah fungsi anonim.

Sebuah literal fungsi bisa ditempatkan ke sebuah variabel atau langsung dipanggil.

Literal fungsi adalah closure: fungsi yang bisa mengacu ke variabel-variabel yang didefinisikan sebelum fungsi. Variabel tersebut dapat diakses antara fungsi dan literal fungsi, dan variabel tersebut bertahan selama mereka dapat diakses.

Ekspresi dasar yaitu operan-operan untuk ekspresi unary dan binari.

Untuk sebuah ekspresi dasar x yang bukan sebuah nama paket, ekspresi selektor

menyatakan field atau method f dari nilai x (atau terkadang *x; lihat di bawah). Pengidentifikasi f disebut (field atau method) selector; ia tidak boleh sebuah pengidentifikasi kosong. Tipe dari ekspresi selector yaitu tipe dari f. Jika x adalah sebuah nama paket, lihat bagian <<Qualified_identifiers[pengidentifikasi terbatas].

Sebuah selector f bisa menyatakan sebuah field atau method f dari sebuah tipe T, atau ia bisa mengacu pada sebuah field atau method f dari field tertanam dari T. Jumlah field tertanam yang dijajaki sampai ke f disebut dengan kedalaman dari T. Kedalaman dari sebuah field atau method f yang dideklarasikan dalam T adalah nol. Kedalaman dari sebuah field atau method f yang dideklarasikan dalam field A yang ditanam dalam T adalah kedalaman f dalam A ditambah satu.

Aturan-aturan berikut berlaku pada selector:

Sebagai contoh, dari deklarasi berikut:

kita dapat menulis:

namun pernyataan berikut adalah invalid:

Jika M ada dalam kumpulan method bertipe T, T.M adalah sebuah fungsi yang dapat dipanggil seperti fungsi biasa dengan argumen yang sama dengan M yang diawali dengan argumen tambahan yaitu receiver dari method.

Misalkan sebuah struct bertipe T dengan dua method, Mv, dengan receiver bertipe T; dan Mp dengan receiver bertipe *T.

Ekspresi

menghasilkan sebuah fungsi yang sama dengan Mv namun dengan sebuah receiver eksplisit sebagai argumen pertama; dengan penanda

Fungsi tersebut bisa dipanggil secara normal dengan receiver eksplisit, sehingga kelima pemanggilan berikut adalah sama:

Hal yang sama, ekspresi berikut

menghasilkan sebuah nilai fungsi yang merepresentasikan Mp dengan penanda

Untuk sebuah method dengan receiver nilai, kita dapat menurunkan sebuah fungsi dengan receiver pointer yang eksplisit, sehingga

menghasilkan sebuah nilai fungsi merepresentasikan Mv dengan penanda

Fungsi seperti ini secara tidak langsung lewat receiver untuk membuat sebuah nilai untuk dikirim sebagai receiver pada method dibaliknya; method tersebut tidak menimpa nilai yang alamatnya dikirim ke pemanggilan fungsi.

Kasus terakhir, fungsi dengan receiver berupa nilai untuk sebuah method dengan receiver berupa pointer, adalah ilegal karena method-method dengan receiver pointer tidak berada dalam kumpulan method dari tipe nilai.

Nilai-nilai fungsi yang diturunkan dari method dipanggil dengan sintaksis pemanggilan fungsi biasa; si receiver diberikan sebagai argumen pertama pada pemanggilan. Maka, diberikan f := T.Mv, f dipanggil dengan cara f(t,7) bukan t.f(7). Untuk membentuk sebuah fungsi yang mengikat receiver, gunakan literal fungsi atau nilai method.

Adalah legal menurunkan sebuah nilai fungsi dari sebuah method bertipe interface. Hasil fungsinya menerima receiver eksplisit dari tipe interface tersebut.

Jika ekspresi x memiliki tipe statis T dan M berada dalam kumpulan method dari tipe T, x.M disebut nilai method. Nilai method x.M yaitu sebuah nilai fungsi yang dapat dipanggil dengan argumen yang sama seperti memanggil method dari x.M. Ekspresi x dievaluasi dan disimpan selama evaluasi dari nilai method; salinan yang disimpan kemudian digunakan sebagai receiver pada setiap pemanggilan, yang bisa saja dieksekusi nantinya.

Tipe T bisa berupa tipe interface atau bukan interface.

Seperti yang telah didiskusikan dalam ekspresi method di atas, misalnya ada sebuah struct bertipe T dengan dua method, Mv, dengan receiver bertipe T, dan Mp, dengan receiver bertipe *T.

Ekspresi dari

menghasilkan sebuah nilai fungsi bertipe

Pemanggilan berikut adalah sama:

Hal yang sama, ekspresi berikut

menghasilkan sebuah nilai fungsi bertip

Seperti halnya dengan selector, sebuah referensi ke method yang bukan interface dengan receiver nilai menggunakan pointer akan secara otomatis membalikan pointer tersebut: pt.Mv sama dengan (*pt)Mv.

Seperti halnya dengan pemanggilan method, sebuah referensi ke method yang bukan interface dengan receiver pointer menggunakan nilai beralamat akan secara otomatis mengambil alamat dari nilai tersebut: t.Mp sama dengan (&t).Mp.

Walaupun contoh di atas menggunakan tipe bukan interface, merupakan hal yang legal untuk membuat sebuah nilai method dari nilai bertipe interface.

Ekspresi dasar dari bentuk

menyatakan elemen dari array, pointer ke array, slice, atau map a yang diindeks oleh x. Nilai x disebut dengan indeks atau map key. Aturan-aturan berikut berlaku:

Jika a bukan sebuah map:

Untuk a dengan tipe Array A:

Untuk a sebagai pointer ke tipe array:

Untuk a dengan tipe slice S:

Untuk a dari tipe string:

Untuk a dari tipe map M:

Selain itu a[x] adalah ilegal.

Ekspresi indeks dapat sebuah map bertipe map[K]V yang digunakan dalam sebuah penempatan atau inisiasi dari bentuk khusus

menghasilkan sebuah nilai boolean tidak bertipe tambahan. Nilai dari ok adalah true jika key x ada dalam map, dan false jika tidak ada.

Menempatkan ke elemen map yang nil akan mengakibatkan panik runtime.

Ekspresi pemotongan membentuk sebuah substring atau slice dari sebuah string, array, pointer ke array, atau slice. Ada dua varian: bentuk sederhana yang menentukan batas bawah dan atas, dan bentuk penuh yang juga menentukan batas dari kapasitas.

Untuk sebuah ekspresi x dari tipe interface dan sebuah tipe T, ekspresi dasar berikut

menyatakan bahwa x tidak nil dan nilai yang tersimpan dalam x bertipe T. Notasi x.(T) disebut dengan asersi tipe.

Lebih tepatnya, jika T bukan bertipe interface, x.(T) menyatakan bahwa tipe dinamis dari x adalah identik dengan tipe T. Dalam kasus ini, T harus mengimplementasikan tipe (interface) dari x; sebaliknya asersi tipe tidak valid karena tidak mungkin bagi x untuk menyimpan nilai bertipe T. Jika T adalah tipe interface, x.(T) menyatakan bahwa tipe dinamis dari x mengimplementasikan interface T.

Jika asersi tipe berhasil, nilai dari ekspresi tersebut yaitu nilai yang tersimpan dalam x dan tipenya yaitu T. Jika asersi tipe gagal, panik runtime terjadi. Dengan kata lain, walaupun tipe dinamis dari x diketahui pada saat runtime, tipe dari x.(T) hanya diketahui sebagai T dalam program yang benar.

Asersi tipe yang digunakan dalam penempatan atau inisiasi dari bentuk khusus

menghasilkan nilai boolean tambahan. Nilai dari ok adalah true jika asersi berhasil. Sebaliknya ia akan false dan nilai dari v adalah nilai kosong untuk tipe T. Tidak ada panik _runtime yang akan terjadi dalam kasus ini.

Diberikan sebuah ekspresi f dari tipe fungsi F,

akan memanggil f dengan argumen a1, a2, …​ an. Kecuali untuk kasus khusus, argumen-argumen haruslah ekspresi nilai-tunggal yang dapat disimpan ke tipe parameter dari F dan dievaluasi sebelum fungsi dipanggil. Tipe dari ekspresi adalah tipe kembalian dari F. Pemanggilan sebuah method mirip namun method itu sendiri ditentukan sebagai sebuah selector dari sebuah nilai dari tipe receiver untuk method tersebut.

Dalam pemanggilan sebuah fungsi, nilai fungsi dan argumennya dievaluasi dengan urutan yang biasa. Setelah mereka dievaluasi, parameter-parameter dari pemanggilan dikirim dengan nilai ke dalam fungsi dan fungsi yang dipanggil tersebut mulai dieksekusi. Parameter kembalian dari fungsi dikirim dengan nilai ke pemanggil fungsi saat fungsi berakhir.

Memanggil fungsi yang nil menyebabkan panik runtime.

Kasus khusus, jika nilai kembalian dari sebuah fungsi atau method g sama jumlahnya dan dapat ditempatkan pada parameter-parameter di fungsi atau method f, maka pemanggilan f(g(parameter_dari_g)) akan memanggil f setelah nilai kembalian dari g diberikan sebagai parameter ke f secara berurutan. Pemanggilan dari f tidak boleh berisi parameter selain pemanggilan ke g, dan g paling tidak harus mengembalikan satu nilai. Jika f memiliki parameter akhir …​, ia akan diisi nilai kembalian dari g yang tersisa setelah penempatan parameter biasa sebelumnya.

Pemanggilan sebuah method x.m() valid jika kumpulan method dari (tipe) x memiliki m dan daftar argumen dapat diberikan ke daftar parameter dari m. Jika x adalah alamat dan kumpulan method &x memiliki m, x.m() adalah singkatan untuk (&x).m():

Tidak ada perbedaan tipe method dan tidak ada literal method.

Jika f adalah variadic dengan parameter terakhir bertipe …​T, maka tipe dari p dalam f sama dengan tipe []T. Jika f dipanggil tanpa argumen untuk p, maka nilai yang dikirim ke p adalah nil. Sebaliknya, nilai yang dikirim adalah slice baru bertipe []T dengan array dasar yang elemennya adalah argumen-argumen aslinya, yang semuanya harus dapat disimpan ke T. Panjang dan kapasitas slice yaitu jumlah argumen dan bisa berbeda untuk setiap pemanggilan.

Diberikan fungsi dan pemanggilan

dalam Greeting, who akan bernilai nil pada pemanggilan yang pertama, dan []string{"Joe", "Anna", "Eileen"} pada pemanggilan kedua.

Jika argumen terakhir dapat disimpan ke slice bertipe []T, maka akan dikirim tanpa diubah sebagai nilai untuk parameter …​T jika argumen diikuti oleh …​. Dalam kasus ini tidak ada slice baru yang dibuat.

Diberikan sebuah slice s dan pemanggilan

dalam Greeting, who akan bernilai sama dengan s dengan array dasar yang sama.

Operator menggabungkan operan menjadi ekspresi.

Operator pembandingan didiskusikan dibagian lain. Untuk operator binari lainnya, tipe operan haruslah identik kecuali pada operasi shift atau bila menggunakan konstanta tanpa tipe. Untuk operasi yang mengikutkan konstanta saja, lihat bagian pada ekspresi konstanta.

Kecuali untuk operasi shift, jika salah satu operan adalah konstanta dan operan lainnya bukan, konstanta tersebut secara implisit dikonversi ke tipe operan lainnya.

Operan sebelah kanan dalam ekspresi shift haruslah tipe integer atau konstanta tak bertipe yang dapat direpresentasikan oleh sebuah nilai bertipe uint. Jika operan sebelah kiri dari ekspresi shift adalah konstanta tanpa tipe, maka ia secara implisit dikonversi ke tipe yang diasumsikan jika ekspresi shift diganti oleh operan kiri.

Operator aritmetika dipakai pada nilai numerik dan menghasilkan nilai dengan tipe yang sama dengan operan pertama. Keempat operator standar aritmetika (, -, *, /) berlaku pada tipe integer, _floating-point_, dan complex; `` juga berlaku pada string. Operator shift dan logika bitwise berlaku pada integer saja.

Operator pembandingan membandingkan dua opera dan menghasilkan nilai boolean tak bertipe.

Dalam setiap pembandingan, operan pertama haruslah dapat disimpan ke tipe dari operan kedua, atau sebaliknya.

Operator persamaan == dan != berlaku untuk operan-operan yang dapat dibandingkan. Operator pengurutan <, ⇐, >, dan >= berlaku untuk operan-operan yang dapat diurutkan. Berikut definisi aturan-aturan dan hasil dari pembandingan:

Pembandingan dua nilai interface dengan tipe dinamis yang identik menyebabkan panik runtime jika nilai dari tipe tersebut tidak bisa dibandingkan. Perilaku ini berlaku tidak saja pada pembandingan nilai interface langsung namun juga saat membandingkan array dari nilai interface atau struct dengan field bernilai interface.

Nilai slice, map, dan fungsi tidak bisa dibandingkan. Namun, sebagai kasus spesial, nilai slice, map, atau fungsi bisa jadi dibandingkan dengan pengidentifikasi nil. Pembandingan nilai pointer, channel, dan interface dengan nil juga dibolehkan dan mengikuti aturan di atas.

Operator logika berlaku untuk nilai boolean dan menghasilkan tipe yang sama dengan operan. Operan kanan dievaluasi berdasarkan kondisi.

Untuk sebuah operan x bertipe T, operasi alamat &x mengembalikan sebuah pointer bertipe *T ke x. Operan tersebut haruslah memiliki alamat, yaitu, sebuah variabel, pointer ke pointer, atau operasi pengindeksan slice; atau sebuah selector field dari operan struct yang memiliki alamat; atau sebuah operasi pengindeksan array dari array yang memiliki alamat;. Salah satu pengecualian dari kebutuhan alamat ini yaitu x mungkin bisa sebuah (dalam tanda kurung) literal komposit. Jika evaluasi dari x menyebabkan panik runtime, maka evaluasi dari &x juga akan panik.

Untuk sebuah operan x berupa pointer bertipe *T, pointer ke pointer dari *x menyatakan variabel bertipe T yang ditunjuk oleh x. Jika x adalah nil, evaluasi dari *x akan menyebabkan panik runtime.

Untuk sebuah operan ch bertipe channel, nilai dari operasi terima ←ch adalah nilai yang diterima dari channel ch. Arah dari channel haruslah membolehkan operasi terima, dan tipe kembalian dari operasi terima yaitu tipe elemen dari channel. Ekspresi dari ←ch akan diblok sampai sebuah nilai tersedia. Operasi terima dari channel yang nil akan diblok selamanya. Operasi terima dari channel yang telah ditutup akan selalu diproses langsung, menghasilkan nilai kosong dari tipe elemen setelah semua nilai yang sebelumnya dikirim ke channel telah diterima semuanya.

Ekspresi terima yang digunakan dalam penempatan atau inisiasi dari bentuk khusus

menghasilkan nilai boolean yang melaporkan apakah komunikasi sukses atau tidak. Nilai dari ok adalah true jika nilai yang diterima dikirim oleh sebuah operasi pengiriman ke channel yang sukses, atau false jika nilainya adalah nilai kosong karena channel telah ditutup dan kosong.

Sebuah konversi mengubah tipe dari sebuah ekspresi ke tipe yang ditentukan oleh konversi. Sebuah konversi bisa muncul secara literal dalam sumber kode, atau ia bisa diimplikasikan oleh konteks di mana ekspresi muncul.

Konversi eksplisit yaitu ekspresi dalam bentuk T(x) dengan T adalah sebuah tipe dan x adalah sebuah ekspresi yang dapat dikonversi ke tipe T.

Jika tipe diawali dengan operator * atau ←, atau jika tipe dimulai dengan kata kunci func dan tidak memiliki daftar kembalian, maka ia haruslah diberi tanda kurung bila diperlukan untuk menghindari kebingungan:

Sebuah konstanta bernilai x dapat dikonversi ke tipe T jika x dapat direpresentasikan oleh nilai dari T. Untuk kasus khusus, nilai konstanta x dapat secara eksplisit dikonversi ke sebuah tipe string menggunakan aturan yang sama dengan nilai non-konstanta x.

Mengonversi sebuah konstanta menghasilkan konstanta bertipe.

Sebuah nilai yang bukan konstanta x dapat dikonversi ke tipe T dalam kasus-kasus berikut:

tag dari struct diindahkan saat membanding tipe struct untuk identitas untuk tujuan konversi:

Aturan-aturan spesifik berlaku untuk konversi (non-konstanta) antara tipe numerik atau dari dan ke tipe string. Konversi ini bisa mengubah representasi dari x dan membutuhkan biaya pada saat runtime. Konversi yang lainnya hanya mengubah tipe tetapi tidak representasi dari x.

Tidak ada mekanisme linguistik untuk mengonversi antara pointer dan integer. Paket unsafe mengimplementasikan fungsionalitas tersebut dengan batasan-batasan tertentu.

Ekspresi konstanta bisa berisi hanya operan-operan konstanta dan dievaluasi saat di-compile.

Konstanta tanpa tipe dari boolean, numerik, dan string bisa digunakan sebagai operan di mana pun selama legal menggunakan operan bertipe boolean, numerik, atau string.

Pembandingan konstanta selalu menghasilkan konstanta boolean tak bertipe. Jika operan kiri dari ekspresi shift adalah konstanta tak bertipe, hasilnya adalah konstanta integer; sebaliknya jika operan kiri yaitu konstanta bertipe maka hasilnya konstanta dengan tipe yang sama dengan operan kiri, yang haruslah bertipe integer.

Operasi lain pada konstanta tanpa tipe menghasilkan konstanta tanpa tipe dari jenis yang sama: yaitu konstanta boolean, integer, floating-point, complex, atau string. Jika operan dari operasi binari tidak bertipe (selain shift) memiliki jenis yang berbeda, hasilnya yaitu jenis operan yang muncul terakhir dalam daftar: integer, rune, floating-point, complex. Misalnya, konstanta integer tanpa tipe dibagi dengan konstanta complex tanpa tipe menghasilkan konstanta complex tanpa tipe.

Menerapkan fungsi bawaan complex ke konstanta integer, rune, atau floating-point tanpa tipe menghasilkan konstanta complex tanpa tipe.

Ekspresi konstanta selalu dievaluasi seperti yang tertulis; Nilai sementara dan konstanta itu sendiri bisa membutuhkan presisi yang lebih besar dari tipe yang didukung dalam bahasa. Berikut ini deklarasi yang legal:

Penyebut dari pembagian sebuah konstanta atau operasi penyisaan haruslah nol:

Nilai dari konstanta bertipe haruslah selalu secara akurat direpresentasikan oleh nilai dari tipe konstanta. Ekspresi konstanta berikut adalah ilegal:

Mask yang digunakan oleh operator komplemen unary bitwise ^ cocok dengan aturan untuk non-konstanta: semua mask adalah 1 untuk konstanta integer dan -1 untuk signed dan konstanta tak bertipe.

Batasan implementasi: compiler bisa melakukan pembulatan saat menghitung ekspresi konstanta floating-point atau complex yang tak bertipe; lihat batasan implementasi dalam bagian konstanta. Pembulatan ini bisa menyebabkan ekspresi konstanta floating-point menjadi tidak valid dalam konteks integer, walaupun menjadi integral saat dihitung menggunakan presisi tanpa batas, dan sebaliknya.

Pada tingkat paket, inisiasi kebergantungan menentukan urutan evaluasi dari ekspresi inisiasi individu dalam deklarasi variabel. Sebaliknya, saat mengevaluasi operan dari sebuah ekspresi, penempatan, atau perintah kembalian, semua pemanggilan fungsi, pemanggilan method, dan operasi komunikasi dievaluasi secara leksikal terurut dari kiri-ke-kanan.

Contohnya, pada penempatan

pemanggilan fungsi dan komunikasi terjadi dengan urutan f(), h(), i(), j(), ←c, dan k(). Namun, urutan dari even-even tersebut dibandingkan dengan evaluasi dan pengindeksan dari x dan evaluasi dari y tidak dispesifikasikan.

Pada tingkat paket, inisiasi dependensi menimpa aturan kiri-ke-kanan untuk ekspresi inisiasi individu, tetapi tidak untuk operan-operan dalam setiap ekspresi:

Pemanggilan fungsi terjadi dengan urutan u(), sqr(), v(), f(), v(), dan g().

Operasi floating-point dalam sebuah ekspresi dievaluasi menurut asosiatif dari operator. Tanda kurung secara eksplisit mempengaruhi evaluasi dengan menimpa asosiatif baku. Dalam ekspresi x+(y+z) penambahan y+z dilakukan sebelum menambahkan dengan x.

Sebuah perintah penghenti mencegah eksekusi dari semua perintah yang muncul setelah perintah penghenti dalam blok yang sama. Perintah-perintah berikut adalah penghenti:

Semua perintah selain itu bukanlah penghenti.

Sebuah daftar perintah berakhir dalam sebuah perintah penghenti jika daftar tersebut tidak kosong dan perintah terakhirnya adalah penghenti.

Perintah kosong tidak melakukan apa pun.

Sebuah perintah berlabel bisa menjadi target dari sebuah perintah goto, break, atau continue.

Dengan pengecualian dari fungsi bawaan khusus, pemanggilan fungsi dan method dan operasi menerima dapat muncul dalam konteks perintah. Perintah-perintah tersebut bisa diberi tanda kurung.

Fungsi-fungsi bawaan berikut tidak dibolehkan dalam konteks perintah:

Sebuah perintah kirim mengirim sebuah nilai ke sebuah channel. Ekspresi channel haruslah bertipe channel, arah channel haruslah membolehkan operasi kirim, dan tipe dari nilai yang akan dikirim haruslah bisa disimpan ke tipe elemen dari channel.

Kedua ekspresi channel dan nilai dievaluasi sebelum komunikasi dimulai. Komunikasi akan ditahan sampai pengirim dan dilanjutkan. Sebuah pengiriman pada channel tanpa buffer dapat dilanjutkan jika sebuah penerima telah sedia. Sebuah pengiriman ke channel dengan buffer dapat dilanjutkan selama ada ruang dalam buffer. Sebuah pengiriman ke channel yang telah ditutup dilanjutkan dengan mengakibatkan panik runtime. Sebuah pengiriman terhadap channel yang nil akan ditahan selamanya.

Perintah "" dan "—" menambah dan mengurangi operannya dengan konstanta tanpa tipe 1. Seperti halnya penempatan, operan tersebut haruslah beralamat atau ekspresi indeks dari sebuah map.

perintah penempatan berikut secara semantik sama:

Setiap operan sisi kiri haruslah beralamat, sebuah ekspresi indeks dari sebuah map, atau (hanya untuk penempatan =) pengidentifikasi kosong. Operan-operan bisa diberi tanda kurung.

Sebuah operasi penempatan x op= y yang mana op yaitu operator aritmetika binari yaitu sama dengan x = x op (y) namun hanya mengevaluasi x sekali saja. Konstruksi op= yaitu sebuah token tunggal. Dalam operasi penempatan, kedua daftar ekspresi kiri dan kanan haruslah berisi ekspresi tunggal dengan nilai, dan ekspresi bagian kiri haruslah bukan pengidentifikasi kosong.

Penempatan tuple memberi setiap individu elemen dari sebuah operasi multi-nilai ke sebuah daftar variabel. Ada dua bentuk. Bentuk pertama, operan bagian kanan yaitu ekspresi multi-nilai seperti pemanggilan fungsi, operasi channel atau map, atau sebuah tipe asersi. Jumlah operan pada sisi kiri harus sesuai dengan jumlah nilai. Misalnya, jika f adalah sebuah fungsi yang mengembalikan dua nilai,

menempatkan nilai pertama ke x dan yang kedua ke y. Dalam bentuk kedua, jumlah operan pada sisi kiri haruslah sama dengan jumlah ekspresi di sisi kanan, setiap-tiapnya haruslah bernilai tunggal, dan ekspresi ke-n di sisi kanan ditempatkan ke operan ke-n di sisi kiri:

Pengidentifikasi kosong menyediakan cara untuk mengindahkan nilai di sisi kanan dalam sebuah penempatan:

Penempatan diproses dengan dua fase. Pertama, operan dari ekspresi indeks dan pembalikan pointer (termasuk pembalikan pointer implisit dalam selector) pada sisi kiri dan ekspresi di sisi kanan dievaluasi dengan urutan yang biasa. Kedua, penempatan dilakukan dengan urutan kiri-ke-kanan.

Dalam penempatan, setiap nilai haruslah dapat ditempatkan ke tipe dari operan yang mana ia ditempatkan, dengan kasus-kasus khusus berikut:

Perintah "if" menentukan kondisi eksekusi dari dua cabang menurut nilai dari sebuah ekspresi boolean. Jika evaluasi ekspresi bernilai true, maka cabang "if" yang dieksekusi, sebaliknya, jika ada, cabang "else" yang dieksekusi.

Ekspresi tersebut bisa didahului oleh perintah sederhana, yang dieksekusi sebelum ekspresi dievaluasi.

Perintah "switch" menyediakan eksekusi multi-cabang. Sebuah ekspresi atau spesifikasi tipe dibandingkan dengan setiap "case" dalam "switch" untuk menentukan cabang mana yang akan dieksekusi.

Ada dua bentuk: switch dengan ekspresi dan switch dengan tipe. Pada switch dengan ekspresi, bagian "case" berisi ekspresi yang dibandingkan dengan nilai dari ekspresi switch. Pada switch dengan tipe, bagian "case" berisi tipe-tipe yang dibandingkan dengan tipe dari ekspresi switch. Ekspresi switch dievaluasi sekali dalam sebuah perintah switch.

Sebuah perintah "for" menentukan eksekusi berulang dari sebuah blok. Ada tiga bentuk: iterasi bisa dikontrol oleh kondisi tunggal, sebuah klausa "for", atau sebuah klausa "range".

Sebuah perintah "go" memulai eksekusi dari pemanggilan fungsi sebagai thread konkuren yang berdiri sendiri, atau disebut _goroutine, dalam ruang alamat yang sama.

Expression haruslah sebuah pemanggilan fungsi atau method; tidak bisa dalam tanda kurung kurawal. Pemanggilan fungsi bawaan dibatasi untuk perintah ekspresi.

Nilai fungsi dan parameter dievaluasi seperti biasa dalam goroutine yang dipanggil, tetapi tidak seperti pemanggilan biasa, eksekusi program tidak menunggu fungsi yang dipanggil untuk selesai. Namun, fungsi tersebut mulai dieksekusi secara independen dalam sebuah goroutine yang baru. Saat fungsi selesai, goroutine-nya juga selesai. Jika fungsi memiliki nilai kembalian, nilainya akan diindahkan saat fungsi selesai.

Sebuah perintah "select" memilih sekumpulan operasi pengiriman atau penerimaan yang akan diproses. Ia mirip dengan perintah "switch" namun dengan semua "case" mengacu pada operasi komunikasi.

Sebuah "case" dengan RecvStmt bisa menempatkan hasil dari RecvExpr ke satu atau dua variabel, yang bisa dideklarasikan menggunakan deklarasi variabel singkat. RecvExpr haruslah sebuah operasi menerima (bisa pakai tanda kurung). Hanya boleh ada satu case "default" dan ia bisa muncul di mana pun dalam daftar case.

Eksekusi dari perintah "select" diproses dalam beberapa langkah:

Secara komunikasi pada channel nil tidak pernah diproses, sebuah "select" dengan hanya channel-channel yang nil tanpa case "default" akan ditahan selamanya.

Sebuah perintah "return" dalam sebuah fungsi F menghentikan eksekusi dari F, dan mengembalikan satu atau lebih nilai. Setiap fungsi yang di-defer oleh F dieksekusi sebelum F kembali ke pemanggilnya.

Dalam sebuah fungsi tanpa tipe kembalian, perintah "return" tidak boleh menspesifikasikan nilai kembalian.

Ada tiga cara untuk mengembalikan nilai dari sebuah fungsi dengan tipe kembalian:

Bagaimanapun cara mereka dideklarasikan, semua nilai kembalian diinisiasi dengan nilai kosong untuk tipe mereka saat memasuki fungsi. Sebuah perintah "return" yang menentukan kembalian menset parameter-parameter kembalian sebelum fungsi-fungsi yang di-defer dieksekusi.

Batasan implementasi: compiler bisa tidak membolehkan daftar eksepresi yang kosong dalam sebuah perintah "return" jika entitas yang berbeda (konstanta, tipe, atau variabel) dengan nama yang sama dengan parameter kembalian berada dalam skop ditempat yang di "return".

Sebuah perintah "break" menghentikan eksekusi dari perintah "for", "switch", "select" dalam fungsi yang sama.

Jika diberi label, ia haruslah yang mengurung perintah "for", "switch", "select", dan itulah yang eksekusinya akan dihentikan.

Sebuah perintah "continue" memulai iterasi selanjutnya dari pengulangan "for" di posisi perintah tersebut. Pengulangan "for" haruslah dalam fungsi yang sama.

Jika ada label, ia haruslah yang mengurung perintah "for", yang disanalah eksekusi akan dilanjutkan.

Sebuah perintah "goto" memindahkan kontrol ke perintah dengan label yang berkorespondensi dalam fungsi yang sama.

Mengeksekusi perintah "goto" tidak boleh menyebabkan variabel menjadi skop yang belum ada dalam skop saat goto terjadi. Misalnya, contoh berikut

adalah eror karena saat meloncat ke label L melewati terbuatnya v.

Sebuah perintah "goto" di luar blok tidak bisa meloncat ke label di dalam blok tersebut. Misalnya, contoh berikut:

adalah eror karena label L1 berada dalam blok perintah "for" namun goto tidak dalam blok yang sama.

Sebuah perintah "fallthrough" memindahkan kontrol ke perintah pertama dari klausa "case" selanjutnya dalam sebuah ekspresi perintah "switch". Ia hanya bisa digunakan sebagai perintah terakhir dalam klausa tersebut.

Sebuah perintah "defer" memanggil sebuah fungsi yang eksekusinya ditunda sampai fungsi yang mengurungnya selesai, baik karena fungsi tersebut mengeksekusi perintah "return", mencapai akhir dari badan fungsi, atau karena goroutine tersebut panik.

Si Expression haruslah sebuah pemanggilan fungsi atau method; tidak bisa di dalam tanda kurung. Pemanggilan fungsi bawaan terbatas untuk perintah ekspresi.

Setiap kali sebuah perintah "defer" dieksekusi, nilai dan parameter fungsi dievaluasi secara normal dan disimpan namun fungsi yang sebenarnya tidak dipanggil. Namun, fungsi yang ditunda dipanggil langsung sebelum fungsi kembali, dengan urutan terbalik dari saat mereka di-defer. Artinya, jika fungsi selesai lewat perintah "return", fungsi yang didefer dieksekusi setelah parameter kembalian diset oleh perintah "return" tersebut namun sebelum fungsi kembali ke pemanggilnya. Jika sebuah fungsi yang di-defer dievaluasi jadi nil, maka eksekusi akan panik saat fungsi dipanggil, bukan saat perintah "defer" dieksekusi.

Misalnya, jika fungsi yang di defer adalah sebuah literal fungsi dan fungsi yang mengurungnya memiliki parameter kembalian bernama yang berada dalam skop dari literal fungsi, maka fungsi yang di-defer bisa mengakses dan mengubah parameter kembalian sebelum mereka dikembalikan. Jika fungsi yang ditunda memiliki nilai kembalian, mereka diindahkan saat fungsi selesai. (Lihat juga bagian tentang penanganan panic.

Untuk sebuah channel c, fungsi bawaan close(c) mencatat bahwa tidak ada lagi nilai yang dapat dikirim ke channel. Fungsi close akan eror jika c adalah channel yang bersifat menerima saja. Mengirim ke atau menutup channel yang telah ditutup menyebabkan panik run-time. Menutup channel yang nil juga menyebabkan panik run-time. Setelah memanggil close, dan setelah nilai yang dikirim sebelumnya telah diterima, operasi menerima akan mengembalikan nilai kosong dari tipe channel tersebut tanpa ditangguhkan. operasi menerima dengan beragam nilai mengembalikan nilai yang diterima berikut dengan indikasi tentang apakah channel telah ditutup.

Fungsi bawaan len dan cap menerima argumen berupa tipe dan mengembalikan nilai bertipe int. Implementasi menjamin bahwa kembalian selalu masuk dengan int.

Kapasitas dari slice yaitu jumlah elemen yang telah dialokasi dalam array dibelakangnya. Relasi berikut selalu berlaku kapanpun:

Panjang dari slice, map atau channel yang nil selalu 0. Kapasitas dari slice atau channel yang nil selalu 0.

Ekspresi len(s) adalah konstanta jika s adalah konstanta string. Ekspresi len(s) dan cap(s) adalah konstanta jika tipe dari s adalah array atau pointer ke array dan ekspresi s tidak mengandung penerimaan channel atau pemanggilan fungsi (yang bukan konstanta); dalam kasus tersebut s tidak dievaluasi. Sebaliknya, pemanggilan len dan cap bukanlah konstanta dan s tidak dievaluasi.

Fungsi bawaan new menerima sebuah tipe T, mengalokasikan penyimpanan untuk sebuah variabel dengan tipe tersebut pada saat run-time, dan mengembalikan sebuah nilai bertipe *T yang menunjuk kepadanya. Variabel tersebut diinisiasi seperti yang dijelaskan dalam bagian nilai awal.

Misalnya

mengalokasikan penyimpanan untuk sebuah variabel bertipe S, menginisiasinya (a=0, b=0.0), dan mengembalikan sebuah nilai bertipe *S yang berisi alamat dari alokasi.

Fungsi bawaan make menerima sebuah tipe T, yang haruslah bertipe slice, map, atau channel; diikuti oleh daftar ekspresi berdasarkan tipe. Ia mengembalikan sebuah nilai bertipe T (bukan *T). Memory diinisiasi seperti yang dijelaskan dalam bagian nilai awal.

Setiap argumen ukuran n dan m haruslah bertipe integer atau konstanta tak bertipe. Argumen yang berupa konstanta haruslah tidak negatif dan dapat direpresentasikan oleh nilai bertipe int; jika ia berupa konstanta tak bertipe ia akan bertipe int. Jika n dan m diberikan dan keduanya adalah konstanta, maka n haruslah besar dari m. Jika n negatif atau besar dari m pada saat run-time, maka panik run-time akan terjadi.

Memanggil make dengan tipe map dan ukuran n akan membuat sebuah map dengan ruang awal yang dapat menyimpan n map elemen. Perilaku aslinya bergantung pada implementasi.

Fungsi bawaan append dan copy membantu dalam operasi slice. Untuk kedua fungsi, hasilnya selalu independen walaupun memory yang diacu oleh argumen bertindihan.

Fungsi variadik append menambahkan kosong atau lebih nilai x ke s yang bertipe S, yang haruslah bertipe slice, dan mengembalikan hasil slice, yang juga bertipe S. Nilai x dikirim sebagai parameter bertipe …​T yang mana T adalah tipe elemen dari S dan aturan pengiriman parameter berlaku. Sebagai kasus khusus, append juga menerima argumen pertama yang dapat ditempatkan ke tipe []byte dengan argumen kedua bertipe string diikuti dengan …​. Bentuk ini menambahkan sejumlah byte ke string.

Jika kapasitas s tidak cukup besar untuk menampung nilai-nilai tambahan, append mengalokasikan sebuah array dasar yang baru yang lebih besar yang dapat menampung slice elemen yang alam dan nilai yang baru. Sebaliknya, append menggunakan array dasar yang sama.

Fungsi copy menyalin elemen slice dari sumber src ke tujuan dst dan mengembalikan jumlah elemen yang disalin. Kedua argumen haruslah memiliki elemen yang identik bertipe T dan harus dapat ditempatkan ke sebuah slice bertipe []T. Jumlah elemen yang disalin yaitu minium dari len(src) dan len(dst). Sebagai kasus khusus, copy juga menerima argumen tujuan yang dapat ditempatkan ke tipe []byte dengan argumen sumber bertipe string. Bentuk ini menyalin byte dari string ke slice byte.

Contoh:

Fungsi bawaan delete menghapus elemen dengan kunci k dari sebuah map m. Tipe dari k haruslah dapat dapat ditempatkan ke tipe kunci dari m.

Jika map m adalah nil atau elemen m[k] tidak ada, delete adalah operasi kosong.

Tiga fungsi menyusun dan mengurai bilangan complex. Fungsi bawaan complex membentuk sebuah nilai complex dari bagian real dan imajiner floating-point, sementara real dan imag mengekstrak bagian real dan imajiner dari sebuah nilai complex.

Tipe dari argumen dan nilai kembalian saling berhubungan. Untuk complex, kedua argumen haruslah tipe floating-point yang sama dan tipe kembalian yaitu salah satu tipe complex berikut: complex64 untuk argumen bertipe float32, dan complex128 untuk argumen bertipe float64. Jika salah satu argumen adalah konstanta tak bertipe, maka ia secara implisit dikonversi ke tipe dari argumen lainnya. Jika kedua argumen dievaluasi ke konstanta tak bertipe, maka keduanya haruslah bilangan non-complex atau bagian imajinernya haruslah nol, dan nilai kembalian dari fungsi yaitu konstanta complex tak bertipe.

Untuk real dan imag, argumen haruslah bertipe complex, dan tipe kembalian berkorespondensi dengan tipe floating-point: float32 untuk argumen complex64, dan float64 untuk argumen complex128. Jika argumen dievaluasi menjadi konstanta tak bertipe, maka ia haruslah berupa angka, dan nilai kembalian dari fungsi yaitu konstanta floating-point tak bertipe.

Fungsi real dan imag keduanya membentuk kebalikan dari complex, sehingga untuk nilai z dari tipe complex Z, z == Z(complex(real(z), imag(z))).

Jika operan dari fungsi-fungsi tersebut semuanya adalah konstanta, maka nilai kembaliannya adalah konstanta.

Dua fungsi bawaan, panic dan recover, membantu dalam melaporkan dan menangani panik run-time dan kondisi eror yang terdefinisi pada program.

Saat mengeksekusi sebuah fungsi F, pemanggilan panic yang eksplisit atau panik run-time menghentikan eksekusi dari F. Fungsi apa pun yang ditunda oleh F kemudian dieksekusi. Selanjutnya, fungsi apa pun yang ditunda oleh pemanggil F dijalankan, dan begitu seterusnya sampai fungsi paling atas dalam goroutine. Di titik tersebut, program dihentikan dan kondisi eror dilaporkan, termasuk nilai argumen ke panic. Urutan penghentian ini disebut dengan panicking.

Fungsi recover membolehkan sebuah program mengatur perilaku dari goroutine yang panik. Misalkan sebuah fungsi G menunda fungsi D yang memanggil recover dan panik terjadi dalam sebuah fungsi pada goroutine yang sama yang mana G dieksekusi. Saat menjalankan fungsi-fungsi yang ditunda mencapai D, nilai kembalian dari pemanggilan recover di dalam D akan berisi argumen yang dikirim pada saat panic dipanggil. Jika D kembali secara normal, tanpa memulai panic yang baru, maka urutan panicking berhenti. Dalam kasus ini, status dari fungsi yang dipanggil antara G dan pemanggilan panic diindahkan, dan eksekusi normal dilanjutkan. Fungsi apa pun yang ditunda oleh G sebelum D maka kemudian dijalankan dan eksekusi dari G dihentikan dengan mengembalikan ke pemanggilnya.

Nilai kembalian dari recover adalah nil jika salah satu kondisi berikut berlaku:

Fungsi protect dalam contoh di bawah memanggil fungsi g dan melindungi pemanggil dari panik run-time yang disebabkan oleh g.

Implementasi yang sekarang menyediakan beberapa fungsi bawaan yang berguna selama bootstrapping. Fungsi-fungsi tersebut didokumentasikan demi kelengkapan namun tidak dijamin akan tetap ada dalam bahasa Go. Mereka tidak memiliki nilai kembalian.

Batasan implementasi: print dan println tidak perlu menerima tipe argumen yang beragam, namun harus mendukung pencetakan tipe boolean, numerik, dan string.

Setiap berkas sumber terdiri dari sebuah klausa paket yang mendefinisikan paket di mana ia berada, diikuti oleh deklarasi import yang bisa saja kosong yang mendeklarasikan paket-paket yang isinya akan digunakan, diikuti oleh sekumpulan deklarasi fungsi, tipe, variabel, dan konstanta.

Sebuah klausa paket memulai berkas sumber dan mendefinisikan paket yang mana berkas tersebut berada.

PackageName tidak boleh berupa pengidentifikasi kosong.

Sekumpulan berkas yang berbagi PackageName yang sama membentuk implementasi dari sebuah paket. Implementasi Go bisa saja mengharuskan semua berkas sumber untuk sebuah paket berada dalam direktori yang sama.

Sebuah deklarasi import menyatakan bahwa berkas sumber yang berisi deklarasi tersebut bergantung pada fungsionalitas dari paket yang diimpor (Inisiasi dan eksekusi program) dan membolehkan akses ke pengidentifikasi yang diekspor dari paket tersebut. Deklarasi import bisa memberi nama pada pengidentifikasi (PackageName) untuk digunakan sebagai akses dan ImportPath yang menentukan paket yang akan diimpor.

PackageName digunakan dalam pengidentifikasi nama untuk mengakses pengidentifikasi yang diekspor dari paket dalam berkas sumber yang mengimpor. Ia dideklarasikan dalam blok berkas. Jika PackageName tidak ada, maka default-nya adalah pengidentifikasi yang dispesifikasikan dalam klausa paket dari paket yang diimpor. Jika tanda titik (.) digunakan bukan sebuah nama, semua pengidentifikasi yang diekspor yang dideklarasikan dalam blok paket tersebut akan dideklarasikan dalam blok berkas sumber yang mengimpor dan harus diakses tanpa nama.

Interpretasi dari ImportPath bergantung pada implementasi namun biasanya berupa sebuah substring dari nama berkas penuh dari paket yang di-compile dan bisa jadi relatif terhadap repositori dari paket yang dipasang.

Batasan implementasi: Compiler bisa membatasi ImportPath menjadi string yang tidak kosong menggunakan hanya karakter yang berada dalam kategori umum Unicode L, M, N, P, dan S (karakter grafik tanpa spasi) dan bisa juga tidak mengikutkan karaketer !"#$%&'()*,:;⇐>?[]^{|}` dan karakter pengganti Unicode U+FFFD.

Asumsi kita telah mengkompilasi sebuah paket yang berisi klausa paket package math, yang mengekspor fungsi Sin, dan memasang paket yang telah dikompilasi dalam berkas yang diidentifikasi dengan "lib/math". Tabel berikut mengilustrasikan bagaimana Sin diakses dalam berkas yang mengimpor paket tersebut setelah deklarasi impor yang beragam.

Deklarasi import menyatakan sebuah relasi dependensi antara paket yang mengimpor dan yang diimpor. Paket tidak boleh mengimpor dirinya sendiri, baik secara langsung maupun tidak langsung, atau secara langsung mengimpor sebuah paket tanpa menggunakan pengidentifikasi yang diekspornya. Untuk mengimpor sebuah paket hanya untuk efek sampingnya saja (inisiasi), gunakan pengidentifikasi kosong sebagai nama paket yang eksplisit:

Berikut sebuah paket Go yang mengimplementasikan saringan bilangan prima secara konkuren.

Saat tempat dialokasikan untuk sebuah variabel, baik lewat deklarasi atau pemanggilan new, atau saat sebuah nilai baru dibuat, baik lewat literal komposit atau sebuah pemanggilan ke make, dan tidak ada inisiasi eksplisit yang diberikan, maka variabel atau nilai diberikan nilai default. Setiap elemen dari variabel tersebut di set ke nilai kosong bagi tipenya: false untuk boolean, 0 untuk tipe numerik, "" untuk string, dan nil untuk pointer, fungsi, interface, slice, channel, dan map. Inisiasi ini berlaku secara rekursif, jadi misalkan setiap elemen dari struct array akan memiliki field-filed yang di-nolkan jika tidak ada nilai yang dispesifikasikan.

Dua deklarasi berikut adalah sama:

Setelah

hal berikut berlaku:

Hal yang sama juga benar untuk

Dalam sebuah paket, inisiasi variabel di tingkat paket diproses secara bertahap, dengan setiap tahap memilih variabel paling awal dalam urutan deklarasi yang tidak memiliki dependensi terhadap variabel-variabel yang belum diinisiasi.

Lebih tepatnya, variabel di tingkat paket dianggap siap untuk inisiasi jika ia belum diinisiasi dan juga tidak punya ekspresi inisiasi atau ekspresi inisiasinya tidak memiliki kebergantungan terhadap variabel yang belum diinisiasi. Inisiasi diproses dengan secara berulang menginisiasi variabel tingkat-paket selanjutnya yang dideklarasikan di awal dan siap untuk inisiasi, sampai tidak ada lagi variabel siap untuk diinisiasi.

Jika ada variabel yang tetap belum diinisiasi saat proses selesai, variabel tersebut adalah bagian dari satu atau lebih putaran inisiasi, dan program tidak valid.

Sejumlah variabel pada bagian kiri dari sebuah deklarasi variabel yang diinisiasi oleh ekspresi tunggal (multi-nilai) pada bagian kanan, diinisiasi secara bersamaan: Jika ada variabel di sisi kiri diinisiasi, maka semua variabel tersebut diinisiasi dalam tahap yang sama.

Variabel kosong diperlakukan seperti halnya variabel lainnya dalam deklarasi.

Urutan deklarasi dari variabel yang dideklarasikan dalam beberapa berkas ditentukan oleh urutan yang mana berkas tersebut diberikan ke compiler: Variabel yang dideklarasikan dalam berkas yang pertama dideklarasikan sebelum variabel lain dideklarasikan di berkas yang kedua, dan seterusnya.

Analisis dependensi tidak bergantung pada nilai sebenarnya dari variabel, hanya pada referensi leksikal dalam sumber berkas, dianalisis secara transitif. Misalnya, jika ekspresi inisiasi variabel x mengacu ke sebuah fungsi yang isinya mengacu pada variabel y, maka x bergantung pada y. Secara spesifik:

Sebagai contoh, diberikan deklarasi berikut

urutan inisiasi adalah d, b, c, a. Ingatlah bahwa urutan sub-ekspresi dalam ekspresi inisiasi tidak penting: a = c + b dan a = b + c menghasilkan urutan inisiasi yang sama dalam contoh tersebut.

Analisis dependensi dilakukan per paket; hanya referensi yang mengacu ke variabel, fungsi, dan method (bukan interface) yang dideklarasikan dalam paket yang sekarang yang diperhatikan. Jika ada kebergantungan data tersembunyi ada antara variabel, urutan inisiasi antara variabel tersebut tidak ditentukan.

Misalnya, diberikan deklarasi berikut

Variabel a akan diinisiasi setelah b namun apakah x diinisiasi sebelum b, antara b dan a, atau setelah a, atau pada saat sideEffect() dipanggil (sebelum atau setelah x diinisiasi) tidak ditentukan.

Variabel juga dapat diinisiasi menggunakan fungsi bernama init yang dideklarasikan dalam blok paket, tanpa argumen dan parameter kembalian.

Satu atau lebih fungsi tersebut bisa didefinisikan per paket, bahkan dalam berkas sumber yang sama. Dalam blok paket, pengidentifikasi init hanya dapat digunakan untuk mendeklarasikan fungsi init, namun pengidentifikasi tersebut tidak dideklarasikan. Oleh sebab itu fungsi init tidak dapat diacu di mana pun dalam sebuah program.

Sebuah paket tanpa import diinisiasi dengan menempatkan nilai awal ke semua variabel di tingkat paket diikuti oleh pemanggilan fungsi init dengan urutan sebagaimana mereka muncul dalam sumber, bisa jadi dalam banyak berkas, saat diberikan kepada compiler. Jika sebuah paket memiliki import, paket-paket yang diimpor diinisiasi sebelum menginisiasi paket itu sendiri. Jika banyak paket mengimpor sebuah paket, maka paket yang diimpor hanya diinisiasi sekali. Saat mengimpor paket, secara konstruksi, menjamin bahwa tidak ada dependensi siklis.

Inisiasi paket —inisiasi variabel dan pemanggilan fungsi init— terjadi dalam sebuah goroutine, secara sekuensial, satu paket satu per satu. Fungsi init bisa meluncurkan goroutine yang lain, yang dapat berjalan secara konkuren dengan kode inisiasi. Namun, inisiasi selalu berurutan untuk fungsi init: ia tidak akan memanggil init selanjutnya sebelum yang sebelumnya selesai.

Untuk memastikan perilaku inisiasi yang dapat direproduksi, sistem pembangunan dianjurkan memberikan beberapa berkas dalam paket yang sama dengan urutan nama berkas secara leksikal kepada compiler.

Sebuah program yang lengkap dibuat dengan mengaitkan sebuah paket yang tidak diimpor bernama paket main dengan semua paket yang diimpornya, secara transitif. Paket main haruslah memiliki nama paket main dan mendeklarasikan sebuah fungsi main yang tidak menerima argumen dan tidak memiliki kembalian.

Eksekusi program dimulai dengan menginisiasi paket main dan kemudian memanggil fungsi main. Bila pemanggilan fungsi tersebut selesai, maka program keluar. Ia tidak menunggu goroutine yang lain untuk selesai.

Paket bawaan unsafe, dikenal oleh compiler dan dapat diakses lewat path import "unsafe", menyediakan fasilitas untuk pemrograman tingkat-rendah termasuk operasi yang melanggar sistem tipe. Sebuah paket yang menggunakan unsafe haruslah diperiksa secara manual demi keamanan tipe dan bisa jadi tidak portabel. Paket tersebut menyediakan interface berikut:

Sebuah Pointer adalah tipe pointer namun nilai Pointer tidak boleh di-acu ulang. Pointer atau nilai dari tipe dasar uintptr dapat dikonversi ke tipe dari tipe dasar Pointer dan sebaliknya. Efek dari mengonversi antara Pointer dan uintptr adalah terdefinisi secara implementasi.

Fungsi Alignof dan Sizeof menerima sebuah ekspresi x dengan tipe apa pun dan mengembalikan ukuran tipe dari sebuah variabel hipotesis v seolah-olah v dideklarasikan lewat var v = x.

Fungsi Offsetof menerima sebuah selector s.f, menandakan field f dari struct yang bernotasi s atau *s, dan mengembalikan posisi dari field dalam byte yang relatif terhadap alamat struct. Jika f adalah field yang ditanam, ia haruslah dapat diakses tanpa pointer lewat field-field dari struct. Untuk sebuah struct s dengan field f:

Arsitektur komputer bisa jadi membutuhkan alamat memory supaya diratakan; supaya alamat sebuah variabel merupakan kelipatan dari sebuah faktor, perataan tipe dari variabel. Fungsi Alignof menerima ekspresi yang menyatakan sebuah variabel tipe apa pun dan mengembalikan perataan dari (tipe dari) variabel dalam sekumpulan byte. Untuk sebuah variabel x:

Pemanggilan dari Alignof, Offsetof, dan Sizeof adalah ekspresi konstanta bertipe uintptr.

Untuk tipe-tipe numerik, ukuran-ukuran berikut dijamin:

Properti perataan minimum berikut selalu berlaku:

Sebuah tipe struct atau array memiliki ukuran nol jika ia tidak mengandung field (atau elemen) yang memiliki ukuran lebih besar dari nol. Dua variabel berukuran nol yang berbeda bisa saja memiliki alamat yang sama di memory.