Como escrever código Go

Introdução

Este documento explica como escrever uma nova package e como testar o código. Ele assume que você tenha instalado Go, usando as instruções de instalação.
N.T. - Aqui mesmo neste blog, disponibilizei a tradução do tutorial de instalação.

Antes de embarcar em uma mudança de uma package existente ou na criação de uma nova package, é uma boa idéia enviar uma mensagem à lista de correspondência para que as pessoas saibam o que você pretende fazer. Agindo assim você ajuda a evitar duplicação de esforços e habilitar discussões sobre design antes que haja muito código escrito.

Recursos da comunidade

Para ajuda em tempo real, podem haver usuários ou desenvolvedores em #go-nuts no servidor Freenode IRC. A lista oficial para discussão da linguagem Go é Go Nuts.

Bugs podem ser relatados usando o Go issue tracker”.

Para aqueles que desejem acompanhar o desenvolvimento, existe outra lista, golang-checkins, que recebe uma mensagem resumindo cada checkin feito no repositório Go.

Criando uma nova package

O código-fonte para a package com caminho import x/y é, por convenção, mantida no diretório $GOROOT/src/pkg/y/y.

Makefile

Seria bom ter ferramentas específicas Go que verificassem os arquivos-fonte para determinar o que montar e em que ordem, mas por enquanto, Go usa a ferramenta GNU make. Portanto, o primeiro arquivo a criar em uma diretório de uma nova package é geralmente
o Makefile. A forma básica usada na árvore de fontes de Go é ilustrada por src/pkg/container/vector/Makefile:

include ../../../Make.$(GOARCH)
 
TARG=container/vector
GOFILES=\
	intvector.go\
	stringvector.go\
	vector.go\
 
include ../../../Make.pkg

Fora da árvore de fontes de Go (para packages pessoais), a forma padrão é

include $(GOROOT)/src/Make.$(GOARCH)
 
TARG=mypackage
GOFILES=\
	my1.go\
	my2.go\
 
include $(GOROOT)/src/Make.pkg

A primeira e a última linha incluem definições padrão e regras. Packages mantidas na árvore padrão Go usam um caminho relativo (ao invés de $(GOROOT)/src) de modo que make trabalhará corretamente mesmo se $(GOROOT) contiver espaços. Isto torna fácil aos programadores experimentar Go.
TARG é o caminho alvo de instalação para a package, a string que clientes usarão para importa-la. Dentro da árvore Go, a string deve ser a igual ao diretório no qual o Makefile aparece, como o prefixo $GOROOT/src/pkg removido. Fora da árvore Go, você pode usar qualquer TARG que deseje desde que não conflite com o nome de packages padrão Go.
Uma convenção comum é usar um nome identificador de primeiro nível para agrupar suas packages: myname/tree, myname/filter, etc. Observe que mesmo que você mantenha suas packages fora da árvore Go, a execução de “make install” instalará os binários de sua package no local padrão - $GOROOT/pkg - para facilitar a sua localização.

GOFILES é uma lista de arquivos-fonte a serem compilados para criar a package. O caracter \ no final de cada linha permite quebras a lista em linhas múltiplas para faciliar
a ordenação.
Se você criar um diretório de uma nova package na árvore Go, adicione-o a lista em $GOROOT/src/pkg/Makefile de modo que ele seja incluido na montagem padrão. Então execute:

cd $GOROOT/src/pkg
./deps.bash

para atualizar o arquivo de dependências - Make.deps (Isto acontece automaticamente cada vez que você executa all.bash ou make.bash).

Se você altera os imports de uma package existente, não precisa editar $GOROOT/src/pkg/Makefile mas ainda precisará executar deps.bash como acima.

Arquivos-fonte Go

A primeira declaração em cada arquivo-fonte listado no Makefile deve ser o nome da package, onde “nome” é o nome padrão da package para “imports” (Todos os arquivos em uma package devem usar o mesmo nome). A convenção de Go é que o nome da package seja o último elemento do caminho do import: a package importada “crypto/rot13″ deve ser nomeada rot13. No momento, as ferramentas Go impõem uma restrição que nomes de packages sejam únicos em todas as packages relacionadas a um único binário, mas esta restrição será abolida em breve.

Go compila todos os arquivos-fonte em uma package de uma vez, então um arquivo pode fazer referência a constantes, variáveis, tipos e funções em outro arquivo sem arranjos especiais ou declarações.

Escrever código Go limpo e idiomático está além do escopo deste documento. O documento Effective Go é uma introdução a este tópico.

Testando

Go tem um framework de teste peso-leve conhecido como gotest. Você escreve um teste criando um arquivo com o nome terminado em _test.go que contém funções nomeadas TestXXX com a assinatura func(t *testing.T). O framework de teste executa cada uma destas funções; se a função chama uma função de falha como t.Error ou f.Fail, o teste é considerado como tendo falhado.
A documentação do comando gotest e a documentação da package testing dão mais detalhes.

Os arquivos *_test.go não devem estar listados no Makefile.

Para executar o teste, execute make test ou gotest (são equivalentes). Para executar apenas os testes em um único arquivo de teste, por exemplo one_test.go, execute gotest one_test.go.

Se sua mudança afeta performance, adicione uma função Benchmark (veja a documentação do comando gotest) e execute-a usando gotest -benchmarks=..

Uma vez que seu novo código esteja testado e funcionando, é hora de revisa-lo e submete-lo.

Tags: Go, Google, Linguagens de programação