# If, For, Switch e GoTo

Algumas estruturas são básicas em praticamente todas as linguagens, pois permitem o controle do fluxo de execução do código. No Go, não é diferente: if, for, switch e goto (sim, existe goto) são fundamentais para criar lógica condicional, laços de repetição e até saltos diretos dentro do código.

# If

O if é uma das estruturas fundamentais de controle de fluxo em Go, permitindo que o programa tome decisões com base em condições lógicas. Seu funcionamento é semelhante ao de outras linguagens, mas possui algumas particularidades que fazem parte do estilo idiomático do Go.

## Sintaxe básica

A sintaxe básica do if no Go é a seguinte:

if condition {
    // só entra nesse bloco, se condition for true
}

Perceba que o if não precisa de parênteses em torno da condição Podemos também definir um if com else

idade := 16

if idade >= 18 {
    fmt.Println("Você é maior de idade!")
} else {
    fmt.Println("Você é menor de idade!")
}

Podemos também fazer um encadeamento de if com else if

idade := 16

if idade >= 18 {
    fmt.Println("Você é maior de idade!")
}
else if idade >= 16 {
    fmt.Println("Você é quase maior de idade!")
} else {
    fmt.Println("Você é menor de idade!")
}

No Go, podemos definir uma variável que só será utilizada no escopo do if

if idade := 16; idade >= 18 {
    fmt.Println("Você é maior de idade!")
} else {
    fmt.Println("Você é menor de idade!")
}

Outra coisa que você verá muito em código Go, é essa estrutura. Onde a função retorna um erro e o if verifica se o erro é diferente de nil

value, err := doSomething()

if err != nil {
    return err
}

Artigo muito legal falando sobre esse assunto: Errors are values. Nele é discutido a abordagem do Go para tratamento de erros, enfatizando que erros são valores e, portanto, podem ser manipulados como qualquer outra variável. Isso permite um tratamento de erros mais flexível e programável,

# For

No Go, o for é a única estrutura de repetição disponível, mas é extremamente flexível e pode ser usada de diferentes maneiras para cobrir os casos comuns de laços encontrados em outras linguagens.Existem os 4 caminhos do for, tradicional com inicialização (C-style), condição um loop while, loop infinito e usando o range.

## C-style

O clássico for com inicialização, condição e incremento

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

## Condição

Esse for é semelhante ao while de outras linguagens

i := 0

for i < 10 {
    fmt.Println(i)
    i++
}

## Loop

Bem simples, só não colocar a condição.

for {
    fmt.Println("Loop infinito")
}

## Range

O range é uma forma de iterar sobre um array, slice, string, map ou channel. Ele retorna dois valores, o índice e o valor do elemento.

numbers := []int{1, 2, 3, 4, 5}

for i, number := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", i, number)
}

## Continue e Break

O continue é usado para pular a iteração atual e ir para a próxima, enquanto o break é usado para sair do loop.

for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue
    }
    fmt.Println(i)
}

for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Println(i)
}

# Switch

O switch é uma das estruturas de controle mais poderosas e flexíveis do Go. Ele é usado para comparar uma variável com diferentes casos (case), funcionando como uma alternativa mais organizada e eficiente ao uso excessivo de if-else.

    dia := "segunda"

    switch dia {
    case "segunda":
        fmt.Println("Início da semana!")
    case "sexta":
        fmt.Println("É sexta!")
    default:
        fmt.Println("Dia comum.")
    }

Veja que não precisamos definir um break, como em C.

## Várias condições

Podemos também fazer um switch com várias condições

    dia := "segunda"

    switch dia {
    case "segunda", "terça", "quarta", "quinta", "sexta":
        fmt.Println("Dia útil!")
    case "sábado", "domingo":
        fmt.Println("Fim de semana!")
    default:
        fmt.Println("Valor inválido.")
    }

## Avaliação de expressão

O switch também pode ser usado sem uma variável, avaliando uma expressão

     numero := 10

    switch {
    case numero % 2 == 0:
        fmt.Println("Número par")
    case numero % 2 != 0:
        fmt.Println("Número ímpar")
    }

## Fallthrough

O fallthrough é uma palavra-chave que faz com que o controle de fluxo passe para o próximo caso, mesmo que o caso atual seja verdadeiro.

    numero := 10

    switch {
    case numero % 2 == 0:
        fmt.Println("Número par")
        fallthrough
    case numero % 2 != 0:
        fmt.Println("Número ímpar")
    }

Quando o fallthrough é usado, o próximo caso é executado, mesmo que a condição seja falsa. No exemplo acima, o caso numero % 2 != 0 será executado, mesmo que a condição numero % 2 == 0 seja verdadeira. Nesse caso não faz muito sentido, mas é um recurso que pode ser útil em algumas situações, como no caso de regras de negócio que se acumulam, por exemplo, descontos em uma compra.

# GoTo

SIM! Go tem goto. Mas, como em outras linguagens, seu uso é desencorajado, pois pode tornar o código difícil de entender e manter. Em 1968 Edsger Dijkstra publicou um artigo chamado “Go To Statement Considered Harmful”, onde ele argumenta que o uso de goto torna o código difícil de entender e manter. Então devemos usar com muito cuidado!

## Sintaxe básica

goto label
label:
    fmt.Println("Hello, World!")

## Exemplo

idade := 17

    if idade < 18 {
        goto menorIdade
    }

    fmt.Println("Acesso permitido.")
    return

menorIdade:
    fmt.Println("Acesso negado. Você precisa ser maior de idade.")

# Referências

1. Chapter 4 - Blocks, Shadows, and Control Structures Learning Go: An Idiomatic Approach to Real-World Go Programming
2. Errors are values
3. Go To Statement Considered Harmful