Iniciando Desenvolvimento com Go no Mac

() translation by (you can also view the original English article)

Final product image — What You'll Be Creating

Atualmente aplicações web fazem parte das nossas vidas. A linguagem Go, do Google, é uma linguagem útil para construir aplicações web. Eu mostrarei a você como começar a usar Go no Mac.

Configurando o Ambiente Go

A forma mais simples para instalar a linguagem de programação Go é usando Homebrew. Se você ainda não possui o Homebrew, o tutorial Homebrew Demystified: OS X’s Ultimate Package Manager mostrará a você como.

Em um terminal, digite:

1	brew install go

Para encontrar a localização do diretório de instalação do go, digite este comando em seu programa de terminal:

1	ls -la `which go`

Você deve ter o seguinte resultado:

1	lrwxr-xr-x 1 raguay wheel 25 May 14 15:11 /usr/local/bin/go -> ../Cellar/go/1.2.2/bin/go

Isto mostrará que a instalação padrão do Go é /usr/local/Cellar/go/1.2.2. Você precisa configurar a variável de ambiente GOROOT para ser o diretório libexec do diretório.

No diretório home, crie um diretório chamado go. A linguagem go guardará todos os pacotes baixados lá. Adicione ao seu arquivo .bashrc e/ou .zshrc a seguinte linha:

1	export GOPATH="/Users/<your user name>/go"
2	export GOROOT="/<your go installation>/libexec"

Se você está usando fish, adicione isto a seu arquivo config.fish:

1	set -xg GOPATH "/Users/<your user name>/go"
2	set -xg GOROOT "/<your go installation>/libexec"

Para testar, digite o seguinte em seu terminal:

1	go version

Deverá ser exibido a versão, do go, que está instalado. Em meu sistema, é exibido go version go1.2.2 darwin/amd64.

Para verificar novas versões, deixe aos cuidados do HomeBrew. Na linha de comando, digite:

1	brew update
2	brew upgrade

O comando update irá obter uma lista dos programas que foram atualizados. O comando upgrade irá atualizar propriamente dito. Desta forma, você nunca terá que buscar em vários sites por atualizações.

Configurando o Editor

Agora que o Go está instalado no seu sistema, você precisa configurar o editor. Eu uso muito Sublime Text 3, Vim, e Emacs. Portanto, Eu preciso levar meus editores a mesma velocidade com Go.

Para o Sublime Text, é fácil. Instale Gerenciador de Pacotes para Sublime Text. Ele permite instalações mais simples de pacotes. O pacote que você quer instalar é goSublime. goSublime te dar destaque de sintaxe da linguagem Go e um sistema de build para o Go.

Para instalar destaque de sintaxe do Go no Emacs, instale as rotinas eLisp encontradas em $GOROOT/misc/emacs em seu diretório elisp. Para que o Emacs carregue estes novos arquivos, adicione esta linha ao seu arquivo .emacs no diretório home.

