Belajar Golang dalam Anda Tidak Akan Menyesal

Seperti yang saya jelaskan dalam artikel sebelumnya, kami sedang berusaha untuk membina LiveAPI, alat penjanaan dokumen auto-API. Bahagian belakang LiveAPI berada di Golang dan saya sedang menemui ciri unik dan hebat Golang.

Bagi mereka yang tidak tahu, Golang (Go) ialah bahasa pengaturcaraan yang direka di Google pada tahun 2009. Ia serupa dengan sintaksis C.

Sebelum mengerjakan projek Golang, saya menggunakan rangka kerja web Node.js dan Python. Bagi pemula beralih ke Golang daripada domain lain, ia mungkin agak sukar pada mulanya, tetapi sebaik sahaja anda berlatih dan memperoleh kepakaran, anda tidak akan meninggalkannya.

Projek Golang pertama saya ialah menukar alat Python CLI, Glee, kepada Golang.

Kami mendapati Python lebih perlahan dan mengekalkan satu binari CLI tersusun adalah sangat sukar, binari kadangkala tidak serasi dengan Mac OS. Isu-isu ini dan lain-lain memaksa kami beralih ke Golang. Berikut ialah siaran Reddit tentang cerita dan isu di sebalik suis.

Dalam artikel ini, saya akan menerangkan ciri unik di Golang yang menarik perhatian saya.

1. Goroutines - Concurrency Ringan

func main() {
    go sayHello("World") // runs concurrently
    time.Sleep(1 * time.Second) 
}

func sayHello(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

Fikirkan goroutine seperti pekerja kecil yang boleh melakukan tugasan secara bebas. Ia jauh lebih ringan daripada benang tradisional - anda boleh mencipta beribu-ribu daripadanya tanpa mendapat prestasi.

2. Saluran - Komunikasi Terbina dalam

func main() {
    messages := make(chan string)
    go func() { messages <- "ping" }()
    msg := <-messages
    fmt.Println(msg)
}

Saluran adalah seperti paip yang membolehkan goroutine berkomunikasi dengan selamat. Bayangkan dua orang menghantar nota melalui tiub - seorang menulis dan memasukkannya ke dalam, seorang lagi mengeluarkannya.

3. Tangguh - Pembersihan Dipermudahkan

func readFile() {
    file, err := os.Open("test.txt")
    defer file.Close() // Will run when function exits 
}

Tangguhan adalah seperti menetapkan peringatan untuk tugas pembersihan. Ia sama seperti menulis nota post-it yang mengatakan "jangan lupa tutup fail" sebaik sahaja anda membukanya.

4. Pelaksanaan Antara Muka - Kontrak Tersirat

type Writer interface {
    Write([]byte) (int, error)
}

type ConsoleWriter struct{}

func (cw ConsoleWriter) Write(data []byte) (int, error) {
    return fmt.Println(string(data))
}

Antara muka Go berpuas hati secara tersirat - jika sesuatu jenis mempunyai kaedah yang betul, ia secara automatik melaksanakan antara muka. Ia seperti menyertai kelab: anda tidak perlu mengisytiharkan keahlian secara rasmi; jika anda boleh melakukan apa yang diperlukan oleh kelab, anda akan masuk secara automatik.

5. Nilai Pulangan Berbilang - Pengendalian Ralat Asli

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

Nilai pulangan berbilang menjadikan pengendalian ralat semula jadi dan eksplisit dalam Go. Ia seperti mendapatkan pakej dan resit semasa membeli-belah - anda boleh menyemak sama ada semuanya baik-baik saja sebelum meneruskan. Corak ini menggalakkan pembangun mengendalikan ralat dengan betul.

Ini hanyalah beberapa ciri yang saya suka dalam Go. Terdapat juga yang lain, seperti perduaan boleh laku tunggal, prestasi lebih pantas, inferens jenis, sokongan ujian terbina dalam dan kompilasi silang.

Jika anda membuat azam untuk 2025, tambahkan Golang pada senarai anda. Anda tidak akan menyesal. Terima kasih kerana membaca! Jika anda ingin mempelajari Golang dengan menyumbang kepada projek sumber terbuka, lihat glee dan Lama2.

Atas ialah kandungan terperinci Belajar Golang dalam Anda Tidak Akan Menyesal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!