Códigos básicos e didáticos

[julian-gamboa-bahia]

Palavra reservada: break

Código de exemplo:

package main

import "fmt"

func main() {
    // O loop continua até que i seja igual a 5.
    // Quando i é 5, o loop é interrompido pelo break.
    for i := 0; i < 10; i++ {
        if i == 5 {
            break
        }
        fmt.Println(i)
    }
}

Palavra reservada: continue

Código de exemplo:

package main

import "fmt"

func main() {
    // O loop ignora a impressão de números pares.
    // Quando i é par, continue pula para a próxima iteração do loop.
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Println(i)
    }
}

Palavra reservada: defer

Código de exemplo:

package main

import "fmt"

func main() {
    // defer adia a execução da função fmt.Println até que a função main() esteja prestes a retornar.
    defer fmt.Println("Executado ao final da função main")

    fmt.Println("Executado antes do fim da função main")
}

Palavra reservada: go

Código de exemplo:

package main

import (
    "fmt"
    "time"
)

func main() {
    // Inicia uma goroutine para executar uma função anônima em paralelo.
    go func() {
        fmt.Println("Executando em uma goroutine")
    }()

    // Aguarda tempo suficiente para a goroutine executar, antes que o programa termine.
    time.Sleep(1 * time.Second)
    fmt.Println("Programa principal terminado")
}

Palavra reservada: if

Código de exemplo:

package main

import "fmt"

func main() {
    // Condicional simples que verifica se um número é positivo.
    x := -42
    if x > 0 {
        fmt.Println(x, "é positivo")
    } else {
        fmt.Println(x, "não é positivo")
    }
}

Palavra reservada: import

Código de exemplo:

package main

import (
    "fmt"     // Importa o pacote fmt para formatação e saída
    "math"    // Importa o pacote math para funções matemáticas
)

func main() {
    // Utiliza a função Sqrt do pacote math para calcular a raiz quadrada
    fmt.Println("A raiz quadrada de 4 é:", math.Sqrt(4))
}

Palavra reservada: interface

Código de exemplo:

package main

import "fmt"

// Define uma interface Geometric que exige a implementação do método Area
type Geometric interface {
    Area() float64
}

// Define um tipo Square que implementa a interface Geometric
type Square struct {
    side float64
}

// Implementa o método Area para Square
func (s Square) Area() float64 {
    return s.side * s.side
}

func main() {
    // Cria uma instância de Square
    s := Square{side: 4}
    // Acessa a área do quadrado através da interface Geometric
    var g Geometric = s
    fmt.Println("A área do quadrado é:", g.Area())
}

Palavra reservada: map

Código de exemplo:

package main

import "fmt"

func main() {
    // Cria um mapa para relacionar strings a inteiros
    m := map[string]int{"a": 1, "b": 2}

    // Adiciona um novo par chave-valor ao mapa
    m["c"] = 3

    // Imprime o valor associado à chave "b"
    fmt.Println("O valor associado à chave 'b' é:", m["b"])
}

Palavra reservada: package

Código de exemplo:

package main

import "fmt"

func main() {
    // Simples impressão para demonstrar um programa executável
    fmt.Println("Este é o pacote principal")
}

Palavra reservada: range

Código de exemplo:

package main

import "fmt"

func main() {
    // Define um slice de inteiros
    numbers := []int{2, 3, 5, 7, 11, 13}

    // Itera sobre o slice usando range
    for index, value := range numbers {
        fmt.Printf("Índice %d: Valor %d\n", index, value)
    }
}

Palavra reservada: return

Código de exemplo:

package main

import "fmt"

// Função que calcula o dobro de um número
func double(num int) int {
    return num * 2
}

func main() {
    result := double(4)
    fmt.Println("O dobro de 4 é:", result)
}

Palavra reservada: select

Código de exemplo:

package main

import (
    "fmt"
    "time"
)

func main() {
    // Cria dois canais de comunicação
    c1 := make(chan string)
    c2 := make(chan string)

    // Envia uma mensagem pelo canal c1 após um segundo
    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "mensagem do c1"
    }()

    // Envia uma mensagem pelo canal c2 após dois segundos
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "mensagem do c2"
    }()

    // Utiliza select para esperar por mensagens de ambos os canais
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("Recebido:", msg1)
        case msg2 := <-c2:
            fmt.Println("Recebido:", msg2)
        }
    }
}

