Comience a desarrollar con Go en la Mac

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

Final product image — What You'll Be Creating

Las aplicaciones web son parte de la vida en estos días. El idioma Go, de Google, es un lenguaje útil para hacer aplicaciones basadas en la web. Te mostraré cómo comenzar a utilizar Go en una Mac.

Configuración del entorno Go

La forma más fácil de instalar el lenguaje de programación Go es con Homebrew. Si aún no ha instalado Homebrew, el tutorial Homebrew Demystified: OS X’s Ultimate Package Manager de OS X le mostrará cómo hacerlo.

En una terminal, escribe:

1	brew install go

Para encontrar la ubicación del directorio de instalación go, ingrese este comando en su programa de terminal:

1	ls -la `which go`

Deberías obtener este resultado:

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

Esto muestra que la instalación principal de Go es /usr/local/Cellar/go/1.2.2. Necesita configurar la variable de entorno GOROOT para que sea el directorio libexec de ese directorio.

En el directorio de inicio, crea el directorio go. El lenguaje go almacenará allí todos los paquetes descargados. Agregue a su archivo .bashrc y / o archivo .zshrc esta línea:

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

Si está utilizando fish, agréguelo a su archivo config.fish:

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

Para probar go, escriba lo siguiente en una terminal:

1	go version

Debería imprimir la versión de go que está instalada. En mi sistema en este momento, muestra la versión go version go1.2.2 darwin/amd64.

Para buscar versiones más nuevas, deje que HomeBrew lo descubra. En la línea de comando, escribe:

1	brew update
2	brew upgrade

El comando update obtendrá una lista de programas actualizados. El comando upgrade hace la actualización real. De esta forma, nunca tendrás que buscar los diferentes sitios web para encontrar actualizaciones.

Configurando el Editor

Ahora que Go está en el sistema, debe configurar el editor. Uso Sublime Text 3, Vim y Emacs mucho. Por lo tanto, necesito que mis editores estén al día con Go.

Para Sublime Text, es fácil. Instale Package Manager para Sublime Text. Esto permite instalaciones de paquetes fáciles. El paquete que desea instalar es goSublime. goSublime le brinda resaltado de sintaxis de lenguaje Go y un sistema de compilación Go.

Para instalar el resaltado de sintaxis Go para Emacs, instale las rutinas eLisp encontradas en $GOROOT/misc/emacs en su carpeta elisp de emacs. Para que Emacs cargue los nuevos archivos, agregue esta línea al archivo .emacs en la carpeta de inicio:

1	(require 'go-mode-load)

El soporte para Vim requiere más trabajo. En una terminal, ejecuta estas líneas 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

La última línea solo es necesaria si todavía no tiene sintaxis en su .vimrc.

Bibliotecas y cómo usarlas

Tradicionalmente, las bibliotecas son los conceptos básicos de la modularización de código para su reutilización. En go, las bibliotecas son paquetes. El idioma go viene con muchos paquetes integrados. Puede escanear a través de ellos en la página de paquetes. También hay muchos paquetes y proyectos de terceros.

Para el Title Case Server, voy a utilizar el paquete de terceros web.go. Es un marco de servidor web simple que simplifica la creación de aplicaciones basadas en web en Go. Para cargar ese paquete en su sistema, escriba lo siguiente:

1	go install github.com/hoisie/web

El comando install toma un argumento que es una dirección web, sin http://, para descargar un paquete. Se coloca en el directorio $GOPATH que se creó anteriormente.

El proyecto: Title Case Server

El caso del título es una de las cosas más exigentes. Algunas personas prefieren ciertas palabras siempre en minúsculas. Otros piensan que las palabras deberían ser todo el caso del título. Por lo tanto, para hacerlo correctamente (lo que la mayoría de las rutinas de paquetes no hacen), debe verificar cada palabra con dos diccionarios para que todo funcione correctamente. Es un gran proyecto para principiantes en un nuevo lenguaje de programación.

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

El símbolo // denota un comentario. El compilador ignora todo después de eso en la línea. Me gusta comentar todo. Cuando lees el código años después, los comentarios te ayudan a recordar cómo funciona el programa.

La línea después de los comentarios es la declaración del paquete. Cada archivo que usa Go debe ser parte de un paquete. Cada programa tiene solo un paquete principal que debe tener la función main(). Eso le dice al compilador dónde comenzar a ejecutar el programa.

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

Para hacer uso de paquetes, debe importarlos con import . Todos los paquetes usados deben estar en esta declaración. Incluyo los dos paquetes base de os para las funciones del sistema operativo y las cadenas para manipular cadenas. El Github.com/hoisie/web carga el paquete web.go para crear el 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 función crea la página de inicio. Esto es lo que el servidor le da a un navegador web que solicita la página frontal del sitio web. El comando func es una declaración de función. La homePage es el nombre de la función. La () le dice al compilador que esta función no toma ninguna entrada. La string después del paréntesis le dice al compilador que la función devolverá una cadena.

Todo dentro de {} es el código para la función. Esta función es simple: devuelve la cadena entrecomillada a la persona que llama de la función. En go, puedes citar cadenas con "", ’’, y ``. Usé el último aquí para tener una cadena de líneas múltiples que no se procesa en absoluto. Usted llama a eso una cadena literal.

Al usar el método de cita literal, puedo diseñar la página web como lo haría normalmente. El compilador no procesa nada dentro de las marcas. Se copia directamente en el programa, y el programa lo devuelve al navegador web a pedido.

//
// 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 hace el trabajo de traducir una cadena dada al servidor web en el equivalente de la caja del título.

El ctx *web.Context, val string le dice al compilador que esta función recibe dos variables. Uno es un puntero a la web.Context de datos de contexto definida en el paquete web.go. El otro es una cadena. Declaras una entrada variable por un nombre y el tipo de variable.

El símbolo * denota un puntero. Un puntero es una dirección a la ubicación en la memoria para la estructura de datos. Go sigue los formatos de puntero de datos C.

La primera instrucción obtiene el parámetro llamado text que el navegador pasa al servidor y lo divide por espacios. El strings.Split llama a la función Split dentro del paquete de strings. Puedes pensar en paquetes similares a los Objetos en C ++. Los llamas usando un . entre el nombre del paquete y el nombre de la función.

En cada paquete, cada función que comienza con una letra mayúscula es accesible desde fuera del paquete. Todas las funciones que comienzan con una letra minúscula solo son accesibles desde el interior del paquete.

Cuando la función strings.Split divide una cadena por el separador, devuelve una matriz de cadenas. La salida se asigna a las palabras variables words. Para crear una nueva variable, la primera vez que la utilice, debe usar a := para asignarla. Si desea cambiar la misma variable a otra matriz de cadenas, usaría el operador =.

A continuación, cree dos matrices para las diferentes listas de palabras. lower es para todas las palabras en minúsculas, y upper para todas las palabras en mayúscula. El [...] le dice al compilador que obtenga el número de asignaciones de los datos. De esta forma, puede agregar palabras a la lista sin preocuparse por aumentar el conteo. El string le dice al compilador que cada entrada en la matriz es una cadena.

Estoy usando for..range bucles para secuenciar sobre las matrices. El primero repasa cada palabra dada en la entrada, mientras que otros dos loops pasan por cada diccionario de palabras para cada palabra. Primero convierte la palabra a minúscula, la compara con cada palabra en el diccionario lower. Si hay una coincidencia, fuerza la palabra a todas las minúsculas asignando esa posición de palabra a la cadena en el diccionario. Luego hace exactamente lo mismo usando el diccionario upper.

Si la palabra no estaba en ninguno de los diccionarios, entonces realiza las strings.Title de título para la palabra. Esto fuerza a que la primera letra sea mayúscula y el resto a minúscula.

Por último, la primera palabra hizo el título sin importar. La función strings.Join ensambla la matriz de cadenas usando un espacio. Devuelve los resultados a la persona que llama de la función.

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

	return ""
}

