İki dilimin eşitliğini kontrol etme

İki dilimin eşit olup olmadığını nasıl kontrol edebilirim?

Dilim ve öğelerin her biri üzerinde döngü ve test gerekir. Dilimler için eşitlik tanımlanmamıştır. Ancak, bytes.Equaltür değerlerini karşılaştırıyorsanız bir işlev vardır []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
}

Refl.DeepEqual () öğesini kullanmalısınız

DeepEqual, Go'nun == operatörünün yinelemeli bir gevşemesidir.

DeepEqual, x ve y'nin “derinden eşit” olup olmadığını bildirir ve aşağıdaki gibi tanımlanır. Aşağıdaki durumlardan biri geçerliyse, aynı türdeki iki değer tamamen eşittir. Farklı türlerin değerleri asla derinden eşit değildir.

Dizi değerleri, karşılık gelen öğeleri derin eşit olduğunda eşittir.

Yapı değerleri, hem dışa aktarılan hem de dışa aktarılan karşılık gelen alanları derinden eşitse, derinden eşittir.

Her ikisi de sıfırsa işlev değerleri derinden eşittir; aksi halde derinden eşit değildirler.

Arayüz değerleri, derinden eşit beton değerlerine sahiplerse derinden eşittir.

Eşleme değerleri aynı eşleme nesnesi olmaları veya aynı uzunluklara sahip olmaları ve karşılık gelen anahtarları (Git eşitliği kullanılarak eşleştirildikleri) eşleme değerleriyle eşleştirmek için eşleme değerleri çok eşittir.

İşaretçi değerleri, Go'nun == işleci kullanılarak eşitse veya derinden eşit değerlere işaret ediyorsa eşittir.

Aşağıdakilerin tümü doğru olduğunda dilim değerleri derinden eşittir: her ikisi de nil veya her ikisi de nil değil, aynı uzunluğa sahipler ve ya aynı temel dizinin aynı ilk girişini gösteriyorlar (yani, & x [0) ] == & y [0]) veya karşılık gelen öğeleri (en fazla) derinden eşittir. Sıfır olmayan boş bir dilim ile sıfır dilim (örneğin, [] byte {} ve [] byte (nil)) derinden eşit değildir.

Diğer değerler - sayılar, bools, dizeler ve kanallar - Go'nun == işleci kullanılarak eşitlerse derinden eşittir.

Bu sadece @ VictorDeryagin'in cevabında verilen refl.DeepEqual () kullanarak bir örnektir .

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

}

Sonuç:

true
false

Go Playground'da deneyin

İki tane varsa []byte, bayt kullanarak karşılaştırın . Golang belgeleri şöyle diyor:

Eşit, a ve b'nin aynı uzunlukta olup olmadığını ve aynı baytları içerip içermediğini bildiren bir boole bildirimi döndürür. Nil argümanı boş bir dilim ile eşdeğerdir.

Kullanımı:

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

Bu yazdırılacak

true
false

Ve şimdi, burada https://github.com/google/go-cmp hangi

reflect.DeepEqualiki değerin anlamsal olarak eşit olup olmadığını karşılaştırmak için daha güçlü ve daha güvenli bir alternatif olması amaçlanmıştır .

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
}

Bir test yazmakla ilgileniyorsanız, o zaman github.com/stretchr/testify/assert arkadaşınız olur.

Dosyanın en başında kütüphaneyi içe aktarın:

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

Sonra testin içinde şunları yaparsınız:

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

İstenen hata şöyle olacaktır:

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