> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Comparison Operators
> Explains Go comparison operators, their meanings, type comparability rules, and examples for equality and ordering operations.
Comparison operators compare two operands and return a Boolean value: true or false. Equality operators (==, !=) require operands to be of comparable types (typically the same type or types that the language allows to be compared). Ordering operators (\<, \<=, >, >=) require ordered types such as numeric types and strings. Common comparisons include checking whether two strings match, if two numbers are equal, or if one number is greater than another.
Not all types are comparable using == and !=. Types such as slices, maps, and functions cannot be compared with equality operators — attempting to do so results in a compile-time error. Structs and arrays are comparable only if all their fields/elements are comparable.
We have the following comparison operators: equal (==), not equal (!=), less than (\<), less than or equal to (\<=), greater than (>), and greater than or equal to (>=).
When comparing values in Go, make sure both operands are of comparable types. Use explicit conversions when necessary (for example, converting between int types) and prefer clear, readable comparisons to avoid subtle bugs.
Operator reference
| Operator | Meaning | Typical Use Case |
| -------- | ------------------------ | ------------------------------------ |
| == | equal | Compare identical values or strings |
| != | not equal | Check inequality |
| \< | less than | Order comparisons (numbers, strings) |
| \<= | less than or equal to | Order or boundary checks |
| > | greater than | Order comparisons |
| >= | greater than or equal to | Order or boundary checks |
Examples
Equal (==)
The equal operator returns true when the two values are equal.
```go theme={null}
package main
import "fmt"
func main() {
var city string = "Kolkata"
var city2 string = "Calcutta"
fmt.Println(city == city2)
}
```
```bash theme={null}
$ go run main.go
false
```
Not equal (!=)
The not-equal operator returns true when the two values are not equal.
```go theme={null}
package main
import "fmt"
func main() {
var city string = "Kolkata"
var city2 string = "Calcutta"
fmt.Println(city != city2)
}
```
```bash theme={null}
$ go run main.go
true
```
Less than (\<)
The less-than operator returns true when the left operand is strictly less than the right operand.
```go theme={null}
package main
import "fmt"
func main() {
var a, b int = 5, 10
fmt.Println(a < b)
}
```
```bash theme={null}
$ go run main.go
true
```
Less than or equal to (\<=)
This operator returns true when the left operand is less than or equal to the right operand.
```go theme={null}
package main
import "fmt"
func main() {
var a, b int = 10, 10
fmt.Println(a <= b)
}
```
```bash theme={null}
$ go run main.go
true
```
Greater than (>)
The greater-than operator returns true when the left operand is strictly greater than the right operand.
```go theme={null}
package main
import "fmt"
func main() {
var a, b int = 20, 10
fmt.Println(a > b)
}
```
```bash theme={null}
$ go run main.go
true
```
Greater than or equal to (>=)
This operator returns true when the left operand is greater than or equal to the right operand.
```go theme={null}
package main
import "fmt"
func main() {
var a, b int = 20, 20
fmt.Println(a >= b)
}
```
```bash theme={null}
$ go run main.go
true
```
Links and References
* Go Language Specification — Expressions: [https://golang.org/ref/spec#Comparison\_operators](https://golang.org/ref/spec#Comparison_operators)
* Go Documentation: [https://golang.org/doc/](https://golang.org/doc/)
* Effective Go: [https://golang.org/doc/effective\_go.html](https://golang.org/doc/effective_go.html)
That's it for this lesson.