Basic Golang - Equality Comparison

This post is part of a series where I intend to share the essential basics for developing with GoLang.

Logical comparisons using the == or != operators don't have much mystery. Or your code compares whether the values ​​are the same or different.
But there are some important details to know about what you're comparing.

Comparable Interface

The first thing is to know what can be compared with these operators, the most obvious place to know this is the Go documentation: section on comparators

And another option is to look at the comparable interface, which was added along with Go's generics implementation, all types that implement this interface are comparable.

So basically all primitive types defined by Go are comparable, such as: string, numbers (int, float, complex), bool.

Comparison of complex types

Some types have conditions to be comparable or not. Which is the case of: struct, slices and channels.
They are only comparable if their elements are also comparable.
The interesting thing is that Go validates this at the compilation level, helping you avoid runtime errors, for example:

//Esse código compila e a comparação funciona:
func main() {
    test1 := struct {
        name       string
    }{}
    test2 := struct {
        name       string
    }{}
    if test1 == test2 {
        fmt.Println("Funciona")
    }
}

In the code above I am creating two structs with equivalent attributes and the comparison works.

//Esse código não compila
func main() {
    test1 := struct {
        name       string
        attributes map[string]string
    }{}
    test2 := struct {
        name       string
        attributes map[string]string
    }{}
    if test1 == test2 {
        fmt.Println("Cade?")
    }
}

This code will fail to compile with the error invalid operation.

This happens because map is not a comparable type in Go.

Details about structs and map

It is very convenient to be able to compare structs with ==, since these are the types where we customize our modeling.
But even when using a non-comparable type there are some ways to simplify the code, and knowing this will save you from writing really boring conditions.

Well, let's imagine that we are working in a school system and we have the following non-comparable struct:

type student struct {
    ID         int
    name       string
    age        int
    course     string
    attributes map[string]string
}

The good part, this struct has an ID field, which makes it a lot easier if you are working with persisted data.

Now just imagine if you are working with data that is still transient, for example if you are reading a file and need to do some type of processing before persisting this data.

You will always have the option to compare field by field, it's not convenient at all, but it works. But you can make use of struct composition as follows:

func main() {
    type identity struct {
        name   string
        age    int
        course string
    }
    type student struct {
        ID int
        identity
        attributes map[string]string
    }

    s1 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "10",
        },
    }
    s2 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    s3 := student{
        identity: identity{
            name:   "Chuck",
            age:    12,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    if s1.identity == s2.identity {
        fmt.Println("Achou", s1)
    }

    if s1.identity != s3.identity {
        fmt.Println("Não achou")
    }
}

The alternative to this code would be to create conditions like these:

    if s1.name == s2.name && s1.age == s2.age && s1.course == s2.course {
        fmt.Println("Achou", s1)
    }

You could extract it to a function, to make it less confusing, but you would still have to maintain these comparisons.

Make good use of composition this can greatly simplify your code!

Summary

• Learn about the comparable interface
• Primitive types are comparable
• Complex types may or may not be comparable
• Use composition to your advantage.

The above is the detailed content of Basic Golang - Equality Comparison. For more information, please follow other related articles on the PHP Chinese website!