INTRODUCCIÓN 15
Acerca de este libro..................................................................................................16
Organización del libro.............................................................................................17
Convenciones de formato......................................................................................18
Acerca del autor........................................................................................................19
Capítulo 1.
INSTALACIÓN Y USO DE GO 211.1 Instalando Go..................................................................................................21
1.2 Comandos básicos de Go.............................................................................22
1.3 Editando su código en Go.............................................................................23
1.4 Compilando y ejecutando su primer programa.......................................24
Capítulo 2.
SINTAXIS BÁSICA DE GO 272.1 Tipos de datos básicos...................................................................................27
2.2 Cadenas de texto. El tipo string...............................................................28
2.3 Definición de variables...................................................................................29
2.4 Conversiones explícitas de tipos.................................................................30
2.5 Constantes........................................................................................................30
2.6 Bases de numeración.....................................................................................31
2.7 Operadores numéricos..................................................................................32
2.8 Operadores numéricos de comparación...................................................33
2.9 Operadores aplicables al tipo string.......................................................34
2.10 Operadores lógicos con bool.....................................................................34
2.11 Operadores lógicos a nivel de bit................................................................35
2.12 Salida estándar de datos...............................................................................35
2.13 Entrada estándar de datos...........................................................................37
Capítulo 3.
CONTROL DE FLUJO 393.1 Bloques condicionales...................................................................................39
3.1.1 if...................................................................................................................39
3.1.2 if ? else..................................................................................................40
3.1.3 switch - case........................................................................................42
3.2 Órdenes iterativas (bucles for)...................................................................45
3.3 Contexto y ocultación de variables.............................................................48
Capítulo 4.
APUNTADORES 494.1 Definición de un apuntador..........................................................................49
4.2 La referencia a nil.........................................................................................50
4.3 Apuntando hacia una variable.....................................................................50
4.4 Leyendo o modificando el valor apuntado................................................51
4.5 Valores versus referencias............................................................................52
Capítulo 5.
FUNCIONES 555.1 Definición e invocación..................................................................................55
5.2 Retorno de valores.........................................................................................57
5.3 Retorno de múltiples valores.......................................................................58
5.4 Retorno de múltiples valores nombrados.................................................58
5.5 El identificador vacío......................................................................................59
5.6 Paso por valor vs. paso por referencia.......................................................59
5.7 Literales de función........................................................................................61
5.8 Otras consideraciones...................................................................................63
Capítulo 6.
ESTRUCTURAS DE DATOS LINEALES 656.1 Vectores.............................................................................................................65
6.2 Porciones..........................................................................................................67
6.3 Declarando variables a porciones...............................................................68
6.4 Añadir elementos a una porción. Función append.......................................69
6.5 Medir dimensiones con len y cap.............................................................70
6.6 Controlar el tamaño inicial con make.........................................................71
6.7 Copia de porciones con copy......................................................................726.8 Uso de porciones en funciones...................................................................726.9 Recorriendo vectores y porciones...............................................................746.10 Creando "vistas" desde las porciones.........................................................756.11 Funciones con número variable de argumentos........................................776.12 El operador difusor.........................................................................................77
Capítulo 7.
CADENAS DE TEXTO 797.1 Diferencias con porciones y vectores.........................................................80
7.2 Obteniendo la longitud de un string......................................................81
7.3 De string a porción.....................................................................................82
7.4 Construcción dinámica de cadenas............................................................83
7.4.1 Concatenación de cadenas....................................................................84
7.4.2 Construcción con strings.Builder...............................................84
7.4.3 Paquete fmt..............................................................................................85
Capítulo 8.
DICCIONARIOS (MAPAS) 878.1 Declaración de mapas....................................................................................8
78.2 Acceso a elementos........................................................................................88
8.3 Eliminando entradas con delete...............................................................89
8.4 Recorriendo mapas con range...................................................................89
8.5 Contando el número de elementos............................................................90
8.6 Conjuntos..........................................................................................................91
8.7 Detalles internos de map...............................................................................92
Capítulo 9.
ORGANIZACIÓN DE CÓDIGO 95Paquetes y módulos9.1 Paquetes (package).......................................................................................95
9.2 Módulos............................................................................................................96
9.3 Creando módulos y paquetes......................................................................98
9.4 Importando paquetes del módulo local....................................................99
9.4.1 Dependencias circulares.....................................................................100
9.5 Incorporando paquetes de módulos externos.....................................100
9.6 Copias locales de módulos. El directorio vendor........................................102
9.7 Elementos públicos y privados a nivel de paquete......................................103
9.8 Alias de paquete...........................................................................................105
9.9 La función init...........................................................................................106
Capítulo 10.
DEFINICIÓN DE TIPOS DE DATOS 10910.1 Tipos a partir de porciones................................................110
10.2 Tipos a partir de mapas..............................................................................111
10.3 Tipos funcionales.........................................................................................112
10.4 Receptores de función. Métodos.............................................................115
10.5 Tipos pseudoenumerados.........................................................................118
10.5.1 El operador iota..................................................................................119
10.6 Caso de estudio: time.Duration..........................................................122
Capítulo 11.
TIPOS DE DATOS ESTRUCTURADOS 125
Struct11.1 Tipos de datos estructurados: struct...................................................125
11.2 Punteros a struct......................................................................................127
11.3 Receptores de función y creación de métodos.....................................128
11.4 Incrustado de estructuras..........................................................................128
11.5 La estructura vacía: struct{}.................................................................131
11.6 Caso práctico: opciones funcionales como alternativa
a constructores.............................................................................................132
Capítulo 12.
INTERFACES 13712.1 Caso de estudio: la interfaz Stringer...................................................139
12.2 La filosofía del tipado estructural.............................................................139
12.3 Implementando interfaces: receptores ¿mediante apuntadores
o mediante valores?....................................................................................140
12.4 La interfaz vacía interface{}................................................................142
12.5 Manejo seguro de tipos de datos............................................................143
12.6 Incrustando interfaces................................................................................146
Capítulo 13.
GESTIÓN DE ERRORES 14713.1 La interfaz error.........................................................................................147
13.2 Instanciando errores de manera genérica.............................................148
13.3 Comprobación de tipos de error..............................................................148
13.3.1 Errores centinela...................................................................................149
13.3.2 Distintas implementaciones de error............................................152
13.4 Envolviendo errores....................................................................................154
13.5 Verificando la cadena de errores: errors.As.....................................156
13.6 defer.............................................................................................................158
13.7 Entrando en pánico.....................................................................................160
13.8 Función panic.............................................................................................161
13.9 Función recover.........................................................................................161
Capítulo 14.
ENTRADA Y SALIDA 165Flujos de datos14.1 Interfaces io.Writer e io.Reader.................................165
14.2 Archivos de disco.........................................................................................167
14.3 Entrada y salida formateada......................................................................169
14.4 Paquete bufio...............................................................................................171
14.5 Paquete ioutil..........................................................................................172
Capítulo 15.
PARALELISMO Y CONCURRENCIA 175Gorrutinas15.1 Un poco de historia.....................................................................................175
15.2 Gorrutinas......................................................................................................176
15.3 Sincronización mediante sync.WaitGroup.........................................180
15.4 Problemas de concurrencia: condiciones de carrera..........................182
15.5 Sincronización mediante sync.Mutex..................................................186
15.5.1 sync.RWMutex.....................................................................................188
15.6 Sincronización mediante atomic............................................................188
15.7 Conclusiones: ¿cuándo y cómo sincronizar gorrutinas?.....................189
Capítulo 16.
CANALES 19116.1 Creación, uso y cierre..................................................................................191
16.2 Canales solo de lectura y de escritura.....................................................193
16.3 Bloqueo en la escritura: canales con o sin búfer..........................................195
16.4 Iterando canales con for..........................................................................197
16.5 Múltiples receptores....................................................................................198
16.6 Sincronización mediante canales.............................................................199
16.7 Demultiplexión con select......................................................................201
16.8 Cancelando lecturas después de un tiempo de espera......................20216.9 Cancelando tareas mediante contextos.................................................204
Capítulo 17.
SERVICIOS WEB 20717.1 HTTP explicado en 3 minutos....................................................................207
17.2 REST explicado en 3 minutos....................................................................209
17.3 Creación de un servicio HTTP en Go.......................................................210
17.3.1 Interfaz http.Handler......................................................................211
17.3.2 Funciones http.ListenAndServe
y http.ListenAndServeTLS........................................................211
17.3.3 Ejemplo de servidor HTTP...................................................................212
17.4 Creación de un cliente HTTP en Go.........................................................213
17.4.1 Ejemplo de cliente HTTP......................................................................214
17.5 Ejemplo práctico de servicio REST............................................................215
17.5.1 Probando el servicio REST...................................................................220
Capítulo 18.
SERIALIZACIÓN DE DATOS 22318.1 Serialización de tipos Go a JSON..............................................................224
18.2 Deserialización de JSON a tipos Go..........................................................225
18.3 Serializando y deserializando documentos JSON sin formato...........227
18.4 Serialización de porciones y arrays..........................................................227
18.5 Serialización y deserialización en otros formatos.................................228
Capítulo 19.
CONEXIÓN A BASES DE DATOS SQL 23119.1 Carga de controlador..................................................................................232
19.2 Abriendo una base de datos.....................................................................233
19.3 Modificando la base de datos...................................................................233
19.4 Consultando datos......................................................................................234
19.5 Declaraciones preparadas.........................................................................235
19.6 Transacciones...............................................................................................237
19.7 Reserva de conexiones...............................................................................238
Capítulo 20.
PRUEBAS AUTOMATIZADAS DE SOFTWARE 24120.1 Código a probar: la función Factorial......................................................241
20.2 El paquete testing....................................................................................242
20.3 Probando servicios HTTP...........................................................................244
20.4 Pruebas de rendimiento.............................................................................246
20.5 Cobertura de las pruebas..........................................................................247
AP ÉNDICE. PROGRAMACIÓN GENÉRICA 249Tipos de datos genéricos..................................................252
Valor cero de un tipo genérico............................................................................254
Funciones genéricas..............................................................................................254
Restricciones sobre argumentos de tipo..........................................................255
Restricciones como interfaces.............................................................................258
Definiendo nuevas restricciones.........................................................................259
Múltiples argumentos de tipo.............................................................................261
Ejemplo: MultiMapa...............................................................................................261
Incremente su cotización profesional con uno de los lenguajes de programación de Google con más empuje de la última década: Go. Go es el lenguaje presentado por Google en 2009, concebido y diseñado para aumentar la productividad y la calidad de su propio software. Su rapidez y ligereza no obvian las características deseables de todo buen lenguaje de alto nivel: expresividad, limpieza, seguridad y potentes abstracciones que simplifican conceptos que hasta ahora eran sinónimo de complejidad. Todo ello, acompañado por un impresionante conjunto de herramientas gratuitas, han convertido a Go en la elección de grandes proyectos, como Docker o Kubernetes, y a sus programadores, en un solicitado grupo de profesionales. Este libro le permitirá realizar un recorrido a través de las principales características de Go, en cuanto a sintaxis y funcionalidad, así como: -Conocer las funcionalidades más utilizadas de su inmensa biblioteca estándar.
-Ahondar en la filosofía de su sistema de tipos de datos, que ha contribuido a dar la vuelta al modo en que el software se diseña.
-Crear software que es capaz de aprovechar al máximo los actuales computadores multiprocesador y multinúcleo.
-Coordinar y comunicar, con extrema sencillez, miles de procesos que se ejecutan en paralelo.
-Empezar rápidamente a crear aplicaciones profesionales, y adquirir sólidas bases sobre servicios web, serialización de datos o conexión a bases de datos, entre otras....
