Apa Itu Golang? Bahasa Go Dijelaskan dengan Contoh

Go adalah bahasa pemrograman yang bertipe statis dan dikompilasi, dibuat di Google. Go menghasilkan satu binary native, dikompilasi dalam hitungan detik, punya garbage collection, dan punya konkurensi yang tertanam di bahasanya lewat goroutine dan channel. Tempat utamanya adalah software di sisi server: API, layanan jaringan, serta tool command-line dan cloud yang menjalankannya.

Ini adalah program Go yang lengkap. Tekan Run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	languages := []string{"Go", "Python", "Rust"}

	for i, name := range languages {
		fmt.Printf("%d: %s has %d letters\n", i, name, len(name))
	}

	fmt.Println(strings.ToUpper("compiled, typed, garbage collected"))
}

Setiap program Go dimulai di package main pada func main(). := mendeklarasikan variabel dan menebak tipenya (di sini []string, sebuah slice berisi string). range menelusuri slice dan memberimu indeks dan nilainya. fmt dan strings berasal dari pustaka standar, yang cukup besar sehingga banyak program tidak mengimpor apa pun selain itu.

Go vs Golang: soal nama

Nama bahasanya adalah Go. "Golang" adalah nama panggilan yang berasal dari situs web pertama proyek ini, golang.org (situsnya sekarang ada di go.dev). Orang terus memakainya karena mencari "go" di web akan menampilkan apa saja kecuali bahasa ini. Dokumentasi resminya menyebut "Go", tetapi "golang" adalah kata yang diketik hampir semua orang di kotak pencarian, dan keduanya berarti hal yang sama. Tidak ada produk atau dialek "Golang" yang terpisah.

Siapa yang membuat Go dan kenapa

Robert Griesemer, Rob Pike, dan Ken Thompson mulai merancang Go di Google pada 2007. Go dirilis sebagai open source pada November 2009, dan Go 1.0 dirilis pada Maret 2012.

Motivasinya praktis. Codebase C++ dan Java yang besar di Google butuh waktu lama untuk di-build, grafik dependensinya sulit dikelola, dan mesin multicore serta layanan berbasis jaringan sudah menjadi hal biasa, tetapi menulis kode konkuren rawan kesalahan. Desain Go menjawab masalah-masalah itu secara langsung:

• Build yang cepat. Import ditulis secara eksplisit, import yang tidak dipakai adalah error kompilasi, dan compiler tidak perlu membaca ulang header, jadi program besar bisa di-build dalam hitungan detik.
• Bahasa yang sederhana. Sedikit kata kunci, satu jenis perulangan (for), tanpa inheritance, tanpa exception. Kode yang ditulis oleh orang yang berbeda cenderung terlihat mirip, yang membantu proses review di tim besar.
• Konkurensi sebagai fitur bahasa. Menjalankan tugas konkuren cukup dengan satu kata kunci, go, dan channel memungkinkan tugas-tugas itu saling berkomunikasi.
• Deployment yang mudah. Hasilnya adalah satu binary yang tinggal kamu salin ke server. Binary itu biasanya di-link secara statis; kalau cgo aktif, package seperti net bisa di-link ke library C milik sistem, dan CGO_ENABLED=0 mematikannya.

Go 1.0 juga hadir dengan janji kompatibilitas Go 1: program yang ditulis untuk Go 1.0 tetap bisa dikompilasi dan dijalankan dengan rilis 1.x berikutnya. Dalam praktiknya, artinya upgrade toolchain jarang merusak kodemu, dan itulah salah satu alasan besar tim memercayai Go untuk layanan yang berumur panjang.

Golang digunakan untuk apa

Go paling kuat ketika sebuah program berkomunikasi lewat jaringan, berjalan dalam waktu lama, dan perlu mudah dikirim ke server:

Go kurang cocok untuk aplikasi GUI desktop, aplikasi mobile, front end di browser, dan pekerjaan numerik atau machine learning, karena ekosistem lain punya library yang jauh lebih baik untuk itu.

Fitur utama, dengan kode

Tipe statis dengan inferensi

Setiap variabel punya tipe yang ditetapkan saat kompilasi, tetapi kamu jarang perlu menuliskannya. := menebaknya:

package main

import "fmt"

func main() {
	count := 3         // int
	price := 9.99      // float64
	name := "keyboard" // string
	inStock := true    // bool

	fmt.Printf("%T %T %T %T\n", count, price, name, inStock)

	total := float64(count) * price
	fmt.Printf("%d x %s = %.2f\n", count, name, total)
}

Go tidak pernah mengonversi antartipe angka secara diam-diam. count * price tidak bisa dikompilasi, karena yang satu int dan yang lain float64; kamu sendiri yang menulis float64(count). Ini mencegah bug pemotongan nilai dan presisi yang tidak terlihat.

Error adalah nilai

Go tidak punya exception. Fungsi yang bisa gagal mengembalikan error sebagai hasil terakhirnya, dan pemanggilnya yang memeriksa:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "forty-two"}

	for _, s := range inputs {
		n, err := strconv.Atoi(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", n*2)
	}
}

