Infinite Loop

An infinite loop in Go is a control flow statement that executes its block of code indefinitely because it lacks a terminating condition. Because Go relies exclusively on the for keyword for all iterative constructs (omitting while or do-while entirely), an infinite loop is created by omitting the initialization statement, the boolean condition, and the post-iteration statement from the loop signature.

When the boolean condition is omitted, the Go compiler implicitly evaluates it as true.

for {
    // Loop body executes indefinitely
}

Control Flow and Termination

Because the loop header provides no mechanism for termination, control flow must be managed explicitly within the loop body. Go provides several mechanisms to halt an infinite loop:

• break: A keyword that terminates the execution of the innermost enclosing for, switch, or select statement and transfers control to the statement immediately following that block. Crucial distinction: If a break is executed inside a switch or select statement that is nested within a for loop, it will only terminate the switch or select, leaving the infinite loop active.
• break [label]: A keyword combined with a label identifier that terminates a specific labeled statement. This is the idiomatic approach for breaking out of multiple nested loops simultaneously, or for breaking out of a for loop from within a nested switch or select block.
• return: A keyword that immediately terminates the execution of the enclosing function, discarding the loop and returning control (and any specified return values) to the caller.
• goto [label]: A keyword that transfers control unconditionally to a labeled statement outside the loop block.
• panic(): A built-in function (a predeclared identifier, not a keyword) that initiates a run-time panic, halting standard control flow and beginning goroutine stack unwinding.

Syntax Visualization with Termination

func process() {
    var stateCode int

    for {
        // The condition variable must be updated within the loop 
        // to prevent an unbreakable loop that hangs the CPU.
        stateCode = getNextState()

        if stateCode == 1 {
            break // Exits the 'for' loop, continues function execution
        }

        if stateCode == -1 {
            return // Exits the entire function immediately
        }
    }
    
    // Control flow resumes here only if 'break' is triggered
}

func getNextState() int {
    // State evaluation logic omitted
    return 1
}

Nested Infinite Loops and Labels

When utilizing nested infinite loops, a standard break statement only escapes the immediate lexical scope. A label must be declared immediately preceding the outer loop to terminate the entire construct using a labeled break.

func processNested() {
    cycles := 0
    
OuterLoop:
    for {
        for {
            cycles++
            
            if cycles >= 100 {
                break OuterLoop // Terminates both the inner and outer infinite loops
            }
            
            if cycles%10 == 0 {
                break // Terminates only the inner loop, returning control to OuterLoop
            }
        }
    }
}

Master Go with Deep Grasping Methodology!

Learn More