Golang Asas - Perbandingan Kesaksamaan

Siaran ini adalah sebahagian daripada siri di mana saya berhasrat untuk berkongsi asas penting untuk membangun dengan GoLang.

Perbandingan logik menggunakan operator == atau != tidak mempunyai banyak misteri. Atau kod anda membandingkan sama ada nilainya sama atau berbeza.
Tetapi terdapat beberapa butiran penting untuk diketahui tentang perkara yang anda bandingkan.

Antara Muka Setanding

Perkara pertama ialah mengetahui perkara yang boleh dibandingkan dengan pengendali ini, tempat yang paling jelas untuk mengetahui ini ialah dokumentasi Go: bahagian tentang pembanding

Dan pilihan lain ialah melihat antara muka yang setanding, yang telah ditambahkan bersama-sama dengan pelaksanaan generik Go, semua jenis yang melaksanakan antara muka ini adalah setanding.

Jadi pada asasnya semua jenis primitif yang ditakrifkan oleh Go adalah setanding, seperti: rentetan, nombor (int, float, kompleks), bool.

Perbandingan jenis kompleks

Sesetengah jenis mempunyai syarat untuk setanding atau tidak. Yang manakah kes: struct, kepingan dan saluran.
Mereka hanya setanding jika elemen mereka juga setanding.
Perkara yang menarik ialah Go mengesahkan ini pada tahap kompilasi, membantu anda mengelakkan ralat masa jalan, contohnya:

//Esse código compila e a comparação funciona:
func main() {
    test1 := struct {
        name       string
    }{}
    test2 := struct {
        name       string
    }{}
    if test1 == test2 {
        fmt.Println("Funciona")
    }
}

Dalam kod di atas saya mencipta dua struct dengan atribut yang setara dan perbandingan berfungsi.

//Esse código não compila
func main() {
    test1 := struct {
        name       string
        attributes map[string]string
    }{}
    test2 := struct {
        name       string
        attributes map[string]string
    }{}
    if test1 == test2 {
        fmt.Println("Cade?")
    }
}

Kod ini akan gagal untuk menyusun dengan ralat operasi tidak sah.

Ini berlaku kerana peta bukan jenis yang setanding dalam Go.

Butiran tentang struct dan peta

Sangat mudah untuk dapat membandingkan struct dengan ==, kerana ini adalah jenis yang kami sesuaikan pemodelan kami.
Tetapi walaupun menggunakan jenis yang tidak setanding, terdapat beberapa cara untuk memudahkan kod dan mengetahui perkara ini akan menyelamatkan anda daripada menulis keadaan yang benar-benar membosankan.

Baiklah, mari kita bayangkan bahawa kita bekerja dalam sistem sekolah dan kita mempunyai struktur tidak setanding berikut:

type student struct {
    ID         int
    name       string
    age        int
    course     string
    attributes map[string]string
}

Bahagian baiknya, struct ini mempunyai medan ID, yang menjadikannya lebih mudah jika anda menggunakan data yang berterusan.

Sekarang bayangkan jika anda menggunakan data yang masih bersifat sementara, contohnya jika anda sedang membaca fail dan perlu melakukan beberapa jenis pemprosesan sebelum meneruskan data ini.

Anda akan sentiasa mempunyai pilihan untuk membandingkan medan demi medan, ia tidak mudah sama sekali, tetapi ia berkesan. Tetapi anda boleh menggunakan komposisi struct seperti berikut:

func main() {
    type identity struct {
        name   string
        age    int
        course string
    }
    type student struct {
        ID int
        identity
        attributes map[string]string
    }

    s1 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "10",
        },
    }
    s2 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    s3 := student{
        identity: identity{
            name:   "Chuck",
            age:    12,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    if s1.identity == s2.identity {
        fmt.Println("Achou", s1)
    }

    if s1.identity != s3.identity {
        fmt.Println("Não achou")
    }
}

Alternatif kepada kod ini ialah mencipta keadaan seperti ini:

    if s1.name == s2.name && s1.age == s2.age && s1.course == s2.course {
        fmt.Println("Achou", s1)
    }

Anda boleh mengekstraknya ke fungsi, untuk menjadikannya kurang mengelirukan, tetapi anda masih perlu mengekalkan perbandingan ini.

Gunakan komposisi dengan baik ini boleh memudahkan kod anda!

Ringkasan

• Ketahui tentang antara muka yang setanding
• Jenis primitif adalah setanding
• Jenis kompleks mungkin atau mungkin tidak setanding
• Gunakan gubahan untuk kelebihan anda.

Atas ialah kandungan terperinci Golang Asas - Perbandingan Kesaksamaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!