Ringkaskan beberapa postur golang yang salah

Bahasa Go, sebagai bahasa baru muncul yang agak popular sejak beberapa tahun kebelakangan ini, telah digunakan secara meluas dalam pelayan rangkaian, sistem teragih dan medan lain. Disebabkan kesederhanaan, kemudahan pembelajaran dan penggunaan, keselarasan tinggi dan sokongan perpustakaan standard yang berkuasa, semakin ramai jurutera memilih untuk menggunakan Go untuk pembangunan. Walau bagaimanapun, seperti mana-mana bahasa, anda mungkin menghadapi pelbagai ralat semasa penggunaan. Artikel ini akan meringkaskan beberapa postur ralat golang biasa, dengan harapan dapat membantu pembangun bahasa Go mengelakkan dan menyelesaikan masalah ini dengan lebih baik.

1. Masalah penuding nol

Penunjuk dalam bahasa Go menjadi lalai semasa pemulaan Jika ia digunakan secara langsung tanpa penetapan, masalah penunjuk nol akan berlaku. Dalam atur cara, membatalkan rujukan langsung penunjuk nol akan menyebabkan atur cara ranap. Penyelesaian biasa ialah membuat pertimbangan sebelum menggunakan penunjuk untuk menentukan sama ada ia adalah penunjuk nol. Kod sampel adalah seperti berikut:

var p *int
if p == nil {
    p = new(int)
}

2. Masalah penukaran rentetan

Terdapat dua cara untuk menukar rentetan dalam bahasa Go. Satu ialah menukar rentetan kepada bait adalah untuk menukar tatasusunan bait kepada rentetan. Jika digunakan secara tidak betul, ia boleh menyebabkan pelbagai masalah pelik dalam program.

1. Tukar rentetan kepada tatasusunan bait:

s := "hello world"
b := []byte(s)

2. Tukar tatasusunan bait kepada rentetan:

b := []byte{104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100}
s := string(b)

Sepatutnya ambil perhatian bahawa apabila menukar tatasusunan bait kepada rentetan, tatasusunan bait mestilah dalam format pengekodan UTF-8, jika tidak, ia akan bercelaru atau penyahkodan akan gagal.

3. Masalah yang disebabkan oleh penyataan tangguh

Pernyataan penangguhan dalam bahasa Go boleh digunakan untuk mendaftarkan panggilan fungsi, dan fungsi ini akan dilaksanakan secara berurutan apabila fungsi itu kembali. Walaupun ciri ini sangat berguna, anda juga harus berhati-hati untuk mengelakkan beberapa masalah yang sukar ditemui semasa menggunakannya.

Pertimbangkan kod berikut:

func foo() (err error) {
    defer func() {
        if err != nil {
            fmt.Println("defer recover: ", err)
            err = nil
        }
    }()
    return errors.New("bar")
}

Dalam kod ini, panik ditangkap dalam penyata tangguh dan nilai pulangan ralat diubah suai kepada sifar. Walau bagaimanapun, kod di atas tidak mempunyai kesan yang diharapkan. Penyata pulangan Go telah memberikan nilai pulangan kepada pembolehubah yang sepadan semasa penyusunan, dan pengubahsuaian pembolehubah dengan nama yang sama dalam penangguhan tidak akan menjejaskan nilai pulangan yang ditetapkan. Oleh itu, kod di atas akan mengembalikan objek ralat bukan nol dan bukannya nil, menyebabkan pemanggil tidak dapat mengendalikan nilai pulangan dengan betul.

Cara biasa untuk menyelesaikan masalah sedemikian adalah dengan menggunakan nilai pulangan yang dinamakan, iaitu, berikan nama kepada nilai pulangan apabila fungsi ditakrifkan dan ubah suai nama terus di dalam fungsi:

func foo() (err error) {
    defer func() {
        if err != nil {
            fmt.Println("defer recover: ", err)
            err = nil
        }
    }()
    err = errors.New("bar")
    return
}

4. Isu concurrency

Sebagai bahasa, bahasa Go menyokong concurrency apabila direka, menjadikannya sangat mudah untuk menulis program concurrency tinggi. Walau bagaimanapun, penggunaan yang tidak betul juga boleh menyebabkan masalah.

goroutine dan saluran dalam bahasa Go ialah dua konsep utama pengaturcaraan serentak. Apabila menggunakan, anda harus memberi perhatian kepada perkara berikut:

1. Elakkan akses serentak ke memori yang dikongsi: Apabila berbilang gorout mengubah suai pembolehubah yang sama secara serentak, keadaan perlumbaan akan berlaku, menyebabkan tingkah laku program menjadi Sangat tidak pasti. Pada masa ini, mekanisme seperti kunci atau operasi atom harus digunakan untuk memastikan ketekalan ingatan.
2. Elakkan kebuntuan: Apabila menggunakan saluran, penjagaan harus diambil untuk mengelakkan situasi kebuntuan. Kebuntuan biasanya disebabkan oleh penghantaran dan penerimaan saluran bukan berpasangan. Apabila menulis kod, anda harus membangunkan tabiat yang baik untuk memastikan operasi hantar dan terima berlaku secara berpasangan.

5. Isu import pakej

Pernyataan import digunakan dalam bahasa Go untuk mengimport pakej lain Jika digunakan secara tidak betul, ia juga akan menyebabkan beberapa masalah.

1. Import pakej yang tidak diperlukan: Semasa menulis kod, anda harus membangunkan tabiat yang baik dan hanya mengimport pakej yang perlu anda gunakan. Jika pakej yang tidak diperlukan diimport, kerumitan dan penggunaan memori program akan meningkat.
2. Masalah kebergantungan bulat: Apabila terdapat kebergantungan bulat antara pakej, pengkompil tidak akan dapat menyusun seperti biasa. Pada ketika ini, mekanisme seperti antara muka harus digunakan untuk menyelesaikan kebergantungan.

Artikel ini meringkaskan beberapa kesilapan biasa dalam pembangunan bahasa Go, termasuk masalah penuding nol, masalah penukaran rentetan, masalah yang disebabkan oleh penyataan penangguhan, masalah konkurensi dan masalah import pakej, dsb. Saya harap ringkasan ini dapat membantu pembangun bahasa Go menggunakan bahasa yang berkuasa ini dan menulis kod yang lebih baik.

Atas ialah kandungan terperinci Ringkaskan beberapa postur golang yang salah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!