Golang cheat sheet

Perintah dan konstruksi golang yang berguna

Konten Halaman

Berikut adalah struktur dasar program Go, pola penanganan kesalahan dan perbandingan antara channel vs goroutines.

bunnies around golang sign

Cheatsheet Bahasa Go

Sintaks Dasar

Pengisian Package

package main

Mengimpor Package

import "fmt"
import (
    "fmt"
    "math"
)

Fungsi Utama

func main() {
    // Kode Anda di sini
}

Variabel dan Tipe

Deklarasi Variabel

var name string
var age int = 25
x := 10 // Deklarasi singkat

Tipe Dasar

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128

Struktur Kontrol

Pernyataan If

if x > 0 {
    // kode
} else if x < 0 {
    // kode
} else {
    // kode
}

Perulangan For

for i := 0; i < 10; i++ {
    // kode
}

Perulangan Range

for index, value := range collection {
    // kode
}

Pernyataan Switch

switch variable {
case value1:
    // kode
case value2:
    // kode
default:
    // kode
}

Fungsi

Deklarasi Fungsi

func functionName(param1 type1, param2 type2) returnType {
    // kode
    return value
}

Nilai Pengembalian Ganda

func divideAndRemainder(x, y int) (int, int) {
    return x / y, x % y
}

Struktur Data

Array

var numbers int
numbers := int{1, 2, 3, 4, 5}

Slice

slice := []int{1, 2, 3}
slice := make([]int, 3, 5)

Map

m := make(map[string]int)
m["key"] = value

Struct

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}

Metode

Deklarasi Metode

func (r Rectangle) Area() float64 {
    return r.width * r.height
}

Interface

Deklarasi Interface

type Shape interface {
    Area() float64
}

Konkurensi

Goroutines

go functionName()

Channel

ch := make(chan int)
ch <- value  // Mengirim
value := <-ch  // Menerima

Penanganan Kesalahan

Pemeriksaan Kesalahan

if err != nil {
    // Menangani kesalahan
}

Defer

defer file.Close()

Pengujian

Fungsi Pengujian

func TestFunction(t *testing.T) {
    // Kode pengujian
}

Cheatsheet ini mencakup konstruksi dan perintah bahasa Go yang paling penting. Ini mencakup sintaks dasar, struktur kontrol, fungsi, struktur data, metode, interface, primitif konkurensi, dan penanganan kesalahan. Ingatlah bahwa Go menekankan kesederhanaan dan keterbacaan, sehingga konstruksi ini menjadi fondasi untuk menulis kode Go yang efisien dan jelas.

Penanganan Kesalahan dalam Go

Penanganan kesalahan dalam Go sederhana dan eksplisit, menekankan kejelasan dan ketahanan. Berikut adalah teknik utama untuk menangani kesalahan dalam Go:

Kembalikan kesalahan sebagai nilai: Fungsi yang dapat gagal harus mengembalikan kesalahan sebagai nilai pengembalian terakhir. Contohnya:

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("empty name")
    }
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message, nil
}

Selalu periksa kesalahan: Setelah memanggil fungsi yang mengembalikan kesalahan, periksa segera apakah kesalahan tidak nol. Contohnya:

result, err := SomeFunction()
if err != nil {
    // Menangani kesalahan
    log.Fatal(err)
}

Gunakan pengemasan kesalahan: Saat mengirimkan kesalahan ke atas tumpukan panggilan, bungkuslah untuk menambahkan konteks menggunakan fmt.Errorf() dengan verba %w. Contohnya:

f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("open failed: %w", err)
}

Gunakan defer untuk pembersihan: Gunakan defer untuk memastikan sumber daya ditutup atau dibersihkan dengan benar, bahkan jika terjadi kesalahan.
Buat jenis kesalahan kustom: Implementasikan antarmuka error untuk jenis kesalahan kustom untuk memberikan informasi kesalahan yang lebih rinci.
Gunakan paket errors: Manfaatkan fungsi seperti errors.New() untuk membuat pesan kesalahan sederhana, dan errors.Is() atau errors.As() untuk pemeriksaan dan konversi jenis kesalahan.
Hindari menggunakan panic: Simpan panic untuk situasi yang benar-benar tidak dapat dipulihkan. Penanganan kesalahan normal harus menggunakan nilai pengembalian.
Berikan informasi kesalahan yang eksplisit: Buat pesan kesalahan yang jelas dan informatif untuk membantu debugging dan pemecahan masalah.

