golang - Comprobando la igualdad de dos rebanadas

go reflection

Question

¿Cómo puedo comprobar si dos rebanadas son iguales?

Answer 1

Debe recorrer cada uno de los elementos de la división y probar. Igualdad para las rebanadas no está definida. Sin embargo, hay una función bytes.Equal si está comparando valores de tipo []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
}

Answer 2

Deberías usar reflect.DeepEqual()

DeepEqual es una relajación recursiva del operador Go ==.

DeepEqual informa si x e y son "profundamente iguales", definidos de la siguiente manera. Dos valores de tipo idéntico son profundamente iguales si se aplica uno de los siguientes casos. Los valores de tipos distintos nunca son profundamente iguales.

Los valores de matriz son profundamente iguales cuando sus elementos correspondientes son profundamente iguales.

Los valores de Struct son profundamente iguales si sus campos correspondientes, tanto exportados como no exportados, son profundamente iguales.

Los valores funcionales son profundamente iguales si ambos son nulos; De lo contrario no son profundamente iguales.

Los valores de interfaz son profundamente iguales si mantienen valores concretos profundamente iguales.

Los valores del mapa son profundamente iguales si son el mismo objeto del mapa o si tienen la misma longitud y sus teclas correspondientes (coincidentes con la igualdad de Go) se asignan a valores profundamente iguales.

Los valores de puntero son profundamente iguales si son iguales utilizando el operador Go == o si apuntan a valores profundamente iguales.

Los valores de división son profundamente iguales cuando todos los siguientes son verdaderos: ambos son nulos o no nulos, tienen la misma longitud y apuntan a la misma entrada inicial de la misma matriz subyacente (es decir, & x [0 ] == & y [0]) o sus elementos correspondientes (hasta la longitud) son profundamente iguales. Tenga en cuenta que una división vacía no nula y una división nula (por ejemplo, [] byte {} y [] byte (nil)) no son profundamente iguales.

Otros valores (números, bools, cadenas y canales) son profundamente iguales si son iguales utilizando el operador == de Go.

Answer 3

Este es solo un ejemplo que utiliza reflect.DeepEqual() que se encuentra en la respuesta de @ 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))

}

Resultado:

true
false

Answer 4

Si tiene dos []byte , compárelos usando bytes.Equal . La documentación de Golang dice:

Equal devuelve un informe booleano si a y b tienen la misma longitud y contienen los mismos bytes. Un argumento nulo es equivalente a una porción vacía.

Uso:

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

Esto imprimirá

true
false