Determine whether two slices are equal in golang

The following tutorial column of golang will introduce to you how to judge whether two slices are equal and whether the arrays under the value are equal in golang. I hope it will be helpful to friends who need it. help!

In golang we can easily judge whether two arrays are equal by ==, but unfortunately slice is not related operator, when we need to determine whether two slices are equal, we can only find another shortcut.

Definition of slice equality

We choose the most common requirement, that is, when the type and length of two slices are the same, and the values ​​of equal subscripts are also equal, For example:

a := []int{1, 2, 3}b := []int{1, 2, 3}c := []int{1, 2}d := []int{1, 3, 2}

In the above code, a and b are equal, c is not equal because the length is different from a,d is not equal because the order of elements is different from a.

Judge whether two []bytes are equal

Why do we need to list []byte separately?

Because the standard library provides an optimized comparison scheme, we no longer need to reinvent the wheel:

package mainimport (
    "bytes"
    "fmt")func main() {
    a := []byte{0, 1, 3, 2}
    b := []byte{0, 1, 3, 2}
    c := []byte{1, 1, 3, 2}

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

Use reflect to determine whether slices (arrays) are equal

When judging slices whose type is not []byte, we can also use reflect.DeepEqual, which is used to deeply compare whether two objects, including the elements contained within them, are equal:

func DeepEqual(x, y interface{}) bool

DeepEqual reports whether x and y are “deeply equal,” defined as follows. Two values ​​of identical type are deeply equal if one of the following cases applies. Values ​​of distinct types are never deeply equal.
…
Slice values ​​are deeply equal when all of the following are true: they are both nil or both non-nil, they have the same length, and either they point to the same initial entry of the same underlying array (that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal. Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte( nil)) are not deeply equal.

The meaning of this passage is not difficult to understand. It is the same as the principle of how to determine slice equality that we discussed at the beginning of this article, except that it uses A little runtime "dark magic".

Look at the example:

package mainimport (
    "fmt"
    "reflect")func main() {
    a := []int{1, 2, 3, 4}
    b := []int{1, 3, 2, 4}
    c := []int{1, 2, 3, 4}
    fmt.Println(reflect.DeepEqual(a, b))
    fmt.Println(reflect.DeepEqual(a, c))}

Handwritten judgment

Using reflect in golang usually requires a performance cost. If we determine the type of slice, then It is relatively not that troublesome to implement slice equality judgment yourself:

func testEq(a, b []int) 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}

Test code:

package main import "fmt" func main() {    a := []int{1, 2, 3, 4}    b := []int{1, 3, 2, 4}    c := []int{1, 2, 3, 4}    fmt.Println(testEq(a, b))    fmt.Println(testEq(a, c))}

The above is the detailed content of Determine whether two slices are equal in golang. For more information, please follow other related articles on the PHP Chinese website!