Dengan mengikuti praktik-praktik ini, Anda dapat membuat program Go yang kuat yang menangani kesalahan secara efektif dan menjaga kejelasan kode.

Praktik Terbaik untuk Goroutines dan Channels dalam Go

Penggunaan Efisien Goroutines

Hindari pembuatan goroutine berlebihan: Buat goroutine secara bijak, mempertimbangkan sifat tugas dan apakah tugas tersebut akan mendapatkan manfaat dari eksekusi paralel.
Sinkronisasi yang tepat: Gunakan mekanisme sinkronisasi seperti channel atau wait groups untuk mengelola goroutine secara efektif dan mencegah pemborosan sumber daya.
Evaluasi sifat tugas: Periksa apakah tugas benar-benar mendapatkan manfaat dari eksekusi konkuren sebelum menggunakan goroutines.

Penggunaan Efektif Channel

Pilih jenis channel yang tepat: Gunakan channel tidak terbuffer untuk sinkronisasi dan channel terbuffer ketika Anda perlu memisahkan operasi pengiriman dan penerimaan.
Kapasitas buffer: Ketika menggunakan channel terbuffer, pertimbangkan ukuran buffer dengan hati-hati untuk menyeimbangkan kinerja dan penggunaan sumber daya.
Tutup channel dengan benar: Pastikan channel ditutup ketika tidak ada lagi data yang akan dikirim untuk mencegah deadlock dan kebocoran sumber daya.

Pola Konkurensi

Pola Pool Pekerja: Implementasikan pool pekerja menggunakan goroutines dan channel untuk distribusi tugas dan pengumpulan hasil yang efisien.
Pola Produsen-Konsumen: Gunakan goroutines sebagai produsen dan konsumen, dengan channel memfasilitasi aliran data antara keduanya.

Penanganan Kesalahan dan Manajemen Sumber Daya

Gunakan defer untuk pembersihan: Gunakan pernyataan defer untuk memastikan pembersihan sumber daya yang tepat, bahkan dalam keberadaan kesalahan.
Tangani panic: Implementasikan recover() dalam goroutines yang berjalan lama untuk mencegah seluruh program crash akibat panic dalam satu goroutine.

Komunikasi dan Sinkronisasi

Lebih baik menggunakan channel daripada memori bersama: Gunakan channel untuk komunikasi antar goroutines untuk menghindari kondisi race dan menyederhanakan sinkronisasi.
Gunakan select untuk beberapa channel: Gunakan pernyataan select untuk menangani beberapa operasi channel secara konkuren.

Pertimbangan Kinerja

Batas operasi konkuren: Gunakan semaphore atau pool pekerja untuk membatasi jumlah operasi konkuren dan mencegah kehabisan sumber daya.
Hindari optimisasi terlalu dini: Profil kode Anda untuk mengidentifikasi bottleneck sebelum menerapkan optimasi konkuren.

Pengujian dan Debugging

Gunakan detektor race: Jalankan pengujian Anda secara rutin dengan flag -race untuk mendeteksi race condition.
Buat pengujian konkuren: Buat pengujian yang secara khusus menguji jalur kode konkuren Anda untuk memastikan keandalan.

Dengan mengikuti praktik terbaik ini, Anda dapat memanfaatkan model konkuren Go secara efektif, membuat program Anda lebih efisien, mudah dipelihara, dan kurang rentan terhadap masalah umum yang terkait konkurensi.

Lihat artikel blog teknis lainnya.

Memperbarui golang di linux

pergi dan unduh versi baru: https://go.dev/doc/install
hapus yang lama:

sudo rm -rf /usr/local/go

instal yang baru:

cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz