Blog / Go Language Spec

Comparison operators

February 12, 2024

I’ll be livestreaming again today! I hope you can join me as I continue where I left off last week, adding some new features to my open-source library, Kivik!

Let’s talk about a mundane detail… that actually has some interesting nuances: Comparisons!

Comparison operators

Comparison operators compare two operands and yield an untyped boolean value.

==    equal
!=    not equal
<     less
<=    less or equal
>     greater
>=    greater or equal

In any comparison, the first operand must be assignable to the type of the second operand, or vice versa.

This is a subtle, but important point: One of the operands must be assignable to the other, but which doesn’t matter.

Wait… how is that possible? Given, say x == y, how could x be assignable to y, but not the other way around? Perhaps the easiest example is comparing against an untyped boolean constant.

Given:

type B bool
var x B

Both

if (x == true) {

and

if (true == x) {

are valid. In the first case, the right hand operand (the untyped constant true) is assignable to the left hand operand (the variable x of type B), but not the other way around (you can’t assign anything to a constant). And in the second example, the reverse is true.

The equality operators == and != apply to operands of comparable types. The ordering operators <, <=, >, and >= apply to operands of ordered types.

The fact that Go has two concepts at play here, ordered and comparable differs from some languages. And sometimes in surprising ways. Perhaps the most surprising is that boolean values are not ordered (more on that tomorrow). In many languages, you can easily convert/typecast between boolean and integer values, such that true translates to 1 and false to 0. In such langauges, it’s usually (if not always) possible to order or sort by a boolean flag, such that false sorts before true. Not so in Go! (Although there have been proposals to change this, but so far they haven’t gotten any serious traction.)

Quotes from The Go Programming Language Specification Version of August 2, 2023

Share this

Direct to your inbox, daily. I respect your privacy .

Unsure? Browse the archive .

Related Content

Comparison operators, conclusion

Comparison operators … Slice, map, and function types are not comparable. However, as a special case, a slice, map, or function value may be compared to the predeclared identifier nil. Comparison of pointer, channel, and interface values to nil is also allowed and follows from the general rules above. Let’s demonstrate: var a func() var b []int var c map[string]string fmt.Println(a == nil, b == nil, c == nil) // true, true, true But this only applies to a direct comparison with nil.

Comparison operators, part IV

Comparison operators … Struct types are comparable if all their field types are comparable. Two struct values are equal if their corresponding non-blank field values are equal. The fields are compared in source order, and comparison stops as soon as two field values differ (or all fields have been compared). I think this is clear. But it leads to some interesting things in the wild, when you want structs to not be comparable.

Comparison operators, part III

Today we continue through the list of data types and how comparison and ordering works on each. Comparison operators … Channel types are comparable. Two channel values are equal if they were created by the same call to make or if both have value nil. Notice that channel comparison is effectively a comparison of identity. Not type or content. Two channels may have the same type and contents, but be unequal: