> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Go Greater Than Or Equal To
The `>=` (greater than or equal to) operator is a binary relational operator in Go that evaluates whether the left operand's value is strictly greater than or mathematically equal to the right operand's value. It yields an untyped boolean value (`true` or `false`).
```go theme={"dark"}
package main
import "fmt"
func main() {
leftOperand := 10
rightOperand := 5
result := leftOperand >= rightOperand
fmt.Println(result) // Output: true
}
```
## Type Constraints
Because Go is strictly typed, the `>=` operator enforces strict operand compatibility. Both operands must resolve to the exact same type, unless one or both are untyped constants. If an untyped constant is used alongside a typed variable, the constant must be implicitly convertible to the variable's type.
The `>=` operator is exclusively defined for **ordered types**. In Go, ordered types include:
* **Integer types:** `int`, `int8`, `int16`, `int32`, `int64`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`, `uintptr`, `byte`, and `rune`.
* **Floating-point types:** `float32` and `float64`.
* **String types:** `string`.
* **Custom types:** Any named type whose underlying type is one of the ordered types listed above (e.g., `type Score int`).
Attempting to use `>=` on unordered types (such as booleans, slices, maps, channels, or structs) will result in an "operator not defined" compile-time error (e.g., `invalid operation: a >= b (operator >= not defined on bool)`). A type mismatch error specifically occurs when attempting to operate on two incompatible types (e.g., `invalid operation: a >= b (mismatched types int and float64)`).
## Evaluation Mechanics
**Numeric Evaluation**
For integers and floating-point numbers, the operator evaluates based on standard mathematical ordering. When evaluating floating-point numbers, Go adheres to IEEE-754 specifications. Consequently, if either operand is `NaN` (Not a Number), the `>=` operation will always evaluate to `false`.
```go theme={"dark"}
package main
import "fmt"
func main() {
var x int32 = 15
var y int32 = 15
res1 := x >= y
fmt.Println(res1) // Output: true
var f1 float64 = 3.14
res2 := f1 >= 3 // untyped constant 3 is implicitly converted to float64
fmt.Println(res2) // Output: true
}
```
**String Evaluation**
For strings, the `>=` operator evaluates lexicographically, byte-by-byte, rather than by character (rune) count or linguistic rules. It compares the underlying numeric byte values of the UTF-8 encoded strings.
```go theme={"dark"}
package main
import "fmt"
func main() {
var s1 string = "apple"
var s2 string = "API"
// byte value of 'a' (97) >= 'A' (65)
res3 := s1 >= s2
fmt.Println(res3) // Output: true
}
```
If two strings are identical up to the length of the shorter string, the longer string is considered greater.
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
