¿Cómo instalar el lenguaje de programación Go?

Español

Go es una lenguaje de programación con una sintaxis clara, concisa y fácil de leer, es concurrente, fuertemente tipado, con seguridad de memoria y recolector de basura. Ha sido desarrollado bajo el paragua de Google y sus diseñadores iniciales fueron Robert Griesemer, Rob Pike y Ken Thompson.

En el post de hoy veremos como instalar Go y desarrollar una aplicación sencilla.

Descargar

Nos decargamos la última versión desde Downloads, seleccionamos el fichero de acuerdo a nuestra arquitectura de nuestra computador o dispositivo en este caso: amd64

$ curl -LO# https://go.dev/dl/go1.19.5.linux-amd64.tar.gz

Como muestra el comando anterior estamoa descargando la versión: 1.19.5

Instalar

Instalaremos Go debajo del DIR .local (si no existe debe crearlo) que esta en $HOME.

Si tiene alguna instalación previa elimínela con:

$ rm -Rfv $HOME/.local/go

luego:

$ tar -C $HOME/.local -xzf go1.19.5.linux-amd64.tar.gz

Agregamos la siguiente línea a $HOME/.profile

export PATH=$PATH:$HOME/.local/go/bin

Es probable que tenga que reiniciar su computadora para que el cambio surta efecto, también puede ejecutar el comando:

$ export PATH=$PATH:$HOME/.local/go/bin

Para agregar el binario al PATH de manera temporal

Comprobar la versión de go:

$ go version
go version go1.19.5 linux/amd64

Para obtener ayuda ejecute:

$ go help
Go is a tool for managing Go source code.

Usage:

	go <command> [arguments]

The commands are:

	bug         start a bug report
	build       compile packages and dependencies
	clean       remove object files and cached files
	doc         show documentation for package or symbol
	env         print Go environment information
	fix         update packages to use new APIs
	fmt         gofmt (reformat) package sources
	generate    generate Go files by processing source
	get         add dependencies to current module and install them
	install     compile and install packages and dependencies
	list        list packages or modules
	mod         module maintenance
	work        workspace maintenance
	run         compile and run Go program
	test        test packages
	tool        run specified go tool
	version     print Go version
	vet         report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

	buildconstraint build constraints
	buildmode       build modes
	c               calling between Go and C
	cache           build and test caching
	environment     environment variables
	filetype        file types
	go.mod          the go.mod file
	gopath          GOPATH environment variable
	gopath-get      legacy GOPATH go get
	goproxy         module proxy protocol
	importpath      import path syntax
	modules         modules, module versions, and more
	module-get      module-aware go get
	module-auth     module authentication using go.sum
	packages        package lists and patterns
	private         configuration for downloading non-public code
	testflag        testing flags
	testfunc        testing functions
	vcs             controlling version control with GOVCS

Use "go help <topic>" for more information about that topic.

Creando el mítico ejemplo ¡Hola mundo!

Nos movemos al DIR en que tenemos nuestros proyectos y creamos el DIR holamundogo

$ mkdir holamundogo

Nos movemos al DIR holamundogo

$ cd holamundogo

Para administrar la dependencias de nuestro proyecto usaremos el comando go mod y para inicializar la administración de dependencias go mod init

$ go mod init miap/holamundogo

Creamos el fichero hola.go y agregamos:

package miap

import "fmt"

func main() {
    fmt.Println("¡Hola, mundo!")
}

Ejecutamos nuestro mítico ejemplo:

$ go run .
¡Hola, mundo!

En el ejemplo anterior declaramos nuestro paquete miapp (un paquete es una forma de agrupar funciones y está formado por todos los archivos en el mismo directorio) e importamos el paquete fmt de la librería estándar (que contiene funciones para formatear texto, incluida la impresión en la consola) y por último declaramos la función main, todo programa desarrollado en go debe tener una función maain que es la entrada principal a nuestro programa.

Creando una app que con dependencias externas

Creamos un pequeño proyecto que va a mostrar por consola un proverbio Go, llamamos all proyecto quotego y seguimos los pasos anteriores.

Inicializamos las dependencias con:

go mod init myapp/quote
go: creating new go.mod: module myapp/quote

Creamos el fichero quote.go y agregamos la siguientes líneas:

package main

import "fmt"

import "rsc.io/quote"

func main() {
    fmt.Println(quote.Go())
}

Instalamos las dependencias con:

$ go mod tidy
go: finding module for package rsc.io/quote
go: downloading rsc.io/quote v1.5.2
go: found rsc.io/quote in rsc.io/quote v1.5.2
go: downloading rsc.io/sampler v1.3.0
go: downloading golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c

Puede encontrar módulos desarrollados por la comunidad en: https://pkg.go.dev/

Ejecutamos el proyecto:

$ go run .
Don't communicate by sharing memory, share memory by communicating.

Si de desea contruir un binario ejecute el comando:

$ go build .

luego puede llamar al binario:

$ ./quote 
Don't communicate by sharing memory, share memory by communicating.

En el día de hoy aprendimos a como instalar el lenguaje de programación Go y nos familiarizamos con el concepto de dependencias, paquetes y binarios.

Enlaces de interés

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.