Palavra reservada: struct

Código de exemplo:

package main

import "fmt"

// Define um tipo de estrutura para representar uma pessoa
type Pessoa struct {
    Nome  string
    Idade int
}

func main() {
    // Cria uma instância da estrutura Pessoa
    p := Pessoa{"Alice", 30}

    // Acessa e imprime os campos da estrutura
    fmt.Println("Nome:", p.Nome)
    fmt.Println("Idade:", p.Idade)
}

Palavra reservada: switch

Código de exemplo:

package main

import "fmt"

func main() {
    // Define uma variável para testar em um switch
    number := 2

    // Utiliza switch para executar um caso baseado no valor de number
    switch number {
    case 1:
        fmt.Println("Um")
    case 2:
        fmt.Println("Dois")
    default:
        fmt.Println("Outro número")
    }
}

Palavra reservada: type

Código de exemplo:

package main

import "fmt"

// Define um novo tipo baseado em int
type MeuInt int

func main() {
    // Declara uma variável do novo tipo MeuInt
    var x MeuInt = 5

    // Imprime a variável do tipo MeuInt
    fmt.Println("Valor de x:", x)
}

Palavra reservada: var

Código de exemplo:

package main

import "fmt"

func main() {
    // Declara uma variável do tipo string
    var mensagem string = "Olá, mundo!"

    // Imprime a variável mensagem
    fmt.Println(mensagem)
}

Completando com um exemplo de defer

Código de exemplo:

package main

import "fmt"

func main() {
    // defer é usado para garantir que uma função seja chamada no final da execução da função main
    defer fmt.Println("Isso será impresso ao final da execução da função main")

    fmt.Println("Isso será impresso primeiro")
}

Palavra reservada: goto

Código de exemplo:

package main

import "fmt"

func main() {
    // goto é usado para pular para um rótulo dentro da mesma função
    goto Fim

    fmt.Println("Esta linha será pulada")

Fim:
    fmt.Println("Chegou ao fim")
}

Palavra reservada: chan

Código de exemplo:

package main

import (
    "fmt"
    "time"
)

func main() {
    // Cria um canal de inteiros
    c := make(chan int)

    // Goroutine que envia um valor para o canal após 2 segundos
    go func() {
        time.Sleep(2 * time.Second)
        c <- 10
    }()

    // Recebe o valor do canal e imprime
    val := <-c
    fmt.Println("Recebeu do canal:", val)
}

Palavra reservada: const

Código de exemplo:

package main

import "fmt"

func main() {
    // Define uma constante
    const Pi = 3.14159

    // Usa a constante em uma operação
    fmt.Println("O valor de Pi é:", Pi)
}

Palavra reservada: default

Código de exemplo:

package main

import "fmt"

func main() {
    // Switch sem uma condição de entrada específica
    switch {
    case false:
        fmt.Println("Não será executado")
    default:
        fmt.Println("Bloco default executado")
    }
}

Palavra reservada: else

Código de exemplo:

package main

import "fmt"

func main() {
    // Condicional com else
    x := -1
    if x > 0 {
        fmt.Println("x é positivo")
    } else {
        fmt.Println("x não é positivo")
    }
}

Palavra reservada: fallthrough

Código de exemplo:

package main

import "fmt"

func main() {
    // Switch com fallthrough
    switch i := 2; i {
    case 2:
        fmt.Println("Dois")
        fallthrough
    case 3:
        fmt.Println("Este bloco é executado devido ao fallthrough")
    }
}

Palavra reservada: for

Código de exemplo:

package main

import "fmt"

func main() {
    // Loop for clássico
    for i := 0; i < 3; i++ {
        fmt.Println("Valor de i:", i)
    }
}

Palavra reservada: func

Código de exemplo:

package main

import "fmt"

// Definição de função
func saudar(nome string) {
    fmt.Println("Olá,", nome)
}

func main() {
    // Chamada de função
    saudar("Mundo")
}

Palavra reservada: case

Código de exemplo:

