Golang cheat sheet ```
Perintah dan konstruksi golang yang berguna ```
Berikut adalah struktur dasar program Go, pola penanganan kesalahan dan perbandingan antara channel vs goroutines.
Cheatsheet Bahasa Go
Sintaks Dasar
Pengisian Paket
package main
Mengimpor Paket
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)
Peta (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 membentuk dasar untuk menulis kode Go yang efisien dan jelas.
Penanganan Kesalahan dalam Go
Penanganan kesalahan dalam Go sederhana dan eksplisit, menekankan kejelasan dan ketangguhan. Berikut adalah teknik utama untuk menangani kesalahan dalam Go:
- Kembalikan kesalahan sebagai nilai: Fungsi yang dapat gagal sebaiknya 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 menyebarkan 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: Gunakandefer
untuk memastikan sumber daya ditutup atau dibersihkan dengan benar, bahkan jika terjadi kesalahan. -
Buat tipe kesalahan khusus: Implementasikan antarmuka
error
untuk tipe kesalahan khusus untuk memberikan informasi kesalahan yang lebih rinci. -
Gunakan paket
errors
: Manfaatkan fungsi sepertierrors.New()
untuk membuat pesan kesalahan sederhana, danerrors.Is()
atauerrors.As()
untuk pemeriksaan dan konversi tipe kesalahan. -
Hindari menggunakan
panic
: Simpanpanic
untuk situasi yang benar-benar tidak dapat dipulihkan. Penanganan kesalahan normal sebaiknya 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 tangguh 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: Pertimbangkan apakah tugas tersebut benar-benar mendapatkan manfaat dari eksekusi konkuren sebelum menggunakan goroutines.
Penggunaan Efektif Channel
-
Pilih jenis channel yang tepat: Gunakan channel non-buffered untuk sinkronisasi dan channel buffered ketika Anda perlu memisahkan operasi pengiriman dan penerimaan.
-
Kapasitas buffer: Ketika menggunakan channel buffered, 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 pernyataandefer
untuk memastikan pembersihan sumber daya yang tepat, bahkan dalam kehadiran kesalahan. -
Tangani panic: Implementasikan
recover()
dalam goroutines yang berjalan lama untuk mencegah seluruh program dari 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
-
Batasi 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 keandalannya.
Dengan mengikuti praktik terbaik ini, Anda dapat secara efektif memanfaatkan model konkuren Go, membuat program Anda lebih efisien, mudah dipelihara, dan kurang rentan terhadap masalah umum yang terkait konkuren.
Lihat artikel blog teknis lainnya.
Memperbarui golang di linux
- pergi dan unduh versi baru: https://go.dev/doc/install
- hapus versi lama:
sudo rm -rf /usr/local/go
- instal versi baru:
cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz
Tautan yang Berguna
- https://go.dev/
- Membuat PDF dalam GO - Perpustakaan dan contoh
- Kinerja AWS lambda: JavaScript vs Python vs Golang
- Memperbaiki kesalahan GORM AutoMigrate postgresql
- Menginstal ulang linux
- Bash Cheat Sheet
- Markdown Cheatsheet
- Mendekode dan mencetak token JWT
- Popularitas bahasa pemrograman dan kerangka kerja
- Ruang Golang
- Alternatif Beautiful Soup untuk Go