Memeriksa kesetaraan dua irisan

Bagaimana saya bisa mengecek apakah dua irisan sama?

Anda perlu mengulang setiap elemen dalam slice dan tes. Kesetaraan untuk irisan tidak ditentukan. Namun, ada bytes.Equalfungsi jika Anda membandingkan nilai tipe []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
}

Anda harus menggunakan reflect.DeepEqual ()

DeepEqual adalah relaksasi rekursif dari operator Go's ==.

DeepEqual melaporkan apakah x dan y “sama dalam,” didefinisikan sebagai berikut. Dua nilai dari jenis yang identik sangat sama jika salah satu dari kasus berikut ini berlaku. Nilai dari tipe yang berbeda tidak pernah sama dalam.

Nilai-nilai array sangat sama ketika elemen-elemen terkaitnya sangat sama.

Nilai-nilai Struct sangat sama jika bidang yang sesuai, baik yang diekspor maupun yang tidak diekspor, sangat sama.

Nilai fungsi sangat sama jika keduanya nol; kalau tidak mereka tidak sederajat.

Nilai antarmuka sangat sama jika mereka memegang nilai konkrit yang sangat sama.

Nilai peta sangat sama jika mereka adalah objek peta yang sama atau jika mereka memiliki panjang yang sama dan kunci yang sesuai (cocok dengan menggunakan kesetaraan Go) memetakan ke nilai yang sangat sama.

Nilai pointer sangat sama jika mereka sama dengan menggunakan operator Go == atau jika mereka menunjuk ke nilai yang sangat sama.

Nilai slice sangat sama ketika semua hal berikut ini benar: keduanya nihil atau keduanya bukan nihil, keduanya memiliki panjang yang sama, dan keduanya menunjuk ke entri awal yang sama dari array mendasar yang sama (yaitu, & x [0 ] == & y [0]) atau elemen yang sesuai (hingga panjang) sangat sama. Perhatikan bahwa irisan kosong non-nil dan irisan nil (misalnya, [] byte {} dan [] byte (nil)) tidak sama dalam.

Nilai lain - angka, bools, string, dan saluran - sangat sama jika mereka sama dengan menggunakan operator Go ==.

Ini hanya contoh menggunakan reflect.DeepEqual () yang diberikan dalam jawaban @ 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))

}

Hasil:

true
false

Cobalah di Go Playground

Jika Anda memiliki dua []byte, bandingkan menggunakan byte . Sama . Dokumentasi Golang mengatakan:

Equal mengembalikan boolean yang melaporkan apakah a dan b memiliki panjang yang sama dan berisi byte yang sama. Argumen nil setara dengan irisan kosong.

Pemakaian:

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))
}

Ini akan dicetak

true
false

Dan untuk saat ini, berikut adalah https://github.com/google/go-cmp yang

dimaksudkan untuk menjadi alternatif yang lebih kuat dan lebih aman reflect.DeepEqualuntuk membandingkan apakah dua nilai secara semantik sama.

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
}

Jika Anda tertarik untuk menulis tes, maka github.com/stretchr/testify/assert adalah teman Anda.

Impor perpustakaan di awal file:

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

Kemudian di dalam tes yang Anda lakukan:

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

Kesalahan yang diminta adalah:

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