Membandingkan Structs untuk kesamaan pergi dengan contoh

Cara yang betul untuk membandingkan struktur dalam GO ialah: 1. Penggunaan == apabila semua medan adalah setanding; 2. Apabila mengandungi medan yang tidak dapat dibandingkan (seperti Slice, Map), anda perlu membandingkan medan secara manual dengan medan; 3. Gunakan refleksi.deepequal dalam ujian atau senario kritikal yang tidak berprestasi. Khususnya, jika struktur hanya mengandungi jenis yang setanding (seperti int, rentetan, dan lain -lain), anda boleh menggunakan secara langsung == untuk menilai kesamaan; Jika ia mengandungi jenis yang tidak dapat dibentuk seperti Slice, Map, atau Func, ralat dilaporkan dalam kompilasi. Pada masa ini, nilai medan mesti dibandingkan satu demi satu melalui logik menulis; Untuk struktur bersarang kompleks atau senario ujian, refleksi. Deepequal menyediakan perbandingan kedalaman yang mudah, tetapi kerana overhead refleksi adalah tinggi dan bidang boleh dibandingkan, ia tidak disyorkan untuk kod sensitif prestasi. Ringkasan: Penggunaan == Pertama, pilih perbandingan manual atau refleksi.

Di GO, membandingkan struktur untuk kesamaan adalah mudah dalam beberapa kes tetapi mempunyai nuansa penting. Mari kita melalui ini dengan contoh untuk melihat kapan dan bagaimana perbandingan struktur berfungsi.

✅ 1. Kesamaan langsung dengan == (struktur mudah)

Jika struktur mengandungi hanya medan setanding , anda boleh menggunakan == secara langsung.

 Pakej utama

Import "FMT"

jenis titik struct {
    X, y int
}

func main () {
    p1: = titik {1, 2}
    p2: = titik {1, 2}
    p3: = titik {3, 4}

    fmt.println (p1 == p2) // benar
    fmt.println (p1 == p3) // palsu
}

Ini berfungsi kerana int adalah setanding, dan semua Point adalah setanding.

? Peraturan : Dua struktur adalah sama jika semua medan yang sama adalah sama dan medannya dapat dibandingkan.

❌ 2. Bila == gagal: medan yang tidak dapat dibandingkan

Anda tidak boleh menggunakan == jika struktur mengandungi kepingan, peta, atau fungsi - kerana jenis ini tidak dapat dibandingkan.

 jenis badstruct struct {
    Rentetan nama
    Data [] int // slice → tidak sebanding
    Peta tambahan [string] int // peta → tidak sebanding
}

func main () {
    s1: = badstruct {"test", [] int {1, 2}, map [string] int {"a": 1}}
    S2: = badstruct {"test", [] int {1, 2}, map [string] int {"a": 1}}

    // fmt.println (s1 == s2) // ❌ ralat penyusunan!
}

? Ini gagal dengan: invalid operation: s1 == s2 (struct containing []int cannot be compared)

✅ 3. Perbandingan medan demi medan manual

Bila == tidak dibenarkan, bandingkan medan secara manual.

 Functration (a, b badstruct) bool {
    jika A.name! = b.name {
        kembali palsu
    }
    jika len (a.data)! = len (b.data) {
        kembali palsu
    }
    untuk i: = julat A.Data {
        jika A.Data [i]! = b.data [i] {
            kembali palsu
        }
    }
    jika len (a.extra)! = len (b.extra) {
        kembali palsu
    }
    untuk k, v: = julat A.extra {
        jika bv, ok: = b.extra [k]; ! OK || bv! = v {
            kembali palsu
        }
    }
    kembali benar
}

Sekarang anda boleh lakukan:

 FMT.println (Struktur (S1, S2)) // TRUE (jika data sepadan)

? Ini memberikan kawalan penuh tetapi verbose. Gunakannya apabila perkara ketepatan.

✅ 4. Menggunakan reflect.DeepEqual (mudah tetapi gunakan dengan teliti)

GO's reflect.DeepEqual boleh membandingkan hampir apa -apa nilai, termasuk structs dengan irisan/peta.

 Import "Mencerminkan"

fmt.println (reflect.deepequal (s1, s2)) // true

Ia secara rekursif memeriksa nilai medan, walaupun di dalam kepingan dan peta.

? Kelebihan:

• Mudah digunakan.
• Mengendalikan struktur bersarang, kepingan, peta.

? Keburukan:

• Lebih perlahan daripada perbandingan langsung (overhead refleksi).
• Boleh terlalu mendalam (contohnya, membandingkan medan yang tidak dijangka).
• Boleh panik atau berkelakuan tanpa disangka -sangka dengan jenis tertentu (seperti fungsi).

✅ Terbaik untuk ujian atau kod kritikal yang tidak berprestasi.

? Contoh: Membandingkan struktur dalam ujian

 Func TestPoint (t *testing.t) {
    mendapat: = titik {1, 2}
    mahu: = titik {1, 2}

    jika mendapat! = mahu {
        t.errorf ("dijangkakan %v, mendapat %v", mahu, mendapat)
    }
}

Func TestComplexStruct (t *testing.t) {
    mendapat: = badstruct {"test", [] int {1, 2}, map [string] int {"a": 1}}
    mahu: = badstruct {"test", [] int {1, 2}, peta [string] int {"a": 1}}

    jika! refleksi.deepequal (mendapat, mahu) {
        t.errorf ("Tidak sama: mendapat %v, mahu %v", mendapat, mahu)
    }
}

Menggunakan reflect.DeepEqual di sini adalah perkara biasa dan boleh diterima.

Ringkasan: Cara membandingkan struktur

Pada asasnya, gunakan == apabila anda boleh, pemeriksaan manual apabila anda memerlukan kawalan, dan DeepEqual apabila kos kemudahan yang lebih tinggi.

Atas ialah kandungan terperinci Membandingkan Structs untuk kesamaan pergi dengan contoh. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!