Controle de fluxo

O statement if

Um statement if executa um bloco de código somente quando uma condição é verdadeira. A condição é uma expressão booleana — ela deve avaliar para true ou false.

age := 20

if age >= 18 {
    fmt.Println("adult")
}

Os parênteses em torno da condição são opcionais em muitas linguagens, mas ausentes por convenção em Go — o compilador os aceita, mas o gofmt os remove. As chaves, por outro lado, são sempre obrigatórias. Go não permite corpos de if em uma única linha sem chaves.

O statement if-else

Um bloco else executa quando a condição é falsa. Ele fornece um segundo caminho de execução — exatamente um dos dois blocos será executado:

score := 72

if score >= 60 {
    fmt.Println("pass")
} else {
    fmt.Println("fail")
}

A keyword else deve aparecer na mesma linha que a chave de fechamento do bloco if. Colocá-la na linha seguinte é um compile error porque a inserção automática de ponto e vírgula do Go coloca um ; após o }, tornando o else inacessível:

// compile error: unexpected else
if score >= 60 {
    fmt.Println("pass")
}
else {
    fmt.Println("fail")
}

O statement if-else if

Quando você precisa avaliar mais de duas condições, pode encadear cláusulas else if. Go as avalia de cima para baixo e executa o primeiro bloco cuja condição seja verdadeira. Se nenhuma condição corresponder e houver um else, esse bloco é executado:

temp := 22

if temp < 0 {
    fmt.Println("freezing")
} else if temp < 15 {
    fmt.Println("cold")
} else if temp < 25 {
    fmt.Println("comfortable")
} else {
    fmt.Println("hot")
}

Uma vez que uma condição corresponde, os demais branches são completamente ignorados — Go não cai nos blocos else if seguintes. O else final é opcional; sem ele, se nenhuma condição corresponder, a execução continua após toda a cadeia.

If com init statement

Go permite um statement de inicialização opcional antes da condição, separado por ponto e vírgula. A variável declarada no init statement tem escopo para todo o bloco if-else — ela existe apenas dentro daquele bloco e não é acessível após ele:

if x := compute(); x > 0 {
    fmt.Println("positive:", x)
} else {
    fmt.Println("non-positive:", x)
}

// x não é acessível aqui

Isso não é apenas uma conveniência sintática — é um mecanismo de escopo intencional. Ao declarar a variável dentro do if, você sinaliza que seu propósito está exclusivamente vinculado àquela verificação condicional. Ela não pode vazar para o escopo externo e afetar código não relacionado.

O padrão é usado constantemente para tratamento de erros em Go. Funções que podem falhar retornam um valor e um error. O init statement captura ambos, e o corpo trata o caminho de falha:

if err := doSomething(); err != nil {
    fmt.Println("error:", err)
    return
}

Essa é a forma idiomática Go de tratar erros inline, sem declarar uma variável descartável no escopo externo apenas para verificá-la uma vez. A variável existe exatamente pelo tempo necessário — nada mais.