Pola if err != nil adalah baris yang paling mudah dikenali di kode Go. Pola ini panjang, dan memang itulah tujuannya: setiap tempat sebuah program bisa gagal terlihat jelas di tempat kejadiannya. Lihat penanganan error untuk membungkus dan memeriksa error.

Goroutine dan channel

Goroutine adalah fungsi yang berjalan secara konkuren dengan bagian program lainnya. Biayanya hanya beberapa kilobyte stack, jadi menjalankan ribuan goroutine adalah hal biasa. Channel mengirim nilai antar-goroutine dengan aman:

package main

import "fmt"

func square(n int, results chan<- string) {
	results <- fmt.Sprintf("%d squared is %d", n, n*n)
}

func main() {
	results := make(chan string)

	for n := 1; n <= 3; n++ {
		go square(n, results)
	}

	for range 3 {
		fmt.Println(<-results)
	}
}

Ketiga goroutine berjalan secara konkuren, jadi ketiga barisnya bisa tercetak dalam urutan apa pun. Jalankan beberapa kali dan kamu mungkin melihat urutan yang berbeda. main menerima tepat tiga nilai, jadi ia menunggu semuanya sebelum keluar.

Interface tanpa "implements"

Sebuah tipe memenuhi interface cukup dengan punya method yang tepat. Tidak ada kata kunci implements:

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func main() {
	shapes := []Shape{Rect{W: 3, H: 4}, Circle{R: 1}}
	for _, s := range shapes {
		fmt.Printf("%T area: %.2f\n", s, s.Area())
	}
}

Rect dan Circle tidak pernah menyebut Shape, tetapi keduanya bisa disimpan di []Shape. Ini memungkinkan kamu mendefinisikan interface di package yang memakainya, jauh setelah tipe konkretnya ditulis.

Satu toolchain

Perintah go melakukan semuanya: go run mengompilasi dan menjalankan, go build membuat binary, go test menjalankan tes, go fmt merapikan format kode, go vet menangkap konstruksi yang mencurigakan, dan go mod mengelola dependensi. Ada satu gaya format resmi yang ditegakkan oleh gofmt, jadi proyek Go tidak perlu berdebat soal kurung kurawal atau indentasi.

Hal yang sengaja tidak dimasukkan ke Go

Beberapa fitur yang umum di bahasa lain sengaja tidak ada:

• Tidak ada class atau inheritance. Kamu memakai struct, method, interface, dan embedding.
• Tidak ada exception. Error dikembalikan sebagai nilai. panic memang ada, tetapi untuk bug, bukan kegagalan biasa.
• Tidak ada operator ternary. Kamu menulis if/else.
• Tidak ada kata kunci while. for mencakup semua jenis perulangan.
• Tidak ada function overloading atau argumen default.
• Generic baru ada sejak Go 1.18, dan sengaja dibatasi dibandingkan template C++ atau generic Java.

Kelebihan dan kekurangan yang jujur

Kode yang panjang. Pemeriksaan error yang eksplisit dan tidak adanya jalan pintas seperti operator ternary membuat kode Go lebih panjang daripada kode Python atau Kotlin yang setara. Membacanya mudah; menulisnya butuh lebih banyak baris.

Garbage collection. Collector milik Go punya waktu jeda yang rendah, tetapi tetap saja sebuah garbage collector. Untuk sistem hard real-time atau kode yang setiap alokasinya penting, C, C++, atau Rust memberimu kendali yang lebih besar.

Nilai nil. Go punya pointer, map, slice, dan interface yang bisa bernilai nil. Dereference pointer nil adalah panic saat program berjalan, dan compiler tidak mencegahnya seperti yang dilakukan sistem tipe Rust.

Sistem tipe yang kecil. Tidak ada sum type, tidak ada enum (kamu membuatnya dengan konstanta dan iota), dan generic yang mencakup kasus umum tetapi tidak untuk pemrograman tingkat tipe yang canggih.

Celah di ekosistem. Library untuk layanan web, database, dan API cloud sangat bagus. Untuk GUI, komputasi ilmiah, dan machine learning, Python, C++, atau Julia punya jauh lebih banyak.

Go dibandingkan bahasa lain

Pilih Go kalau kamu menginginkan performa bahasa yang dikompilasi dan deployment yang sederhana, tanpa kurva belajar Rust atau formalitas Java.

Apakah Go layak dipelajari?

Kalau kamu menulis layanan backend, tool command-line, atau apa pun di ranah infrastruktur cloud, ya. Go adalah bahasa yang dipakai untuk menulis sebagian besar ekosistem itu, dan membaca kode sumbernya adalah bagian dari pekerjaan. Bahasanya kecil, jadi usaha yang dibutuhkan tidak besar: sintaks intinya bisa dikuasai dalam beberapa hari, sedangkan konkurensi dan penanganan error yang idiomatis butuh latihan beberapa minggu.

Untuk mulai menulis Go di komputermu, instal Go, lalu pelajari halaman hello world, yang menjelaskan setiap baris dari program pertama.