package main

import "fmt"

func main() {
    // Usando case em um switch para diferentes casos
    x := 2
    switch x {
    case 1:
        fmt.Println("O número é 1")
    case 2:
        fmt.Println("O número é 2")
    default:
        fmt.Println("O número é outro")
    }
}

[julian-gamboa-bahia]

Palavra reservada: chan

Código de exemplo:

package main

import (
    "fmt"
    "time"
)

// função que simula processamento longo e envia resultado em um canal
func processamentoPesado(c chan int) {
    // Simula um cálculo demorado
    time.Sleep(3 * time.Second)
    c <- 42  // Envia o resultado para o canal
}

func main() {
    c := make(chan int)
    go processamentoPesado(c)  // Inicia a goroutine

    // Espera e recebe o resultado do canal
    resultado := <-c
    fmt.Println("Recebeu do canal:", resultado)
}

Palavra reservada: const

Código de exemplo:

package main

import (
    "fmt"
    "math"
)

// Constantes usadas para cálculos matemáticos
const (
    Pi    = 3.14159
    Raio  = 2
)

func main() {
    // Calcula a área de um círculo com o raio e Pi definidos
    area := Pi * math.Pow(Raio, 2)
    fmt.Printf("A área do círculo é: %.2f\n", area)
}

Palavra reservada: default

Código de exemplo:

package main

import "fmt"

func tipoDeValor(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("O valor é um inteiro: %d\n", v)
    case string:
        fmt.Printf("O valor é uma string: %s\n", v)
    default:
        fmt.Printf("Outro tipo com valor: %v\n", v)
    }
}

func main() {
    tipoDeValor(10)
    tipoDeValor("dez")
    tipoDeValor(3.14)
}

Palavra reservada: else

Código de exemplo:

package main

import "fmt"

func verificarValor(num int) {
    if num%2 == 0 {
        fmt.Println(num, "é par")
    } else {
        fmt.Println(num, "é ímpar")
    }
}

func main() {
    verificarValor(5)
    verificarValor(6)
}

Palavra reservada: fallthrough

Código de exemplo:

package main

import "fmt"

func main() {
    valor := 2
    switch valor {
    case 1:
        fmt.Println("Um")
    case 2:
        fmt.Println("Dois")
        fallthrough
    case 3:
        fmt.Println("Três, alcançado pelo fallthrough do caso 2")
    }
}

Palavra reservada: for

Código de exemplo:

package main

import "fmt"

func main() {
    // Loop for usando range para iterar sobre um slice
    numeros := []int{1, 2, 3, 4, 5}
    for idx, num := range numeros {
        fmt.Printf("Índice %d tem valor %d\n", idx, num)
    }
}

Palavra reservada: func

Código de exemplo:

package main

import "fmt"

// Função que retorna uma função que incrementa um valor
func incrementador() func() int {
    var x int
    return func() int {
        x++
        return x
    }
}

func main() {
    inc := incrementador()
    fmt.Println(inc())
    fmt.Println(inc())
}

Palavra reservada: case

Código de exemplo:

package main

import "fmt"

func avaliarNumero(numero int) {
    switch {
    case numero < 0:
        fmt.Println("Número negativo")
    case numero == 0:
        fmt.Println("Zero")
    case numero > 0:
        fmt.Println("Número positivo")
    }
}

func main() {
    avaliarNumero(-5)
    avaliarNumero(0)
    avaliarNumero(10)
}

Palavra reservada: defer

Código de exemplo:

package main

import "fmt"

func limpar() {
    fmt.Println("Limpando recursos...")
}

func operacaoComplexa() {
    defer limpar()  // Garante que a função limpar() será chamada ao final, independentemente de erros.
    fmt.Println("Executando operação complexa")
    // Simula um erro
    panic("algo deu errado")
}

func main() {
    defer fmt.Println("Operações concluídas")  // Executado após todos os panics e defers anteriores serem resolvidos.
    operacaoComplexa()
}

Palavra reservada: go

Código de exemplo:

package main

import (
    "fmt"
    "time"
)

func tarefa(duracao time.Duration) {
    fmt.Printf("Iniciando tarefa de %v segundos...\n", duracao.Seconds())
    time.Sleep(duracao)
    fmt.Println("Tarefa concluída")
}

