PROGRAMACION EN GO

PROGRAMACION EN GO

MACIAS LLORET MARIO

29,70 €
IVA inclós
En estoc
Editorial:
MARCOMBO
Any d'edició:
2022
Matèria
Informatica
ISBN:
978-84-267-3449-5
Pàgines:
264
Enquadernació:
Rústica
29,70 €
IVA inclós
En estoc
Afegir a favorits

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: o Conocer las funcionalidades más utilizadas de su inmensa biblioteca estándar. o 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. o Crear software que es capaz de aprovechar al máximo los actuales computadores multiprocesador y multinúcleo. o Coordinar y comunicar, con extrema sencillez, miles de procesos que se ejecutan en paralelo. o 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. Además, en el apéndice de esta segunda edición se describe el mecanismo de funciones y tipos de datos genéricos, una de las últimas y más demandadas inclusiones, que amplía el paradigma del lenguaje y lo equipara en funcionalidades a los lenguajes de mayor implantación en la industria. No pierda la oportunidad de mejorar su cotización como profesional, a través de un itinerario temático diseñado para facilitar su toma de contacto con el lenguaje y acelerar su profundización en los conceptos más avanzados de Go. Amortizará decenas de veces la adquisición de este libro con el tiempo que ahorrará en la búsqueda de documentación y tutoriales en línea. Este libro le proporciona, ya compilado y pulido, todo el conocimiento que necesita para consolidarse como programador en Go. Mario Macías, autor de este libro, es doctor en arquitectura de computadores. Trabajó como investigador científico durante una década en el Centro Nacional de Supercomputación de Barcelona, España, compaginándolo con horas como profesor de programación en la Universidad Politécnica de Cataluña. Actualmente es ingeniero de software sénior en la empresa Red Hat. En su vertiente como divulgador, es asiduo conferenciante, y ha publicado libros sobre divulgación y Big Data.

Articles relacionats

  • DISEÑO DE APLICACIONES MEDIANTE EL USO INTENSIVO DE DATO
    KLEPPMANN MARTIN
    Los datos están en el centro de muchos desafíos que se presentan actualmente en el diseño de sistemas. Hay que resolver cuestiones complejas, como la escalabilidad, la coherencia, la fiabilidad, la eficiencia y el mantenimiento. Además, existe una abrumadora variedad de herramientas, incluyendo bases de datos relacionales, almacenes de datos NoSQL, procesadores de flujo o por l...
    En estoc

    44,00 €

  • APRENDER WORDPRESS CON 100 EJERCICIOS PRACTICOS
    MONTESERIN FERNANDEZ,PABLO
    Si le interesa hacer de su página web personal la web de su negocio o quiere desarrollar páginas web corporativas para otras personas, este libro es una magnífica oportunidad para lograrlo. WordPress es el gestor de contenidos más usado en el mercado, es especialmente intuitivo y cuenta con infinitas posibilidades para lograr los objetivos que se proponga. Gracias a los 100 e...
    En estoc

    21,40 €

  • CURSO DE PROGRAMACION BASH SHELL
    MATA GARCIA ARTURO
    El propósito general de este libro es introducir al lector en el reconocimiento y escaneo de vulnerabilidades utilizando lenguaje , así como en el diseño de scripts para evaluar la configuración de seguridad de equipos conectados a una red LAN.Esta obra está dirigida a estudiantes y profesionales de la informática, está redactada con un lenguaje claro y didáctico y en e...
    En estoc

    24,90 €

  • SEGURIDAD INFORMÁTICA PARA MAYORES
    MAÍLLO FERNÁNDEZ JUAN ANDRES
    ¿No haces compras a través de Internet por miedo a que te roben? ¿Te preocupa que tus hijos naveguen por la red sin que sepas qué hacen y qué peligros se pueden encontrar? ¿Llevas un Smartphone en tubolsillo todo el día y nos sabes qué debes hacer para estar seguro ante ataques informáticos? Este libro es la respuesta a todas esas dudas y te ayudará a adentrarte en el...
    En estoc

    18,90 €

  • QUERY PARA EXCEL 365/2021
    FLORES CARTILLO JOSE
    Manipular la información proveniente de diversas fuentes e importarla a Excel puede ser un proceso lento y repetitivo. Si requiere una nueva forma de importación, este libro será su gran aliado. En él se proporciona una herramienta rápida y sencilla de aprender, las Consultas, con la que solo necesitará realizar una vez el proceso de importar datos y recrear las importaciones c...
    En estoc

    20,80 €

  • PYTHON PARA FILOSOFO
    LOMEÑA ANDRES
    La programación y la filosofía pueden llegar a ser igual de abstractas, aunque ambas son capaces de converger e iluminarse mutuamente: la filosofía ayuda a visualizar y clarificar las ideas, mientras que la programación enseña a razonar de una forma sistemática y creativa. Este libro sirve para aprender a pensar con Python, desde la democratización del amor por la sabiduría y ...
    En estoc

    14,96 €

Altres llibres de l'autor

  • PROGRAMACIÓN EN GO
    MACÍAS LLORET MARIO
    Incremente su cotización profesional con uno de los lenguajes de programación de Google con mas empuje de la ultima 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, l...
    Sense estoc

    24,80 €