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).

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.

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.

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.

Master Go with Deep Grasping Methodology!

Learn More