1	(require 'go-mode-load)

O suporte para o Vim dar um pouco mais de trabalho. Em um terminal, rode estas linhas de comando bash:

mkdir -p $HOME/.vim/ftdetect
mkdir -p $HOME/.vim/syntax
mkdir -p $HOME/.vim/autoload/go
ln -s $GOROOT/misc/vim/ftdetect/gofiletype.vim $HOME/.vim/ftdetect/
ln -s $GOROOT/misc/vim/syntax/go.vim $HOME/.vim/syntax
ln -s $GOROOT/misc/vim/autoload/go/complete.vim $HOME/.vim/autoload/go
echo "syntax on" >> $HOME/.vimrc

A última linha somente é necessário se você já não tiver a configuração syntax on em seu .vimrc.

Bibliotecas e como usa-las

Tradicionalmente, bibliotecas são o básico da modularização de código para reuso. Em go, bibliotecas são pacotes. A linguagem go vem com muitos pacotes incluídos. Você pode ver todos eles na página de pacotes. Há também muitos pacotes e projetos da comunidade.

Para o Title Case Server, eu vou usar o pacote de terceiro web.go. É um simples framework web que simplifica a criação de aplicações web em Go. Para baixar o pacote no seu sistema, digite o seguinte:

1	go install github.com/hoisie/web

O comando para instalar leva um argumento que é um endereço web, sem o http://, para o download do pacote. Ele é colocado no diretório $GOPATH que foi criado antes.

O Projeto: Title Case Server

Title case é uma coisas mais exigentes. Algumas pessoas pessoas gostam de algumas palavras sempre em caixa baixa. Outros acham que todas as palavras deveriam estar Capitalizadas. Embora, para fazer corretamente (Que a maioria das rotinas não fazem) você deve verificar cada palavra em um dicionário de palavras para ter tudo correto. Isto faz um belo projeto para iniciante em uma nova linguagem de programação.

//
// Package:       Main
//
// Description:  This is the main package for the goTitleServer.
//  	      This is a simple web technology based title case
//                     text server.
//
package main

O simbolo // representa um comentário. O compilador ignora tudo após ele na mesma linha. Eu gosto de comentar tudo. Quando você lê o código anos depois, os comentários ajudam você a lembrar como o programa funciona.

A linha após os comentários é a declaração de pacote. Cada arquivo que Go usa deve ser parte de um pacote. Cada programa possui somente um pacote main que deve possuir uma função main(). Isto instrui o compilador onde o programa deve iniciar.

//
// Import the libraries that we need for the server.
//
import (
	"github.com/hoisie/web"
	"os"
	"strings"
)

Para fazer uso de pacotes, você deve importar-los. Todos os pacotes usados devem estar nesta parte. Eu estou incluíndo dois pacotes básicos de os para as funções do sistema operacional, e strings para manipulação de strings. O github.com/hoisie/web Carrega o pacote web.go para construir um servidor web.

//
// Function:             homePage
//
// Description:         This function will server the home page for inputing the string
//                             to convert.
//
func homePage() string {
    return `
<!doctype html>
<html lang="en">
	<head>
		<meta charset="utf-8" />
		<title>Title Case Server</title>
		<!--[if IE]>
			<script src="http://html5shiv.googlecode.com/svn/trunk/html5.js">
			</script>
		<![endif]-->
		<style>
			body {
				width:		100%;
			}

			header {
				background: 	lightblue;
				width:		80%;
				height:		100px;
				margin:		20px auto;
				border-radius:	10px;
			}

			header h3 {
				text-align:		center;
				padding-top:	40px;
				font-size:		28px;
			}

			content {
				font-size:		16px;
			}

			content form {
				font-size:		inherit;
				margin:		auto;
				padding-left:	8px;
				width:		80%;
				text-align:		center;
			}

			content form p input {
				width:		80%;
			}

			content form button {
				margin: 		auto;
				border-radius:	10px;
			}
		</style>
 		<script type="text/javascript" src="http://code.jquery.com/jquery-1.11.1.min.js">
 		</script>
 		<script type="text/javascript" >
 			window.convert = function() {
 				$.ajax({
 					type: "GET",
 					url: "http://127.0.0.1:9910/titlecase/",
 					data: { text: $("#text").val()}
 				}).done(function(msg) {
	 				$("#result").val(msg);
 				});
 			};
		</script>
	</head>
	<body>
 		<header>
 			<h3>Title Case Server</h3>
 		</header>
 		<content>
 			<form action="/titlecase/" method="get">
 				<p>Text to fix:
 					<input id="text" type="text" name="text" >
 					</input>
 				</p>
 				<button type="button" id="convert" text="Convert" onclick="window.convert();">Convert</button>
 				<p>Results:
 					<input id="result" type="text" name="result">
 					</input>
 				</p>
 			</form>
 		</content>
 		<footer>
 		</footer>
	</body>
</html>
	`
}

Esta função cria uma página inicial. Isto é o que o server nos da para um navegador web quando ele requisita a página inicial de um site. O comando func é uma declaração de função. homePage é o nome da função. Os () instruem o compilador que esta função não tem nenhuma entrada. A string após os parênteses instrui o compilador que a função irá retornar uma string.

Tudo dentro de {} é o código da função. Esta função é simples: retorna a string a string entre aspas a quem chamou a função. Em go, você pode usar strings com "", '' e ``. Eu costumo usar a última pata ter string em múltiplas linhas que não são processadas. Você a chama de literal de string.

Em usar o método de strings literais, eu posso fazer o layout de uma página exatamente como eu faria normalmente. Nada dentro das marcas de apostrofos serão processadas pelo compilador. É apenas copiado diretamente no programa, e o programa retorna para o navegador quando é requisitado.

//
// Function:            titleCase
//
// Description:        This takes a string and converts it to Title case. It then
//                             returns the string.
//
// Input:
//                            val         rest of the url if given any.
//
func titleCase(ctx *web.Context, val string) string {
    //
	// Get the string to convert and split it up by spaces.
	//
	words := strings.Split(ctx.Params["text"], " ")

	//
	// The array of words that should be lower case always, unless it is the first word
	// of the title.
	//
	lower := [...]string{"to", "an", "and", "at", "as", "but", "by", "for", "if", "in", "on", "or", "is", "with", "a", "the", "of", "vs", "vs.", "via", "via", "en"}

	//
	// The array of words that should be all upper case always.
	//
	upper := [...]string{"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "HTML", "CSS", "AT&T", "PHP"}

	//
	// For every word in the Title.
	//
	for i, _ := range words {
		//
		// Assume the word is not in the upper case or lower case arrays.
		//
		up := false
		low := false

		//
		// Loop through every word in the lower case array.
		//
		for j, _ := range lower {
			if strings.ToLower(words[i]) == lower[j] {
				//
				// It matches. Make sure the word in the array is the same.
				// Set the up flag as true.
				//
				words[i] = lower[j]
				low = true
			}
		}

		//
		// Loop through every word in the upper case array.
		//
		for k, _ := range upper {
			if strings.ToUpper(words[i]) == upper[k] {
				//
				// It matches. Make sure the word is the array is the same.
				// Set the low flag to true.
				//
				words[i] = upper[k]
				up = true
			}
		}

		//
		// If the word was not in the upper or lower array, then do a normal
		// title case conversion. This makes the first letter upper case and all
		// the other letters lower case.
		//
		if (!up) && (!low) {
			words[i] = strings.Title(words[i])
		}
	}
	//
	// Make sure the first word is title case!
	//
	words[0] = strings.Title(words[0])

	//
	// Return the Title by joining all the words with a space.
	//
	return strings.Join(words, " ")
}

Este código realiza o trabalho de tradução uma string dada ao servidor web na capitalizada equivalente.

O ctx *web.Context, val string instrui o compilador que esta função recebe duas variáveis. Uma é um ponteiro para a estrutura web.Context definida no pacote web.go. A outra é uma string. Você declara uma variável pelo nome e tipo da variável.

O simbolo * representa um ponteiro. Um ponteiro é um endereço para uma localização de uma estrurtura de dados na memória. Go segue os formatos de dados do C.

O primeira linha obtém um parâmetro nomeado chamado text que o browser pass ao servidor e o corta em espaços. A chamada a strings.Split chama a função Split dentro do pacote strings. Você pode pensar em pacotes similares a objetos em C++. Você pode chama-los usando um . Entre o nome do pacote e o nome da função.

Em todos os pacotes, cada função que inicia com uma letra em caixa alta é acessível de fora do pacote. Cada função que iniciar com uma letra em caixa baixa é acessível somente dentro do pacote.

Quando a função strings.Split quebra a string pelo separador, ela retorna um array de strings. A saída é então atribuída a variável words. Para criar uma nova variável, na primeira vez que é usada, você deve usar a := para atribuir. Se você quer alterar a mesma variável para outra array de strings, você deve usar o operador =.

Próximo, criar dois arrays para as diferentes listas de palavras. lower para todas as palavras em caixa baixa, e upper para todas as palavras em caixa alta. O [...] instrui o compilador a ter o número de atribuições de um dado. Desta forma você pode adicionar palavras a lista sem se preocupar em incrementar a contagem. A string instrui o compilador que cada entrada no array é uma string.

Estou usando looping for...range para iterar nos arrays. O primeiro iteram em cada palavra dada na entrada, enquanto os outros dois iteram em cada dicionários de palavras para cada palavra. Inicialmente converte a palavra em caixa baixa, a compara a cada palavra no dicionário lower de caixa baixa. Se encontra algum, ele força a palavra para todas de caixa baixa atribuindo cada posição da palavra a string no dicionário. Ele então faz exatamente o mesmo com o dicionário upper.

Se a palavra não estava em nenhum dicionário, então ele chama a função strings.Title na palavra. Isto força a primeira letra para ficar em caixa alta e todas as restantes em caixa baixa.

Por último, a primeira palavra feita em capitalizada não importa qual. A função strings.Join monta o array de strings usando espaços. Ela retorna os resultados a quem chamou a função.

//
// Function:             killServer
//
// Description:         This function will stop the server.
//
func killServer() string {
	os.Exit(0)

	return ""
}

A função killServer faz exatamente o que o nome implica: mata o servidor web. Ela envolve uma chamada a função os.Exit() no pacote os.

//
// Function:             main
//
// Description:         This is the main function that is called upon program running.
//
func main() {
    //
	// set the titlecase web address to the proper function.
	//
	web.Get("/titlecase/(.*)", titleCase)

	//
	// Set up a path to kill the server.
	//
	web.Get("/kill", killServer)

	//
	// send the home page to the proper function.
	//
	web.Get("/", homePage)

	//
	// Run the server on the local machine at port 9911
	//
	web.Run("127.0.0.1:9910")
}

A função main usa web.Get para configurar as rotas para o protocolo Get para a página inicial, a página que mata, e a rotina que capitaliza strings A web é o pacote web.go que nós fizemos download antes. O Get define uma requisição Get HTML. Há também operadores Put, Post, e Delete que você pode definir.

A linha web.Run inicia o servidor web em um dado endereço e porta. O pacote web.go segue adiante e chama suas rotinas sempre que o endereço definido é chamado.

Compilando

Agora que o programa está concluído, você precisa compila-lo. Para compilar um programa em Go, você instrui a construir o arquivo que a função main está localizada. Para compilar este programa, você digita:

1	go build goTitleServer.go

Quando concluído, você terá um arquivo chamad goTitleServer no diretório É o programa inteiro. Você pode inicia-lo com:

1	./goTitleServer

Então abra um navegador e acesse http://127.0.0.1:9910. Você deve ver isso:

Entre sua string em na caixa de texto: Text to fix e pressione Convert, e a string convertida irá aparecer na caixa de texto Results.

Wordflow Title Case Server.

Eu naturalmente ponho este programa em workflow Alfred. É parte do download junto com o arquivo goTitleServer.go Isto é um exemplo em como usar um servidor sem um navegador. Ele usa o seguinte código bash para pesquisar no servidor:

1	query=`echo "{query}" \| sed -e 's/ /+/g'`;
2	curl "http://localhost:9910/titlecase/?text=$query";

A primeira linha altera todos os espaços na query string para +. O comando curl é um comando padrão unix para obter informações de um servidor web. A linha de comando usará o comando curl para fazer uma requisição web a página. O que é retornado é o resultado da conversão da string em capitalização.

Um prompt de comando Alfred para este workflow é:

tis:launch - Este é um comando que inicia um servidor. Você deve iniciar o servidor antes de você converter.

tsc:convert - Este comando leva uma string para converter. O workflow exibe o resultado em uma notificação e copia para o clipboard.

tsc:kill - Este comando mata servidor web.

Há também um atalho que você precisa configurar para a seleção atual e rodar contra o servidor e colar de volta novamente.

Conclusão

Agora que você tem o sistema configurado para escrever e compilar aplicações web usando Go, você precisa iniciar a escrever alguns! Tome este código como base e expanda para mais funções de processamento de texto e faça um grande servidor de processamento de texto.

Seja o primeiro a saber sobre novas traduções–siga @tutsplus_pt no Twitter!