ตรวจสอบความเท่าเทียมกันของสองชิ้น

ฉันจะตรวจสอบว่ามีสองส่วนเท่ากันได้อย่างไร

คุณจำเป็นต้องวนซ้ำแต่ละองค์ประกอบในชิ้นและทดสอบ ความเท่าเทียมกันสำหรับชิ้นไม่ได้กำหนดไว้ แต่มีฟังก์ชั่นถ้าคุณกำลังเปรียบเทียบค่าประเภทbytes.Equal[]byte

func testEq(a, b []Type) bool {

    // If one is nil, the other must also be nil.
    if (a == nil) != (b == nil) { 
        return false; 
    }

    if len(a) != len(b) {
        return false
    }

    for i := range a {
        if a[i] != b[i] {
            return false
        }
    }

    return true
}

คุณควรใช้reflect.deepEqual ()

DeepEqual เป็นการพักผ่อนแบบวนซ้ำของโอเปอเรเตอร์ == ของโก

DeepEqual รายงานว่า x และ y เป็น“ ลึกเท่ากัน” กำหนดไว้ดังต่อไปนี้ ค่าสองประเภทที่เหมือนกันจะเท่ากันอย่างยิ่งถ้าหนึ่งในกรณีต่อไปนี้ใช้ ค่าของประเภทที่แตกต่างจะไม่เท่ากันอย่างลึกซึ้ง

ค่าอาร์เรย์มีค่าเท่ากันเมื่อองค์ประกอบที่เกี่ยวข้องมีค่าเท่ากัน

ค่าโครงสร้างจะเท่ากันอย่างยิ่งถ้าเขตข้อมูลที่สอดคล้องกันทั้งที่เอ็กซ์พอร์ตและเอ็กซ์พอร์ตนั้นมีค่าเท่ากัน

ค่าของ Func มีค่าเท่ากันถ้าทั้งคู่เป็นศูนย์ ไม่อย่างนั้นจะไม่ลึกเท่ากัน

ค่าอินเทอร์เฟซจะเท่ากันอย่างล้ำลึกหากพวกเขามีค่าที่เป็นรูปธรรมลึก

ค่าแผนที่จะเท่ากันอย่างยิ่งหากพวกเขาเป็นวัตถุแผนที่เดียวกันหรือหากพวกเขามีความยาวเท่ากันและแผนที่ที่สำคัญของพวกเขา

ค่าตัวชี้จะเท่ากันอย่างยิ่งหากพวกเขามีค่าเท่ากันโดยใช้ตัวดำเนินการ == ของ Go หรือถ้าพวกเขาชี้ไปที่ค่าที่เท่ากันอย่างลึกซึ้ง

ค่า Slice มีความลึกเท่ากันเมื่อทั้งหมดต่อไปนี้เป็นจริง: ทั้งสองเป็นศูนย์หรือไม่มีทั้งคู่พวกเขามีความยาวเท่ากันและทั้งคู่ชี้ไปที่รายการเริ่มต้นเดียวกันของอาร์เรย์ต้นแบบเดียวกัน (นั่นคือ & x [0 ] == & y [0]) หรือองค์ประกอบที่เกี่ยวข้อง (ยาวถึง) เท่ากับกัน โปรดทราบว่าส่วนที่ไม่ว่างเปล่าที่ไม่ใช่ศูนย์และชิ้นส่วนศูนย์ (ตัวอย่างเช่น [] ไบต์ {} และ [] ไบต์ (ศูนย์)) จะไม่เท่ากันอย่างลึกซึ้ง

ค่าอื่น ๆ - ตัวเลข, bools, สตริง, และแชนเนล - เท่ากันหากพวกเขาเท่ากันโดยใช้โอเปอเรเตอร์ == Go's

นี่เป็นเพียงตัวอย่างการใช้reflect.DeepEqual ()ที่ให้ไว้ในคำตอบ @ VictorDeryagin

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := []int {4,5,6}
    b := []int {4,5,6}
    c := []int {4,5,6,7}

    fmt.Println(reflect.DeepEqual(a, b))
    fmt.Println(reflect.DeepEqual(a, c))

}

ผลลัพธ์:

true
false

ลองใช้ในสนามเด็กเล่นไป

หากคุณมีสอง[]byteเปรียบเทียบพวกเขาโดยใช้bytes.Equal เอกสารประกอบของ Golang พูดว่า:

เท่ากับคืนค่าบูลีนที่รายงานว่า a และ b มีความยาวเท่ากันและมีไบต์เดียวกัน อาร์กิวเมนต์ศูนย์จะเทียบเท่ากับชิ้นว่าง

การใช้งาน:

package main

import (
    "fmt"
    "bytes"
)

func main() {
    a := []byte {1,2,3}
    b := []byte {1,2,3}
    c := []byte {1,2,2}

    fmt.Println(bytes.Equal(a, b))
    fmt.Println(bytes.Equal(a, c))
}

สิ่งนี้จะพิมพ์

true
false

และตอนนี้ที่นี่เป็นhttps://github.com/google/go-cmpซึ่ง

มีวัตถุประสงค์เพื่อเป็นทางเลือกที่มีประสิทธิภาพและปลอดภัยยิ่งขึ้นreflect.DeepEqualสำหรับการเปรียบเทียบว่าสองค่ามีความหมายเท่าเทียมกัน

package main

import (
    "fmt"

    "github.com/google/go-cmp/cmp"
)

func main() {
    a := []byte{1, 2, 3}
    b := []byte{1, 2, 3}

    fmt.Println(cmp.Equal(a, b)) // true
}

ในกรณีที่คุณมีความสนใจในการเขียนแบบทดสอบgithub.com/stretchr/testify/assertเพื่อนของคุณก็คือ

นำเข้าไลบรารีที่จุดเริ่มต้นของไฟล์:

import (
    "github.com/stretchr/testify/assert"
)

จากนั้นในการทดสอบที่คุณทำ:

func TestEquality_SomeSlice (t * testing.T) {
    a := []int{1, 2}
    b := []int{2, 1}
    assert.Equal(t, a, b)
}

ข้อผิดพลาดที่แจ้งจะเป็น:

                Diff:
                --- Expected
                +++ Actual
                @@ -1,4 +1,4 @@
                 ([]int) (len=2) {
                + (int) 1,
                  (int) 2,
                - (int) 2,
                  (int) 1,
Test:           TestEquality_SomeSlice