func main() {
    go tarefa(1 * time.Second)
    go tarefa(2 * time.Second)
    fmt.Println("Aguardando tarefas")
    time.Sleep(3 * time.Second)
    fmt.Println("Final do programa")
}

Palavra reservada: goto

Código de exemplo:

package main

import "fmt"

func main() {
    i := 0
Start:
    if i < 5 {
        fmt.Println(i)
        i++
        goto Start
    }
    fmt.Println("Finalizado")
}

Palavra reservada: if

Código de exemplo:

package main

import "fmt"

func classificarIdade(idade int) {
    if idade < 13 {
        fmt.Println("Criança")
    } else if idade < 20 {
        fmt.Println("Adolescente")
    } else {
        fmt.Println("Adulto")
    }
}

func main() {
    classificarIdade(10)
    classificarIdade(16)
    classificarIdade(25)
}

Palavra reservada: import

Código de exemplo:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    fmt.Println("Número aleatório:", rand.Intn(100))
}

Palavra reservada: interface

Código de exemplo:

package main

import "fmt"

type Forma interface {
    Area() float64
}

type Circulo struct {
    raio float64
}

func (c Circulo) Area() float64 {
    return 3.14159 * c.raio * c.raio
}

func main() {
    var f Forma = Circulo{raio: 5}
    fmt.Println("Área do círculo:", f.Area())
}

Palavra reservada: map

Código de exemplo:

package main

import "fmt"

func main() {
    usuarios := map[string]int{
        "Alice": 28,
        "Bob": 34,
    }
    usuarios["Charlie"] = 22
    for nome, idade := range usuarios {
        fmt.Println(nome, "tem", idade, "anos")
    }
}

Palavra reservada: package

Código de exemplo:

// main.go
package main

import "fmt"

func main() {
    fmt.Println("Exemplo de uso da palavra reservada package")
}

Palavra reservada: range

Código de exemplo:

package main

import "fmt"

func main() {
    nomes := []string{"Alice", "Bob", "Charlie"}
    for i, nome := range nomes {
        fmt.Printf("Índice %d: %s\n", i, nome)
    }
}

Palavra reservada: return

Código de exemplo:

package main

import "fmt"

func somar(a, b int) int {
    return a + b
}

func main() {
    resultado := somar(5, 7)
    fmt.Println("Resultado da soma:", resultado)
}

Palavra reservada: select

Código de exemplo:

package main

import (
    "fmt"
    "time"
)

func servidor1(ch chan string) {
    time.Sleep(1 * time.Second)
    ch <- "Servidor

 1 respondeu"
}

func servidor2(ch chan string) {
    time.Sleep(2 * time.Second)
    ch <- "Servidor 2 respondeu"
}

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go servidor1(ch1)
    go servidor2(ch2)

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println(msg1)
        case msg2 := <-ch2:
            fmt.Println(msg2)
        }
    }
}

Palavra reservada: struct

Código de exemplo:

package main

import "fmt"

type Carro struct {
    Marca string
    Ano   int
}

func main() {
    meuCarro := Carro{"Toyota", 2021}
    fmt.Println("Marca do carro:", meuCarro.Marca, "- Ano:", meuCarro.Ano)
}

Palavra reservada: switch

Código de exemplo:

package main

import "fmt"

func main() {
    idioma := "espanhol"
    switch idioma {
    case "inglês":
        fmt.Println("Hello!")
    case "espanhol":
        fmt.Println("¡Hola!")
    case "francês":
        fmt.Println("Bonjour!")
    default:
        fmt.Println("Idioma desconhecido")
    }
}

Palavra reservada: type

Código de exemplo:

package main

import "fmt"

type Inteiro int

func (i Inteiro) Dobrar() Inteiro {
    return i * 2
}

func main() {
    var x Inteiro = 10
    fmt.Println("O dobro de", x, "é", x.Dobrar())
}

Palavra reservada: var

Código de exemplo:

package main

import "fmt"

func main() {
    var idade int = 30
    var nome string = "Alice"
    fmt.Println(nome, "tem", idade, "anos")
}