manual de go, Apuntes de Programación Informática

¡Descarga manual de go y más Apuntes en PDF de Programación Informática solo en Docsity!

Roberto Costumero Moreno

ACM Cap´ıtulo de Estudiantes

Facultad de Inform´atica, UPM

Abril 2010

El logotipo de Go y la informaci´on correspondiente al presente manual ha sido obtenida, recopilada y modificada adecuadamente de la p´agina oficial de Go, http://golang.org. El logotipo de Go y la informaci´on referente al lenguaje est´an licenciadas por GoogleTM bajo una Licencia Reconocimiento 3.0 de Creative Commons y puede consultarse en la si- guiente direcci´on: http://creativecommons.org/licenses/by/3.0/es/. El uso del logotipo y de la informaci´on est´an autorizados por la presente licencia mencionando su correcta atribuci´on.

2010 ACM Cap´ıtulo de Estudiantes - Facultad de Inform´atica UPM ACM Cap´ıtulo de Estudiantes Facultad de Inform´atica - Universidad Polit´ecnica de Madrid Campus de Montegancedo s/n 28660 Boadilla del Monte MADRID (ESPA ˜NA)

Esta obra puede ser distribuida ´unicamente bajo los t´erminos y condiciones expuestos en la Licencia Reconocimiento-No Comercial-Compartir bajo la misma licencia 3.0 Espa ˜na de Creative Commons o superior (puede consultarla en http://creativecommons.org/licenses/by- nc-sa/3.0/es/ ).

ACM Cap´ıtulo de Estudiantes - Facultad de Inform´atica UPM no se responsabiliza de las opiniones aqu´ı vertidas por el autor.

Indice general´

• 1. Introducci´on
  • 1.1. ¿Qu´e es Go?
  • 1.2. ¿Qui´en lo desarrolla?
  • 1.3. ¿Por qu´e crear un nuevo lenguaje?
  • 1.4. Recursos
    • 1.4.1. golang.org
    • 1.4.2. #go-nuts
    • 1.4.3. Lista de correo Go Nuts
    • 1.4.4. Gestor de errores
    • 1.4.5. http://go-lang.cat-v.org/
  • 1.5. ¿C´omo instalarlo?
  • 1.6. Compilando
    • 1.6.1. gccgo
    • 1.6.2. 6g/8g
  • 1.7. Otras herramientas
    • 1.7.1. Godoc
    • 1.7.2. Gofmt
  • 1.8. Manteni´endose al d´ıa
• 2. Caracter´ısticas y tipos b´asicos
  • 2.1. Nuestro primer programa: Hello World!
  • 2.2. Garbage Collector
  • 2.3. Las bases del lenguaje
  • 2.4. Comentarios
  • 2.5. Literales
  • 2.6. Vistazo r´apido de la sintaxis
  • 2.7. Tipos
    • 2.7.1. N´umeros
    • 2.7.2. Bool
    • 2.7.3. String
  • 2.8. Operadores
    • 2.8.1. Diferencias con C
    • 2.8.2. Ejemplos
  • 2.9. Conversiones
  • 2.10. Valores constantes y n´umeros ideales
  • 2.11. Declaraciones
    • 2.11.1. Variables
    • 2.11.2. Constantes
    • 2.11.3. Tipos
    • 2.11.4. Operador new vs. funci´on make
    • 2.11.5. Asignaciones
• 3. Estructuras de control
  • 3.1. Sentencia condicional: if
  • 3.2. Sentencia condicional: switch
  • 3.3. Bucles: for
  • 3.4. Instrucciones break y continue
  • 3.5. Funciones
  • 3.6. ¿Y qu´e hay del 0?
  • 3.7. Defer
  • 3.8. Funciones an´onimas, λ-programaci´on y closures
• 4. Estructuraci´on de programas
  • 4.1. Paquetes y estructura de los ficheros fuente
  • 4.2. Ambito de una variable .´
  • 4.3. Inicializaci´on
  • 4.4. Testing
  • 4.5. Librer´ıas
    • 4.5.1. Fmt
    • 4.5.2. Os
    • 4.5.3. Os - Entrada/salida en ficheros
    • 4.5.4. Otras librer´ıas
• 5. Tipos de datos compuestos
  • 5.1. Arrays
  • 5.2. Slices
  • 5.3. Maps
    • 5.3.1. Indexando un map
    • 5.3.2. Comprobando la existencia de una clave
    • 5.3.3. Borrando una entrada
    • 5.3.4. Bucle for y range
  • 5.4. Structs
    • 5.4.1. Exportaci´on de tipos
    • 5.4.2. Atributos an´onimos
    • 5.4.3. Conflictos
• 6. Orientaci´on a Objetos
  • 6.1. M´etodos
    • 6.1.1. M´etodos para structs
    • 6.1.2. Invocaci´on de m´etodos
    • 6.1.3. Reglas para el uso de m´etodos
    • 6.1.4. Punteros y valores en los m´etodos
    • 6.1.5. Atributos an´onimos en los m´etodos
    • 6.1.6. M´etodos con otros tipos
    • 6.1.7. El m´etodo String()
    • 6.1.8. Visibilidad de atributos y m´etodos
  • 6.2. Interfaces
    • 6.2.1. Introducci´on sobre interfaces
    • 6.2.2. Definici´on de interfaz
    • 6.2.3. El tipo interface
    • 6.2.4. El valor interfaz
    • 6.2.5. Hechos de los interfaces
    • 6.2.6. Ejemplo: io.Writer
    • 6.2.7. Comparaci´on con C++
    • 6.2.8. Contenedores y la interfaz vac´ıa
    • 6.2.9. Asertos de tipos
    • 6.2.10. Conversi´on de una interfaz a otra
    • 6.2.11. Probando interfaces con asertos
    • 6.2.12. El paquete reflect
• 7. Concurrencia y comunicaci´on
  • 7.1. Goroutines
    • 7.1.1. Definici´on
    • 7.1.2. C´omo crear una Goroutine
    • 7.1.3. Verdades delas Goroutines
    • 7.1.4. Pila de una Goroutine
    • 7.1.5. Scheduling
  • 7.2. Channels
    • 7.2.1. El tipo channel
    • 7.2.2. El operador < −
    • 7.2.3. Sem´antica de canales
    • 7.2.4. Ejemplo de comunicaci´on
    • 7.2.5. Funciones que devuelven canales
    • 7.2.6. Rangos y canales
    • 7.2.7. Cerrando un canal
    • 7.2.8. Iteradores
    • 7.2.9. Direccionalidad de un canal
    • 7.2.10. Canales s´ıncronos
    • 7.2.11. Canales as´ıncronos
    • 7.2.12. Probando la comunicaci´on
  • 7.3. Select
    • 7.3.1. Definici´on
    • 7.3.2. Sem´antica de select
    • 7.3.3. Ejemplo: Generador aleatorio de bits
  • 7.4. Multiplexaci´on
    • 7.4.1. El servidor
    • 7.4.2. El cliente
    • 7.4.3. La contrapartida
  • 7.5. Problemas de concurrencia
• 8. Modelo de Memoria de Go
  • 8.1. Lo que primero ocurre
  • 8.2. Sincronizaci´on
    • 8.2.1. Inicializaci´on
    • 8.2.2. Creaci´on de Goroutines
    • 8.2.3. Comunicaci´on mediante canales
  • 8.3. Cerrojos - Locks
  • 8.4. El paquete once
  • 8.5. Sincronizaci´on incorrecta

1.2. ¿Qui´en lo desarrolla?

Go es un proyecto promovido por cinco personas: Rob Pike, Robert Griesemer y Ken Thom- pson, en primera instancia, a los que se unieron posteriormente Russ Cox e Ian Lance Taylor. Todos los anteriormente citados, forman parte de GoogleTM. Varios de ellos desarrollaron el Sistema Operativo Plan 9 y han retomado muchas de las ideas originales para la creaci´on de este nuevo lenguaje de programaci´on.

1.3. ¿Por qu´e crear un nuevo lenguaje?

Existen varias razones por las que crear un nuevo lenguaje de programaci´on.

Para empezar, el mundo inform´atico ha avanzado enormemente en la ´ultima d´ecada, a la par que no han aparecido nuevos lenguajes de programaci´on para sistemas. Actualmente, nos podemos encontrar las siguientes casu´ısticas:

Los ordenadores son mucho m´as r´apidos, pero no as´ı el desarrollo de software.

Los sistemas software tienen una gran dependencia, por lo que a la hora de compilar es importante realizar un an´alisis eficiente de las dependencias entre los distintos ficheros, algo que no ocurre en los actuales “ficheros de cabecera” de C.

Existe una tendencia creciente al uso de lenguajes de tipado din´amico, como Python y Javascript.

La recolecci´on de basura o la computaci´on paralela, no est´an soportadas adecuadamente por los lenguajes de sistemas m´as populares.

El aumento del n´umero de n´ucleos en los ordenadores, ha provocado confusi´on y quebra- deros de cabeza respecto a la programaci´on concurrente y paralela.

1.4. Recursos

Pese a que Go es un lenguaje de reciente creaci´on, ya existen numerosos sitios de infor- maci´on sobre el lenguaje, aunque no siempre son f´aciles de encontrar debido a que el t´ermino ”Go” es muy com´un en ingl´es.

Algunos ejemplos:

1.4.1. golang.org

El sitio web oficial del lenguaje, no olvid´eis su direcci´on: http://golang.org. Toda la infor- maci´on que quer´ais encontrar respecto al lenguaje, seguro que estar´a ah´ı.

Como curiosidad, comentar que la propia p´agina web est´a hecha en Go, utilizando el ser- vidor web empotrado y una serie de templates HTML que trae ”de serie”. A continuaci´on, un enlace r´apido a los sitios m´as importantes dentro de la p´agina:

ACM Cap´ıtulo de estudiantes 9 FI - UPM

http://golang.org/doc Acceso al listado de los ficheros de documentaci´on.

http://golang.org/cmd Acceso a la documentaci´on sobre los comandos que pueden usarse.

http://golang.org/pkg Acceso a la documentaci´on de todos los paquetes existentes en Go.

http://golang.org/src Acceso al c´odigo fuente de distintos ficheros de apoyo.

1.4.2. #go-nuts

Existe un canal de chat oficial en IRC para discutir acerca del lenguaje. Si quieres una sesi´on live sobre Go, entra en el canal #go-nuts en el servidor irc.freenode.net.

1.4.3. Lista de correo Go Nuts

La lista oficial de correo de Go, se puede encontrar en la siguiente direcci´on: http://groups.google.com/group/golang-nuts?pli=1. Podr´as darte de alta, ya que es una lista abierta, y recibir y enviar correos con todas las dudas que te surjan.

1.4.4. Gestor de errores

Hay una p´agina dedicada a gestionar todos los posibles errores del lenguaje, para ser as´ı re- sueltos de forma eficiente. Si quer´eis echarle un vistazo, la pod´eis encontrar en: http://code.google.com/p/go/issues/list

1.4.5. http://go-lang.cat-v.org/

Un sitio web mantenido a partir de todas las aportaciones de la gente a trav´es de la lista de correo oficial. Contiene muchas librer´ıas actualmente en desarrollo, ports del lenguaje a otros entornos (entre ellos Windows), y sobre todo, archivos de coloreado de c´odigo fuente para un mont´on de programas de edici´on de texto.

1.5. ¿C´omo instalarlo?

Para instalar todas las librer´ıas de Go y las herramientas propias del lenguaje, hay que seguir unos sencillos pasos. Los aqu´ı mencionados son los que aparecen en la p´agina oficial y est´an pensados para cualquier arquitectura basada en UNIX.

1. Inicializar la variable $GOROOT que indica el directorio ra´ız de Go. T´ıpicamente es el directorio $HOME/go, aunque puede usarse cualquier otro.
2. Inicializar las variables $GOOS y $GOARCH. Indican la combinaci´on de Sistema Ope- rativo y Arquitectura utilizada. Los posibles valores son los que se observan en la tabla superior.
3. Inicializar la variable $GOBIN (opcional), que indica d´onde ser´an instalados los binarios ejecutables. Por defecto es $HOME/bin. Tras la instalaci´on, es conveniente agregarla al $PATH, para poder usar las herramientas desde cualquier directorio.

ACM Cap´ıtulo de estudiantes 10 FI - UPM

Para compilar la distribuci´on de Go, hay que ejecutar:

$ cd $GOROOT/src $ ./all.bash

Si make all funciona correctamente, finalizar´a imprimiendo como ´ultimas l´ıneas

--- cd ../test N known bugs; 0 unexpected bugs

donde N es un n´umero que var´ıa de una distribuci´on a otra de Go.

1.6. Compilando

Go viene con un conjunto de herramientas bastante completo. Entre las herramientas m´as importantes, est´an los dos tipos de compiladores que podemos usar para generar nuestros pro- gramas ejecutables: gccgo y 6g/8g.

Vamos a ver caracter´ısticas de uno y otro, y un ejemplo de c´omo realizar una compilaci´on con el compilador nativo de Go, la versi´on 6g/8g. Una caracter´ıstica com´un de ambos, es que generan un c´odigo ´unicamente entre un 10 % y un 20 % m´as lento que c´odigo en C.

1.6.1. gccgo

El compilador gccgo es un front-end del famoso compilador de C, GCC. Posee las siguientes caracter´ısticas:

Es un compilador m´as tradicional.

Soporta 32-bit y 64-bit bajo x86, adem´as de ARM.

Genera muy buen c´odigo, pero no tan r´apido como su hermano 6g/8g.

Se puede enlazar con GCC, y as´ı realizar una compilaci´on con C.

No soporta pilas segmentadas todav´ıa y aloja cada goroutine - se ver´a m´as adelante - por hilo de ejecuci´on.

Su uso, es exactamente igual al uso que se le da a GCC, s´olo que invoc´andolo con el co- mando gccgo.

1.6.2. 6g/8g

El compilador 6g/8g es un compilador experimental nativo de Go. 6g, es el compilador aso- ciado a la arquitectura amd64, y genera ficheros objeto con extensi´on ”.6”. 8g, es el compilador asociado a la arquitectura 386, y genera ficheros objeto con extensi´on ”.8”.

ACM Cap´ıtulo de estudiantes 12 FI - UPM

Es un compilador experimental.

Soporta 32-bit y 64-bit bajo x86, adem´as de ARM.

Genera buen c´odigo de forma muy, muy r´apida.

No se puede enlazar con GCC, pero tiene soporte FFI.

Posee un buen soporte de gouroutines, multiplex´andolas en varios hilos de ejecuci´on, e implementa las pilas segmentadas.

Para compilar un archivo cualquiera llamado file.go, usaremos el comando:

$ 6g file.go

y para enlazar el archivo y as´ı generar el fichero ejecutable correspondiente, usaremos:

$ 6l file.

Finalmente, para ejecutar el programa usaremos el comando:

$ ./6.out

Nota.- Hay que tener en cuenta, que si se usa la versi´on 32-bit del compilador, se cambiar´ıa cada 6 por un 8.

Nota.- Para conseguir compilar un fichero con su propio nombre (y as´ı no usar el fichero ejecutable por defecto (6.out), podemos pasarle el par´ametro -o fichero salida (ejemplo: 6l -o fichero file.6).

El linker de Go (6l), no necesita recibir ning´un otro fichero del que dependa la compilaci´on, como en otros lenguajes, ya que el compilador averigua qu´e ficheros son necesarios leyendo el comienzo del fichero compilado.

A la hora de compilar un fichero A.go que dependa de otro B.go que depende a su vez de C.go:

• Compila C.go, B.go y finalmente A.go.
• Para compilar A.go, el compilador lee B.go, no C.go

1.7. Otras herramientas

La distribuci´on de Go viene con una serie de herramientas bastante ´utiles, aunque todav´ıa le faltan otras importantes, como un depurador, que est´a en desarrollo. As´ı pues, contamos con: Godoc, Gofmt y con gdb^2.

(^2) Aquellos que usen gccgo pueden invocar gdb, pero la tabla de s´ımbolos ser´a como la de C y no tendr´an

conocimiento del run-time

ACM Cap´ıtulo de estudiantes 13 FI - UPM

Cap´ıtulo 2

Caracter´ısticas y tipos b´asicos

2.1. Nuestro primer programa: Hello World!

Sin m´as pre´ambulos, y despu´es de contar un poco qu´e es Go y por qu´e se da este manual, veamos el primer trozo de c´odigo: el t´ıpico programa Hello World!

package main

import "fmt"

func main() { fmt.Printf("Hello World!\n") }

2.2. Garbage Collector

Go posee un Garbage Collector - Recolector de Basura - que identifica cu´ando se deja de uti- lizar una variable o una declaraci´on concreta, y libera la memoria asociada de forma autom´atica.

Actualmente, el compilador de Go posee un Garbage Collector muy simple pero efectivo, basado en un ”marcado de barrido”, es decir, marca aquello que puede ser eliminado, y cuando se activa, se borra.

Est´a en desarrollo un Garbage Collector mucho m´as avanzado basado en las ideas del Gar- bage Collector de IBMTM1. Esta nueva implementaci´on pretende ser muy eficiente, concurrente y de baja latencia, con lo que nada m´as detectar que algo sobra, se elimine.

2.3. Las bases del lenguaje

Go est´a basado en una sintaxis tipo C, con lo que cualquier conocimiento previo de dicho lenguaje, ser´a de mucha utilidad para seguir el curso.

(^1) http://www.research.ibm.com/people/d/dfb/papers.html

Strings tipo C: Son aquellas cadenas de caracteres que se escriben igual que en C, pero en este caso deben estar representadas en UTF-8 (o cualquier otra representaci´on Unicode). Tambien pueden representarse bytes con \xNN con 2 d´ıgitos o con \ 012 con 3 d´ıgitos.

"Hello, world!\n" "\xFF" // 1 byte "\u00FF" // 1 caracter unicode, 2 bytes en UTF-

Strings puros: Son cadenas de caracteres que se imprimen tal cual son escritas en el c´odigo fuente, sin escapar ning´un car´acter. Se representan poniendo la cadena entre dos acentos graves ‘ ` ’.

‘\n.abc\t\‘ == "\n\.abc\t\"

2.6. Vistazo r´apido de la sintaxis

La sintaxis de Go es muy similar a la sintaxis utilizada en C. A la hora de declarar una variable o un tipo, se realiza de la misma forma que en C, ´unicamente que se invierte el orden del nombre de la variable y el tipo, quedando este ´ultimo al final. Adem´as, hay que a˜nadir una palabra reservada al principio de las declaraciones. Veamos esto con un ejemplo, definiendo tres tipos de variables y un tipo Struct.

var a int // a es un entero var b, c *int // b y c son punteros a enteros var d []int // d es un array de enteros

type S struct { a, b int } // S es una estructura con dos atributos enteros, a y b.

Las estructuras de control del programa, tambi´en nos resultar´an familiares si hemos traba- jado con lenguages tipo C. Veamos un ejemplo con un if y un for.

if a == b { fmt.Print("a y b son iguales") } else { fmt.Print("a y b son distintos") }

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

Nota.- No son necesarios los par´entesis en la comparaci´on del if o del for, pero siempre son necesarias las llaves, que no pueden ser omitidas. Adem´as, hay que tener en cuenta que la llave de apertura de un if debe ir en la misma linea que la sentencia, y que el else tiene que ir emparejado en la misma linea que el cierre de bloque del if. M´as adelante se ver´a la estructura correcta.

ACM Cap´ıtulo de estudiantes 18 FI - UPM

Por ´ultimo hay que notar en el c´odigo la ausencia del car´acter ’;’ como indicativo del final de sentencia.

Cuando Go fue creado, los puntos y coma eran obligatorios en todas las instrucciones. Fi- nalmente, se acord´o que su uso ser´ıa opcional, y que ser´ıa el propio compilador el que a˜nadir´ıa los puntos y coma al final de las sentencias que considerara v´alidas. A´un as´ı, el uso de puntos y coma en ciertas estructuras es obligatorio. Este esquema sigue las pautas acerca de este tipo de delimitadores del lenguaje BCPL, precursor de B y por lo tanto de C.

As´ı pues, resumiendo acerca del uso de los puntos y coma:

Son opcionales en todos los programas al final de una sentencia, aunque deber´ıan no ponerse. ´Unicamente son obligatorios a la hora de separar los elementos en la cl´ausula de un bucle for o elementos en un if.

El compilador introducir´a autom´aticamente los puntos y coma, por ello no es conveniente ponerlos, al final de una l´ınea no vac´ıa, si lo ´ultimo que se encuentra es:

• Un identificador o un literal.
• Alguna de las palabras reservadas: break, continue, fallthrough o return.
• Alguno de los siguientes tokens: ++, –, ), ], }.

Se pueden poner los puntos y coma para separar instrucciones en una misma l´ınea, pu- diendo ser omitido antes de ’)’ o de ’}’.

2.7. Tipos

Go posee ´unicamente tres tipos b´asicos: N´umeros, Booleanos y Cadenas de caracteres.

2.7.1. N ´umeros

Existen tres tipos num´ericos: Enteros, enteros sin signo y n´umeros flotantes.

Cada uno de estos tipos tiene asociadas una serie de variantes dependiendo del n´umero de bits en el que sea almacenado. Veamos un cuadro resumen con los tipos num´ericos existentes:

Enteros Enteros sin signo Flotantes int uint float int8 uint8 = byte int16 uint int32 uint32 float int64 uint64 float

Cuadro 2.1: Tabla de tipos num´ericos

ACM Cap´ıtulo de estudiantes 19 FI - UPM