La función killServer hace exactamente lo que su nombre implica: mata el servidor web. Envuelve una llamada a la función os.Exit() en el paquete 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")
}

La función main utiliza web.Get para configurar Get para obtener las rutas de protocolo para la página de inicio, la página de cierre y la rutina de conversión de mayúsculas y minúsculas. La web es el paquete web.go que descargamos anteriormente. El Get define una solicitud Get de HTML. También están los operadores Put, Post y Delete que puede definir.

La instrucción web.Run inicia el servidor web en la dirección y el puerto dados. El paquete web.go toma el control desde allí y llama a sus rutinas cada vez que se solicitan las direcciones definidas.

Compilando

Ahora que el programa está listo, debes compilarlo. Para compilar un programa Go, dígale que cree el archivo con la función principal. Para compilar este programa, escriba:

1	go build goTitleServer.go

Cuando termine, tendrá goTitleServer en el directorio. Ese es el programa completo. Puedes lanzarlo con:

1	./goTitleServer

A continuación, abra un navegador web para http://127.0.0.1:9910. Deberías ver esto:

Ingrese su cadena en el Text to fix: (texto para corregir:) cuadro de texto, presione Convert, y la cadena convertida aparecerá en el cuadro de texto Results:.

Flujo de trabajo del servidor de Title Case

Naturalmente, coloco este programa en un flujo de trabajo de Alfred. Es parte de la descarga junto con el archivo goTitleServer.go. Esto proporciona un ejemplo de uso del servidor sin un navegador web. Utiliza el siguiente código bash para consultar el servidor:

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

La primera línea cambia todos los espacios en la cadena de consulta query string a +. El comando curl es un comando estándar de Unix para obtener información de un servidor web. La línea de comando usará el comando curl una solicitud de URL como la página web crearía para enviarla. Lo que se devuelve en los resultados de convertir la cadena en title case.

Los comandos Alfred prompt para este flujo de trabajo son:

tis:launch–Este comando inicia el servidor. Tienes que lanzar el servidor antes de que puedas convertir.

tcs:convert–Este comando toma una cadena para convertir. El flujo de trabajo muestra el resultado en una notificación y lo copia al portapapeles.

tcs:kill–este comando mata el servidor web.

También hay una tecla de acceso rápido que debe asignar para tomar la selección actual y ejecutarla a través del servidor de caso de título y volver a pegarla.

Conclusión

Ahora que tiene el sistema configurado para escribir y compilar aplicaciones web usando Go, ¡necesita comenzar a escribir algunas! Tome esta base de código y amplíela a más funciones de procesamiento de texto para hacer un excelente servidor de procesamiento de texto.