Logical OR

The || (logical OR) operator is a binary operator in Go that evaluates two boolean expressions and yields true if at least one of the operands evaluates to true. If both operands evaluate to false, the result is false.

expression1 || expression2

Technical Characteristics

Type Constraints Go is strictly typed. Both operands provided to the || operator must resolve to the predeclared bool type. Unlike dynamically typed languages, Go does not support “truthiness”; you cannot use integers, strings, or pointers directly as operands.

Short-Circuit Evaluation The || operator employs left-to-right short-circuit evaluation. Go evaluates the left-hand operand first. If the left-hand operand evaluates to true, the overall expression is guaranteed to be true, and the Go runtime completely bypasses the right-hand operand. Any function calls, state mutations, or potential runtime panics present in the right-hand expression will not execute. However, the right-hand operand must still be a valid expression that resolves to a bool to pass compile-time type checking.

Operator Precedence In Go’s operator precedence hierarchy, || has the lowest precedence among logical operators. It binds less tightly than both the ! (logical NOT) and && (logical AND) operators.

Syntax Visualization

package main

import "fmt"

func panickyFunc() bool {
    panic("this will never execute")
}

func main() {
    var a bool = true
    var b bool = false

    // Standard evaluation
    res1 := a || b       // Evaluates to true
    res2 := false || b   // Evaluates to false

    // Precedence demonstration
    // && is evaluated before ||
    res3 := true || false && false 
    // Parsed as: true || (false && false) -> true || false -> true

    // Short-circuit demonstration
    // Because the left operand is true, the right operand is ignored.
    // panickyFunc() is never called, preventing a runtime panic.
    // Note: panickyFunc must return a bool to satisfy the compiler.
    res4 := true || panickyFunc() 

    // Print results to satisfy Go's strict unused variable compiler checks
    fmt.Println(res1, res2, res3, res4)
}

Truth Table

Left Operand	Right Operand	Result	Evaluation Path
true	true	true	Right operand ignored
true	false	true	Right operand ignored
false	true	true	Both operands evaluated
false	false	false	Both operands evaluated

Master Go with Deep Grasping Methodology!

Learn More