Перевірка рівності двох скибочок

Як я можу перевірити, чи рівні два скибочки?

Потрібно провести петлю над кожним із елементів у зрізі та протестувати. Рівність для скибочок не визначена. Однак є 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
}

Ви повинні використовувати refle.DeepEqual ()

DeepEqual - рекурсивна релаксація оператора Go ==.

DeepEqual повідомляє, чи x і y "глибоко рівні", визначаються наступним чином. Два значення однакового типу глибоко рівні, якщо застосовується один із наступних випадків. Значення різних типів ніколи не є глибоко рівними.

Значення масиву глибоко рівні, коли їх відповідні елементи глибоко рівні.

Значення структури глибоко рівні, якщо відповідні їм поля, як експортовані, так і неекспортовані, глибоко рівні.

Значення функцій глибоко рівні, якщо обидва є нульовими; інакше вони не є глибоко рівними.

Значення інтерфейсу глибоко рівні, якщо вони мають глибоко рівні конкретні значення.

Значення карт глибоко рівні, якщо вони є одним і тим же об'єктом карти або якщо вони мають однакову довжину, а їхні відповідні ключі (відповідні за допомогою Go рівності) відображають на глибоко рівні значення.

Значення вказівника глибоко рівні, якщо вони рівні за допомогою оператора Go == або якщо вони вказують на глибоко рівні значення.

Значення зрізів глибоко рівні, коли всі наведені нижче дані є істинними: вони обоє нульові, або обидва ненульові, мають однакову довжину, або вони вказують на один і той же початковий запис того ж базового масиву (тобто & x [0 ] == & y [0]) або їх відповідні елементи (до довжини) глибоко рівні. Зауважте, що порожній зріз, який не є нульовим, і нульовий фрагмент (наприклад, [] байт {} і [] байт (нуль)) не є глибоко рівними.

Інші значення - числа, булі, рядки та канали - глибоко рівні, якщо вони рівні, використовуючи оператор Go's ==.

Це лише приклад з використанням refle.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

Спробуйте це на майданчику Go Go

Якщо у вас є два []byte, порівняйте їх за допомогою байтів.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