> ## 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 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`.
```go theme={"dark"}
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
```go theme={"dark"}
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 |
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
