Criando arquivos em go

Criar e escrever arquivos com go é bem simples:

  • ioutil
package main

import (
    "io/ioutil"
)

func main() {
    texto := []byte("conteudo")
    err := ioutil.WriteFile("caminho", texto, 0644)
    
    if err != nil {
        panic(err)
    }
}

Voltar para Começando com go

Anúncios

Ponteiros em go

Quem já trabalhou com C, deve estar lembrado dos ponteiros, de utilizar * e &. Nesta parte, colocarei o texto integral do go tour, pois achei bem didático e direto ao ponto:

Go tem ponteiros. Um ponteiro guarda na memória o endereço de uma variável.

O tipo *T é um ponteiro para um valor T. Seu valor zero é nil.

var p *int
O operador & gera um ponteiro para seu operando.

i := 42
p = &i
O operador * indica valor subjacente do ponteiro.

fmt.Println(*p) // lê i através do ponteiro p
*p = 21 // defina i através do ponteiro p
Isto é conhecido como “desreferenciamento” ou “indirecionamento”.

Diferente de C, Go não faz aritimética de ponteiros.

Voltar para Começando com go

Estruturas de controle no go

No go, temos apenas uma estrutura de laço: o for. A sua estrutura é simples: Não possui () e as {} são obrigatórios.

    for i := 0; i < 10; i++ {
	
    }

Não é obrigatório declarar nem a primeira nem a última declaração

    i := 1
    for ; i < 10;  {
	i += i
    }

O que deixa o for similar ao while de outras linguagens

    i := 1
    for i < 10 {
	i += i
    }

Você também pode criar um for infinito

    for {
	// algo infinito aqui
    }

O if possui a mesma estrutura do for: O () não existe e o {} é obrigatório

    idade := 29
    if idade > 30 {
        // alguma coisa aqui
    }

Também podemos declarar uma variável, assim como no for. A seu escopo será apenas dentro do if (e dos elses que o sigam)

    if idade := 29; idade > 30 {
        // alguma coisa aqui
    }

Uma coisa que pode ser diferente de outras linguagens, é a utilização de defer. Ao chamarmos uma função com defer, nós estamos adiando a execução daquela função até o fim do retorno da função que estamos

package main

import "fmt"

func funcComDefer() {
    fmt.Println("funcComDefer")
}

func testeDefer() {
    defer funcComDefer()
	fmt.Println("testeDefer")
}

func main() {
    testeDefer()
}

Caso tenha vários defer, eles serão executados na forma de fila, sendo o último a entrar, o primeiro a sair.

Voltar para Começando com go

Tipos básicos em go

Os tipos básicos no go são:

  • bool
  • string
  • int
  • int8
  • int16
  • int32
  • int64
  • uint
  • uint8
  • uint16
  • uint32
  • uint64
  • uintptr
  • byte
  • rune
  • float32
  • float64
  • complex64
  • complex128

Os valores default para variáveis não inicializadas são:

  • 0 para tipos numéricos
  • “” para string
  • false para bool

Para conversões de tipo, é necessário realizar uma conversão explicita

func main() {
    var x = 1
    var z uint
    z = x // erro
}

func main() {
    var x = 1
    var z uint
    z = uint(x) // OK
}

Quando utilizamos uma declaração de variável sem especificar o tipo, o tipo é determinado a partir do valor passado. Para valores numéricos, os tipos serão sempre int, float64 ou complex128

func main() {
    x := 1 // inteiro
    y := 1.1 // float64
    z := 1.6i // complex128
}

Para declarar uma constante, basta utilizar a palavra chave const. A única observação é que não é possível inicializar uma constante utilizando o inicializador :=

func main() {
    const Ola = "Olá"
}

Voltar para Começando com go

Declaração de variáveis em go

A sintaxe do go é bem simples. Existem alguns pontos diferentes de outras linguagens, mas caso você já tenha programado em C ou em qualquer outra linguagem inspirada nele, você não terá grandes dificuldades.

Variáveis

Para declarar uma variável, basta utilizar a palavra chave var, nomeá-la e tipa-la.

var exemplo string
var exemplo2 int

Você também pode utilizar var para declarar n variáveis

var variavel1, variavel2, variavel3 bool

Caso você inicie a variável, poderá omitir o tipo

var nome = "Rafael"
var idade = 29
var nacionalidade, ativo = "Brasileiro", true

Quando se está trabalhando dentro de uma função, você poderá utilizar o inicializador :=, omitindo a palavra var.

func main() {
    nome := "Rafael"
}

Voltar para Começando com go

Go workspaces

Antes de falarmos da linguagem, sintaxe, etc. Vamos falar sobre Workspaces.

Workspace é uma estrutura de diretórios/pastas onde o seu código go será mantido. Uma estrutura de workspace seguirá o seguinte formato:

  • $GOPATH
    • src – código go organizado em packages
    • bin – contém os executáveis
    • pkg – contém os objetos dos pacotes

O seu $GOPATH pode ser qualquer pasta. Como por exemplo ~/gocode ou c:\gocode.

Referências

Voltar para Começando com go

Instalando o Go

É bem fácil instalar o go na sua máquina. Você pode instalar a última versão do site oficial da linguagem: https://golang.org/doc/install. O go está disponível para os sistemas operacionais:

  • FreeBSD 8 superior
  • Linux 2.6.23 ou superior
  • Mac OS X 10.6 ou superior
  • Windows XP ou superior

Não vou me estender muito na instalação, pois pode acabar ficando obsoleto com o tempo. No lugar disso, deixarei a referência para o site do go, que possui instruções claras para todos os sistemas operacionais disponíveis

Voltar para Começando com go