Erhalten Sie Zugang zu diesem und mehr als 300000 Büchern ab EUR 5,99 monatlich.
- Herausgeber: Marcombo
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Spanisch
- Veröffentlichungsjahr: 2020
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, 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ía realizar un recorrido a través de las principales características de Go, en cuanto a sintaxis y funcionalidad, así como: - Conocer las funcionalidades mas 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 multinucleo. - Coordinar y comunicar, con extrema sencillez, miles de procesos que se ejecutan en paralelo. - Empezar rápidamente a crear aplicaciones profesionales, y adquirir solidas bases sobre servicios web, serialización de datos o conexión a bases de datos, entre otras. 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 mas avanzados de Go. Amortizara decenas de veces la adquisición de este libro con el tiempo que ahorrara 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.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 216
Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:
Ähnliche
Programación en Go
Primera edición, 2021
© 2021 Mario Macías Lloret
© 2021 MARCOMBO, S. L.
www.marcombo.com
Diseño de cubierta: ENEDENÚ DISEÑO GRÁFICO
Maquetación: Reverte-Aguilar
Correctora: Anna Alberola
Directora de producción: M.a Rosa CastilloProducción del ePub: booqlab
Todos los logotipos utilizados en este libro son propiedad de sus respectivas empresas y su uso en este libro es meramente didáctico:
Ilustración de cubierta: Renee French - Creative Commons Attribution 3.0 licensed
Logotipo GO de cubierta: Equipo de Go (www.blog.golang.org/go-brand) - Creative Commons Attribution 3.0 licensed
Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra solo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley. Diríjase a CEDRO (Centro Español de Derechos Reprográficos, www.cedro.org) si necesita fotocopiar o escanear algún fragmento de esta obra.
ISBN: 978-84-267-3249-1
Este libro está dedicado a Isabel.Sin tus ideas y ánimos, tu paciencia y generosidad,estas palabras nunca habrían sido posibles.
TABLA DE CONTENIDO
INTRODUCCIÓN
Acerca de este libro
Organización del libro
Convenciones de formato
Acerca del autor
CAPÍTULO 1. INSTALACIÓN Y USO DE GO
1.1 Instalando Go
1.2 Comandos básicos de Go
1.3 Editando su código en Go
1.4 Compilando y ejecutando su primer programa
CAPÍTULO 2. SINTAXIS BÁSICA DE GO
2.1 Tipos de datos básicos
2.2 Cadenas de texto. El tipo string
2.3 Definición de variables
2.4 Conversiones explícitas de tipos
2.5 Constantes
2.6 Bases de numeración
2.7 Operadores numéricos
2.8 Operadores numéricos de comparación
2.9 Operadores aplicables al tipo string
2.10 Operadores lógicos con bool
2.11 Operadores lógicos a nivel de bit
2.12 Salida estándar de datos
2.13 Entrada estándar de datos
CAPÍTULO 3. CONTROL DE FLUJO
3.1 Bloques condicionales
3.1.1if
3.1.2if ... else
3.1.3switch - case
3.2 Órdenes iterativas (bucles for)
3.3 Contexto y ocultación de variables
CAPÍTULO 4. APUNTADORES
4.1 Definición de un apuntador
4.2 La referencia a nil
4.3 Apuntando hacia una variable
4.4 Leyendo o modificando el valor apuntado
4.5 Valores versus referencias
CAPÍTULO 5. FUNCIONES
5.1 Definición e invocación
5.2 Retorno de valores
5.3 Retorno de múltiples valores
5.4 Retorno de múltiples valores nombrados
5.5 El identificador vacío
5.6 Paso por valor vs. paso por referencia
5.7 Literales de función
5.8 Otras consideraciones
CAPÍTULO 6. ESTRUCTURAS DE DATOS LINEALES
6.1 Vectores
6.2 Porciones
6.3 Declarando variables a porciones
6.4 Añadir elementos a una porción. Función append
6.5 Medir dimensiones con len y cap
6.6 Controlar el tamaño inicial con make
6.7 Copia de porciones con copy
6.8 Uso de porciones en funciones
6.9 Recorriendo vectores y porciones
6.10 Creando “vistas” desde las porciones
6.11 Funciones con número variable de argumentos
6.12 El operador difusor
CAPÍTULO 7. CADENAS DE TEXTO
7.1 Diferencias con porciones y vectores
7.2 Obteniendo la longitud de un string
7.3 De string a porción
7.4 Construcción dinámica de cadenas
7.4.1 Concatenación de cadenas
7.4.2 Construcción con strings.Builder
7.4.3 Paquete fmt
CAPÍTULO 8. DICCIONARIOS (MAPAS)
8.1 Declaración de mapas
8.2 Acceso a elementos
8.3 Eliminando entradas con delete
8.4 Recorriendo mapas con range
8.5 Contando el número de elementos
8.6 Conjuntos
8.7 Detalles internos de map
CAPÍTULO 9. ORGANIZACIÓN DE CÓDIGO
Paquetes y módulos
9.1 Paquetes (package)
9.2 Módulos
9.3 Creando módulos y paquetes
9.4 Importando paquetes del módulo local
9.4.1 Dependencias circulares
9.5 Incorporando paquetes de módulos externos
9.6 Copias locales de módulos. El directorio vendor
9.7 Elementos públicos y privados a nivel de paquete
9.8 Alias de paquete
9.9 La función init
CAPÍTULO 10. DEFINICIÓN DE TIPOS DE DATOS
10.1 Tipos a partir de porciones
10.2 Tipos a partir de mapas
10.3 Tipos funcionales
10.4 Receptores de función. Métodos
10.5 Tipos pseudoenumerados
10.5.1 El operador iota
10.6 Caso de estudio: time.Duration
CAPÍTULO 11. TIPOS DE DATOS ESTRUCTURADOS
Struct
11.1 Tipos de datos estructurados: struct
11.2 Punteros a struct
11.3 Receptores de función y creación de métodos
11.4 Incrustado de estructuras
11.5 La estructura vacía: struct{}
11.6 Caso práctico: opciones funcionales como alternativa a constructores
CAPÍTULO 12. INTERFACES
12.1 Caso de estudio: la interfaz Stringer
12.2 La filosofía del tipado estructural
12.3 Implementando interfaces: receptores ¿mediante apuntadores o mediante valores?
12.4 La interfaz vacía interface{}
12.5 Manejo seguro de tipos de datos
12.6 Incrustando interfaces
CAPÍTULO 13. GESTIÓN DE ERRORES
13.1 La interfaz error
13.2 Instanciando errores de manera genérica
13.3 Comprobación de tipos de error
13.3.1 Errores centinela
13.3.2 Distintas implementaciones de error
13.4 Envolviendo errores
13.5 Verificando la cadena de errores: errors.As
13.6defer
13.7 Entrando en pánico
13.8 Función panic
13.9 Función recover
CAPÍTULO 14. ENTRADA Y SALIDA
Flujos de datos
14.1 Interfaces io.Writer e io.Reader
14.2 Archivos de disco
14.3 Entrada y salida formateada
14.4 Paquete bufio
14.5 Paquete ioutil
CAPÍTULO 15. PARALELISMO Y CONCURRENCIA
Gorrutinas
15.1 Un poco de historia
15.2 Gorrutinas
15.3 Sincronización mediante sync.WaitGroup
15.4 Problemas de concurrencia: condiciones de carrera
15.5 Sincronización mediante sync.Mutex
15.5.1sync.RWMutex
15.6 Sincronización mediante atomic
15.7 Conclusiones: ¿cuándo y cómo sincronizar gorrutinas?
CAPÍTULO 16. CANALES
16.1 Creación, uso y cierre
16.2 Canales solo de lectura y de escritura
16.3 Bloqueo en la escritura: canales con o sin búfer
16.4 Iterando canales con for
16.5 Múltiples receptores
16.6 Sincronización mediante canales
16.7 Demultiplexión con select
16.8 Cancelando lecturas después de un tiempo de espera
16.9 Cancelando tareas mediante contextos
CAPÍTULO 17. SERVICIOS WEB
17.1 HTTP explicado en 3 minutos
17.2 REST explicado en 3 minutos
17.3 Creación de un servicio HTTP en Go
17.3.1 Interfaz http.Handler
17.3.2 Funciones http.ListenAndServe y http.ListenAndServeTLS
17.3.3 Ejemplo de servidor HTTP
17.4 Creación de un cliente HTTP en Go
17.4.1 Ejemplo de cliente HTTP
17.5 Ejemplo práctico de servicio REST
17.5.1 Probando el servicio REST
CAPÍTULO 18. SERIALIZACIÓN DE DATOS
18.1 Serialización de tipos Go a JSON
18.2 Deserialización de JSON a tipos Go
18.3 Serializando y deserializando documentos JSON sin formato
18.4 Serialización de porciones y arrays
18.5 Serialización y deserialización en otros formatos
CAPÍTULO 19. CONEXIÓN A BASES DE DATOS SQL
19.1 Carga de controlador
19.2 Abriendo una base de datos
19.3 Modificando la base de datos
19.4 Consultando datos
19.5 Declaraciones preparadas
19.6 Transacciones
19.7 Reserva de conexiones
CAPÍTULO 20. PRUEBAS AUTOMATIZADAS DE SOFTWARE
20.1 Código a probar: la función Factorial
20.2 El paquete testing
20.3 Probando servicios HTTP
20.4 Pruebas de rendimiento
20.5 Cobertura de las pruebas
INTRODUCCIÓN
Go es el lenguaje de moda entre informáticos. Sin duda, es uno de los lenguajes de programación que durante la última década han ganado más impulso entre los programadores de diversas disciplinas. Pese a ser un lenguaje relativamente “joven”, no ha tardado en hacerse con una legión, ya no de adeptos, sino de auténticos fans.
Son muchas las causas del éxito de Go:
• Es versátil. Combina características de los lenguajes de bajo nivel, como C++, con características de lenguajes dinámicos, como Python o Ruby. Esto hace de Go un lenguaje tan idóneo para software de sistema (controladores, comandos de sistema, agentes de monitorización, incluso programación de sistemas embebidos gracias a la implementación de tinygo.org) como para la creación de grandes aplicaciones web y sistemas de servicios distribuidos.
• Es rápido. Es un lenguaje cuyos ejecutables se distribuyen en código nativo, sin necesidad de máquinas virtuales o intérpretes de lenguaje. Compila las técnicas de optimización más vanguardistas.
• Es compacto. Genera ejecutables pequeños que incluyen todo el código necesario, sin necesidad de bibliotecas externas o entornos de ejecución extra.
• Es muy rápido compilando. Está enfocado hacia las tendencias actuales de integración y despliegue continuo de aplicaciones, mediante las cuales el software está en continua actualización. Hoy, el tiempo de compilación es una métrica clave para la productividad de los equipos de desarrollo.
• Es seguro. A diferencia de otros lenguajes como C o C++, donde un apuntador a memoria “desbocado” puede suponer un grave fallo de seguridad, Go comprueba la seguridad de los accesos a memoria de tal manera que un usuario malintencionado lo tendrá mucho más difícil para encontrar fallos de seguridad explotables.
• Es sencillo. Los equipos de desarrollo modernos pasan muchas horas revisando código de sus compañeros, con tal de reforzar unos estándares de calidad altos. Go es un lenguaje diseñado para ser fácil de leer y entender, lo cual incentiva unas prácticas y estilos globales y unificados, y evita proveer múltiples soluciones para una misma tarea.
• Es completo. La distribución estándar de Go proporciona casi todas las herramientas que un profesional necesita: gestores de dependencias, analizadores de rendimiento, formateadores y analizadores de código, depuradores, gestión de la documentación, una enorme biblioteca estándar de funcionalidades, etc.
• Es código abierto. El código de todas las herramientas oficiales de Go, así como su librería estándar, es abierto y libre de modificar y distribuir. Además, sus bibliotecas de terceros también son código abierto.
ACERCA DE ESTE LIBRO
Este libro pretende ser un punto tanto de contacto como de profundización en el lenguaje de programación Go. Está destinado tanto a personas con conocimientos básicos de programación como a profesionales con experiencia que quieran adentrarse en los paradigmas y filosofía de un nuevo lenguaje.
En ningún caso es una introducción a la programación para personas que nunca hayan programado, ni un curso de algoritmia básica. No obstante, muchos de los conceptos que se presentan se explican brevemente, de manera que todo el mundo pueda entenderlos.
Si usted es un programador experto, podrá sacar buen provecho de este libro, ya que no se limita a explicar las estructuras básicas de programación adaptadas a la sintaxis de Go, sino también su filosofía y los nuevos conceptos que hacen de Go un lenguaje único y especial.
Este libro no pretende ser un manual de referencia técnico, ni un compendio de todas las bibliotecas y funciones estándar de Go. Para ese cometido ya existe la documentación oficial. Este libro pretende ser una introducción ágil —sin descuidar la profundización— a las herramientas y características que le permitirán escribir programas en Go de manera productiva, en un breve periodo de tiempo.
Como autor, humildemente —pero no por ello sin ambición—, pretendo que este libro sea la herramienta que a mí me hubiera gustado tener para agilizar mi transición profesional de programador en C y Java hacia el lenguaje Go.
ORGANIZACIÓN DEL LIBRO
Los 20 capítulos de este libro se agrupan en cuatro partes diferenciadas.
La primera parte comprende los capítulos del 1 al 9, y muestra los constructos esenciales de Go, comunes a casi cualquier otro lenguaje de programación imperativo y estructurado. Los programadores expertos serán capaces de leer y asimilar de manera rápida las particularidades de la sintaxis de Go, mediante breves explicaciones y ejemplos concisos. Los programadores menos iniciados encontrarán explicaciones sencillas a muchos conceptos que puedan ser nuevos para ellos.
La segunda parte comprende los capítulos del 10 al 14. Los conceptos aquí explicados tienen sus equivalentes en otros lenguajes de programación, aunque en Go se abordan desde otro paradigma, que cambiará la manera en que diseñamos nuestro software respecto a cuando lo hacemos para lenguajes más clásicos.
Durante el transcurso de los capítulos del 10 al 14, el lector podrá empezar a intuir por qué Go es un lenguaje “diferente”, y cómo aúna filosofías que se pensaban irreconciliables, al situarse entre los lenguajes de programación de bajo nivel y los lenguajes interpretados y dinámicos.
La tercera parte está compuesta por los capítulos 15 y 16, en los que el lector entrará de lleno en los conceptos y herramientas que hacen de Go un lenguaje único para la computación de altas prestaciones, tanto por la potencia de sus herramientas como por su casi insultante sencillez. El lector aprenderá a lanzar miles de tareas en paralelo, a coordinarlas y a establecer una comunicación sencilla y efectiva entre estas.
La cuarta parte está enfocada a la programación de aplicaciones en Go. Además de su lenguaje, su filosofía y sus detalles, este libro pretende servir también como punto de contacto con la programación efectiva de aplicaciones. Por ello, la cuarta y última parte de este libro muestra, paso a paso, cómo utilizar estas funcionalidades de la biblioteca estándar de Go que rápidamente nos permitirán empezar a programar un amplio abanico de aplicaciones.
El capítulo 17 está dedicado a la creación de servicios web en Go: cómo entablar la comunicación entre programas situados remotamente. El capítulo 18 muestra cómo serializar estructuras de datos complejas en Go a formatos de texto, para su intercambio a través de Internet o su guardado en disco, por ejemplo. El capítulo 19 explica las funciones básicas que permitirán conectar nuestras aplicaciones en Go a bases de datos relacionales, para el guardado persistente de datos estructurados y relacionados. Por último, el capítulo 20 muestra el sistema de Go para llevar a cabo una de las prácticas actualmente esenciales durante el desarrollo y mantenimiento de aplicaciones: las pruebas de código automatizadas (testing).
CONVENCIONES DE FORMATO
Este libro intercala texto explicativo con extractos de código, así como con capturas de sesiones interactivas de terminal.
El código fuente se muestra en una fuente de ancho fijo, con algunas palabras clave de Go resaltadas. Ejemplo:
Para una mejor visualización del código en el formato de un libro, las líneas de código no ocuparán más de 60 caracteres de ancho, y las indentaciones/tabulaciones ocuparán 2 caracteres.
La entrada y salida de datos a través del terminal de línea de comandos se muestra en fuente de ancho fijo y sin resaltado. Los comandos que el usuario escribe desde el terminal están precedidos del símbolo del dólar, $, a semejanza de las líneas de comando Unix/Linux:
En algunos momentos, se muestran plantillas que describen de manera genérica algunas partes de la sintaxis de Go. Las partes entre símbolos < y > deben substituirse por un texto que represente el concepto explicado, sin dichos símbolos. Las partes entre símbolos [ y ] representan partes opcionales, que pueden omitirse.
Por ejemplo, la plantilla
podría coincidir con cualquiera de las siguientes líneas válidas de Go:
Por brevedad, en los ejemplos de código se omiten algunas partes que serían necesarias en un programa completo, cuando estas no aportan información interesante al ejemplo o a la explicación, tales como:
• Cabeceras de la función principal: func main()
• Definición de paquetes: package main
• Importación de paquetes externos: import "net/http"
ACERCA DEL AUTOR
Nacido durante las últimas “hornadas” de la generación baby boom, tuve la suerte de entablar contacto con la informática desde pequeñito gracias a mi tío Antonio, que nos consiguió un micro-ordenador Sony MSX. Cuando fui capaz de aprender programación en el lenguaje BASIC de nuestro MSX, supe que quería dedicarme profesionalmente a ello. Creo que fue gracias a la determinación surgida de este fortísimo deseo que conseguí acabar, con mucha frustración y dificultad, mis estudios de secundaria. Los odiaba, pero me permitieron llegar a estudiar Ingeniería Informática en la universidad, una de las mejores cosas que me han pasado en la vida.
Después de trabajar unos años en empresas, volví al mundo académico para trabajar y realizar mi doctorado en Arquitectura de Computadores en el Barcelona Supercomputing Center y en la Universitat Politécnica de Catalunya donde, además, tuve el privilegio de dar clases de programación durante 10 años. Al poco tiempo de volver al mundo empresarial, entré en contacto con Go, nada más entrar en la empresa de monitorización New Relic (newrelic.com).
He pretendido aunar en este libro mi pasión por la programación y mi pasión por la docencia. Solo me queda agradecerle su lectura, y esperar que lo disfrute tanto como yo disfruté escribiéndolo.
Capítulo 1
INSTALACIÓN Y USO DE GO
1.1 INSTALANDO GO
Go está disponible para descarga gratuita desde su página web:
http://golang.org
En la página principal, haga clic en el enlace titulado “Download Go”, que le llevará a la página de descargas (Figura 1.1), donde encontrará los diversos paquetes para su sistema operativo (Windows, Linux, Mac).
Tan solo instale el paquete descargado y siga las instrucciones de instalación. Si la instalación ha tenido éxito, puede abrir una sesión de línea de comandos y verificar que el ejecutable go está en su ruta de programas:
La instalación por defecto de Go consiste en:
• El compilador go, que le permite generar sus archivos ejecutables.
• Herramientas útiles para la programación: depuradores, analizadores de rendimiento, comprobadores de código...
• La biblioteca estándar de Go: una extensa colección de funcionalidades que usted puede incorporar en sus programas.
• La documentación estándar de Go, accesible a través del comando godoc.
Figura 1.1 Página web oficial de descargas de Go.
1.2 COMANDOS BÁSICOS DE GO
A continuación, se muestran algunos de los comandos más habituales de Go, que pueden serle de utilidad durante su proceso de aprendizaje:
•go build
– Ejecutándose desde el directorio raíz de su proyecto Go, genera un archivo ejecutable del proyecto.
•go run <archivo>.go
– Para ejecutar su programa de Go directamente, sin generar un ejecutable. Útil durante la etapa de desarrollo.
•go fmt ./...
– Ejecutándose desde el directorio raíz de su proyecto, reformatea todos los archivos de código fuente según el formato estándar de Go. Su uso es, si no obligado de facto, sí muy recomendable.
•go vet ./...
– Ejecutándose desde el directorio raíz de su proyecto, busca patrones de código susceptibles de ocasionar errores o comportamientos incorrectos.
•godoc
– Abre un servidor web en la dirección http://localhost:6060/. Si lo abre desde su navegador, podrá navegar localmente por toda la documentación de las diferentes bibliotecas estándar de Go, disponibles en la instalación por defecto.
•go get
– Permite descargar bibliotecas y utilidades de línea de comandos suministradas por terceros.
•go mod
– Permite gestionar sus proyectos locales, así como sus dependencias hacia bibliotecas de terceros.
1.3 EDITANDO SU CÓDIGO EN GO
Para programar en Go, tan solo necesita un editor de texto plano, como un bloc de notas. Sin embargo, es aconsejable utilizar un editor de código o un entorno integrado de desarrollo, que proporciona funcionalidades tales como resaltado de código, comprobación in situ de errores, depuración visual, etc.
Go es compatible con la gran mayoría de editores de código y entornos de desarrollo, directamente o a través de extensiones. La tabla de la Figura 1.2 enumera, por orden alfabético, algunos de los entornos más populares para el desarrollo de proyectos en Go. Aunque su editor favorito no esté en la tabla, es posible que ofrezca soporte básico o resaltado de sintaxis para Go.
Figura 1.2 Algunos editores y entornos de desarrollo populares para Go.
1.4 COMPILANDO Y EJECUTANDO SU PRIMER PROGRAMA
Comenzaremos a familiarizarnos con Go y sus herramientas mediante la creación y compilación de un programa básico. No se preocupe si no entiende todo su contenido, ya que será explicado en profundidad en los próximos capítulos.
Para empezar, abra un editor de texto plano y cree un archivo cuya extensión sea .go. Por ejemplo, hola.go. Copie el siguiente contenido:
Del código anterior, quizás haya podido deducir algunos de los siguientes componentes de un programa básico en Go:
• El punto de entrada del programa se marca mediante func main() {. El programa comenzará ejecutando el código contenido en el bloque delimitado por llaves { y }.
• Cada fichero está encabezado por una directiva package, que otorga un nombre común para la agrupación (paquete) de todos los archivos Go en un directorio. El punto de entrada del programa debe estar encabezado por package main (paquete principal).
• Cuando se incorporan funcionalidades de la biblioteca estándar o de otras bibliotecas de terceros (por ejemplo, para mostrar un mensaje en pantalla), deben incorporarse explícitamente los paquetes que las contienen mediante la directiva import. En el programa de ejemplo, la directiva import "fmt” permite usar funcionalidades de escritura de mensajes en pantalla (entre otras).
• Cualquier texto escrito después de dos barras // es ignorado por el compilador hasta el final de la línea. Allí puede dejar algunos comentarios que ayuden a documentar o entender el código.
– Puede usar comentarios de múltiples líneas si los sitúa entre los símbolos /* y */.
• El comando fmt.Println muestra un mensaje en pantalla. Está compuesto por el nombre del paquete en el que está guardado (fmt) y el nombre de la función Println. Entre paréntesis, se escribe el texto a mostrar (que debe ir entre comillas dobles).
Para saber más sobre Println y sobre el paquete fmt, puede probar a ejecutar el comando godoc en su línea de comandos. Se ejecutará un servidor web local en el que puede abrir la siguiente dirección en su navegador:
Dicha dirección le llevará a la documentación del paquete fmt, donde podrá encontrar información completa sobre las funciones que proporciona, muchas de las cuales se explicarán en el próximo capítulo y en el capítulo 14.
Para ejecutar el programa, vaya desde la línea de comandos al directorio que contiene el archivo hola.go y ejecute el siguiente comando:
A continuación del comando escrito, verá el siguiente mensaje:
Esto permite ejecutar el programa en su ordenador personal (ya que tiene instalada la herramienta Go). Para generar un archivo ejecutable que pueda ser ejecutado en otro ordenador, debe utilizar el comando go.build:
El comando anterior creará un archivo ejecutable apto para la misma arquitectura y el mismo sistema operativo desde el cual compila. Si quisiera generar ejecutables para otros sistemas operativos y arquitecturas de procesador, puede usar las variables de entorno GOOS y GOARCH, respectivamente:
Los comandos anteriores generarían ejecutables para Windows con procesadores Intel de 32 bits, y para Linux con procesadores ARM de 64 bits, respectivamente.
Capítulo 2
SINTAXIS BÁSICA DE GO
Este capítulo explica las características básicas del lenguaje de programación Go. Los fundamentos del lenguaje Go no son, en concepto, muy diferentes de los de otros lenguajes de programación, como Java o C.
2.1 TIPOS DE DATOS BÁSICOS
Una variable es un espacio reservado en la memoria del ordenador para guardar datos cuyo valor puede cambiar durante la vida del programa: un número, una letra, un texto, un luchador de Street Fighter... Una variable irá asociada a un nombre para poder referirnos a ella durante el programa: matrícula, total, jugador1...
Go es un lenguaje con “tipado estático”, lo que significa que cada variable tiene un tipo de dato asociado y solo podrá guardar valores de su tipo de dato.
Go provee los siguientes tipos de datos básicos, a partir de los cuales es posible definir variables y ejecutar operaciones básicas:
•bool es el tipo booleano. Los posibles valores que puede tomar son dos: true (cierto) o false (falso).
•string permite guardar cadenas de texto, y acepta cualquier carácter Unicode mediante la codificación UTF-8 (es decir, todos los caracteres del alfabeto latino, más caracteres de otras culturas, incluso emojis).
•int es un número entero con signo (es decir, permite guardar tanto números enteros positivos como negativos). Su tamaño depende de la plataforma para la cual se compila el programa. Esto significa que el compilador escogerá el tamaño de las variables int que mejor se adapten a la arquitectura del procesador para el cual se compila (generalmente, concordará con el número de bits del procesador: 32 o 64).
– Cuando sea necesario concretar con exactitud el tamaño de una variable, se pueden usar los siguientes tipos: int8, int16, int32, int64 para números enteros con signo de 8, 16, 32 y 64 bits, respectivamente.
•uint es un número entero sin signo (es decir, no acepta números negativos). Al igual que int, su tamaño dependerá de la plataforma (32 o 64 bits).
– Cuando se requiera concretar con exactitud el tamaño de una variable, se pueden usar los siguientes tipos: uint8, uinti6, uint32 o uint64.
•byte es el equivalente de uint8.
•rune es un equivalente para int32 y se usa para representar un carácter (letras, números, signos de puntuación, emojis, y un largo etcétera).
•float32 y float64 representan números de coma flotante (también llamados “números reales”) de 32 y 64 bits, respectivamente.
•complex64 y complex128 son números complejos cuyas partes real e imaginaria están representadas por números reales de 32 y 64 bits, respectivamente.
– Un literal de número complejo se escribe como en el siguiente ejemplo: 2.23 + 3i.
2.2 CADENAS DE TEXTO. EL TIPO string
Go permite definir cadenas de texto explícitamente, insertando un texto cualquiera entre comillas dobles:
Si una cadena ha de contener un texto mostrado en diversas líneas, puede introducir el carácter especial de nueva línea \n allá donde quiera que termine una línea y empiece otra:
Si una cadena ha de contener comillas dobles en su interior, estas deben especificarse como un carácter especial \", para que Go no las confunda como el final de una cadena de texto:
Cuando un texto contiene múltiples líneas o comillas dobles, puede resultar más limpio substituir el delimitador de comillas dobles por el de “acento grave”; esto le permitirá escribir cadenas en múltiples líneas, tomando los saltos de línea como literales. El equivalente a la cadena anterior, sería:
No debe confundir los delimitadores de cadenas con la comilla simple ', que sirve para especificar caracteres individuales, del tipo byte o rune.
2.3 DEFINICIÓN DE VARIABLES
La manera de definir una variable, dado un nombre y un tipo de dato, es:
Por ejemplo:
Las líneas anteriores definirían una variable llamada dias, del tipo int, y otra variable llamada meses, del tipo int, a la que se le asigna un valor inicial de 12.
Si no se provee un valor inicial, las variables serán inicializadas automáticamente con el “valor cero” de cada tipo de dato: 0 para tipos numéricos, false para bool, y la cadena vacía "" para string.
