¿Qué es el lenguaje de programación GO y para que se utiliza?
Go es un lenguaje de programación concurrente y compilado inspirado en la sintaxis de C, que intenta ser dinámico como Python y con el rendimiento de C o C++. Ha sido desarrollado por Google y sus diseñadores iniciales fueron Robert Griesemer, Rob Pike y Ken Thompson. Actualmente está disponible en formato binario para los sistemas operativos Windows, GNU/Linux, FreeBSD y Mac OS X, pudiendo también ser instalado en estos y en otros sistemas mediante el código fuente.
Go es un lenguaje de programación compilado, concurrente, imperativo, estructurado, orientado a objetos y con recolector de basura que de momento es soportado en diferentes tipos de sistemas UNIX, incluidos Linux, FreeBSD, Mac OS X y Plan 9 (puesto que parte del compilador está basado en un trabajo previo sobre el sistema operativo Inferno). Las arquitecturas soportadas son i386, amd64 y ARM.
Actualmente GO se utiliza mucho es creaciones de API Rest de forma fácil y ágil.
Características del lenguaje de programación GO
- Go es un proyecto opensource.
- Go usa una sintaxis similar a C.
- Go usa tipado estático (statically typed ).
- Go es un lenguaje compilado, al igual que C y C++.
- Provee de un recolector de basura , reflexión y algunas otras capacidades de lenguajes de alto nivel.
- El binario de Go tiene la característica de compilación cruzada de manera nativa.
- Go admite el paradigma de programación orientada a objetos, pero a diferencia de otros lenguajes de programación no dispone de herencia de tipos y tampoco de palabras clave que denoten claramente que soporta este paradigma.
- En Go, la definición de un tipo ("clase") se realiza por medio de declaraciones separadas (interfaces, structs, embedded values).
- Go permite el uso de delegación (a través de embedded values) y polimorfismo (por medio de interfaces).
- Go utiliza la concurrencia a través de las gorutinas.
- Go esta orientado a aprovechar sistemas con múltiples procesadores y procesamiento en red.
- Go admite la tipificación dinámica de datos también conocida como duck Typing.
- Un struct puede implementar una interfaz de forma automática.
Manejo de las Excepciones
Go no utiliza excepciones.Los creadores del lenguaje han dado varios motivos para que esto sea así. La principal es que añadir una capa de excepciones agrega una complejidad innecesaria al lenguaje y al entorno de ejecución. Por definición las excepciones deberían ser excepcionales pero al final se acaban usando como controladores del flujo de la aplicación y dejan de tener la finalidad de excepcionalidad. Según los creadores, las excepciones tienen que ser realmente excepcionales y el uso que se le da mayoritariamente no justifica su existencia.
Tabla de contenido
Acerca de 1
Capítulo 1: Empezando con Go 2
Observaciones 2
Versiones 2
La última versión de la versión principal está en negrita a continuación. Historial de lan 2
Examples 2
¡Hola Mundo! 2
Salida: 3
FizzBuzz 3
Listado de variables de entorno de Go 4
Configurando el medio ambiente 4
GOPATH 5
GOBIN 5
GOROOT 5
Acceso a la documentación fuera de línea 5
Running Go en línea 6
El patio de juegos Go 6
Compartiendo tu codigo 6
En acción 6
Capítulo 2: Agrupación de memoria 8
Introducción 8
Examples 8
sync.Pool 8
Capítulo 3: Análisis de archivos CSV 10
Sintaxis 10
Examples 10
CSV simple de análisis 10
Capítulo 4: Análisis de argumentos de línea de comando y banderas 11
Examples 11
Argumentos de línea de comando 11Banderas 11
Capítulo 5: Aplazar 13
Introducción 13
Sintaxis 13
Observaciones 13
Examples 13
Diferir lo básico 13
Llamadas de función diferida 15
Capítulo 6: Archivo I / O 17
Sintaxis 17
Parámetros 17
Examples 18
Leer y escribir en un archivo usando ioutil. 18
Listado de todos los archivos y carpetas en el directorio actual. 18
Listado de todas las carpetas en el directorio actual 19
Capítulo 7: Arrays 20
Introducción 20
Sintaxis 20
Examples 20
Creando matrices 20
Array Multidimensional 21
Índices de matriz 22
Capítulo 8: Autorización JWT en Go 24
Introducción 24
Observaciones 24
Examples 24
Analizar y validar un token utilizando el método de firma HMAC 24
Creación de un token utilizando un tipo de notificaciones personalizado 25
Creación, firma y codificación de un token JWT utilizando el método de firma HMAC 25
Usando el tipo StandardClaims por sí mismo para analizar un token 26
Analizar los tipos de error usando cheques de campo de bits 26
Obteniendo el token del encabezado de autorización HTTP 27
Capítulo 9: Bucles 28
Introducción 28
Examples 28
Lazo basico 28
Romper y continuar 28
Bucle condicional 29
Diferentes formas de For Loop 29
Bucle temporizado 32
Capítulo 10: Buenas prácticas en la estructura del proyecto. 34
Examples 34
Proyectos Restfull API con Gin 34
controladores 34
núcleo 35
libs 35
middlewares 35
público 36
h21 36
enrutadores 36
servicios 38
main.go 38
Capítulo 11: cgo 40
Examples 40
Cgo: tutorial de primeros pasos. 40
Qué 40
Cómo 40
El ejemplo 40
Hola Mundo! 41
Suma de ints 42
Generando un binario 43
Capítulo 12: cgo 45
Examples 45
Llamando a la función C desde Go 45
Cable C y Go en todas las direcciones. 46
Capítulo 13: Cierres 49
Examples 49
Fundamentos de cierre 49
Capítulo 14: Cliente HTTP 51
Sintaxis 51
Parámetros 51
Observaciones 51
Examples 51
GET básico 51
GET con parámetros de URL y una respuesta JSON 52
Tiempo de espera de solicitud con un contexto 53
1.7+ 53
Antes de 1.7 53
Otras lecturas 54
PUT solicitud de objeto JSON 54
Capítulo 15: Codificación Base64 56
Sintaxis 56
Observaciones 56
Examples 56
Codificación 56
Codificación a una cadena 56
Descodificación 56
Decodificar una cadena 57
Capítulo 16: Comandos de ejecución 58
Examples 58
Tiempo de espera con interrupción y luego matar 58
Ejecución de comando simple 58
Ejecutando un Comando luego Continuar y Esperar 58
Ejecutando un comando dos veces 59
Capítulo 17: Comenzando con el uso de Go Atom 60
Introducción 60
Examples 60
Obtener, instalar y configurar Atom & Gulp 60
Crear $ GO_PATH / gulpfile.js 62
Crear $ GO_PATH / mypackage / source.go 63
Creando $ GO_PATH / main.go 63
Capítulo 18: Compilación cruzada 67
Introducción 67
Sintaxis 67
Observaciones 67
Examples 68
Compila todas las arquitecturas usando un Makefile 68
Recopilación cruzada simple con go build 69
Compilación cruzada utilizando gox 70
Instalación 70
Uso 70
Ejemplo simple: compilar helloworld.go para la arquitectura de brazo en una máquina Linux 70
Capítulo 19: Concurrencia 71
Introducción 71
Sintaxis 71
Observaciones 71
Examples 71
Creando goroutines 71
Hola mundo goroutine 72
Esperando goroutines 72
Usando cierres con goroutines en un bucle. 73
Detener goroutines 74
Ping pong con dos goroutines. 74
Capítulo 20: Constantes 76
Observaciones 76
Examples 76
Declarando una constante 76Declaración de constantes múltiples 77
Constantes mecanografiadas vs. no tipificadas 77
Capítulo 21: Construir restricciones 79
Sintaxis 79
Observaciones 79
Examples 79
Pruebas de integración separadas 79
Optimizar implementaciones basadas en arquitectura. 80
Capítulo 22: Contexto 81
Sintaxis 81
Observaciones 81
Otras lecturas 81
Examples 82
Árbol de contexto representado como un gráfico dirigido 82
Usando un contexto para cancelar el trabajo 83
Capítulo 23: Criptografía 84
Introducción 84
Examples 84
Cifrado y descifrado 84
Prefacio 84
Cifrado 84
Introducción y datos 84
Paso 1 85
Paso 2 85
Paso 3 85
Etapa 4 85
Paso 5 86
Paso 6 86
Paso 7 86
Paso 8 86
Paso 9 86Paso 10 87
Descifrado 87
Introducción y datos 87
Paso 1 87
Paso 2 87
Paso 3 87
Etapa 4 88
Paso 5 88
Paso 6 88
Paso 7 88
Paso 8 88
Paso 9 88
Paso 10 88
Capítulo 24: Cuerda 90
Introducción 90
Sintaxis 90
Examples 90
Tipo de cadena 90
Formato de texto 91
paquete de cuerdas 92
Capítulo 25: Derivación 94
Examples 94
Cambiar declaraciones 94
Si las declaraciones 95
Tipo de cambio de instrucciones 96
Goto declaraciones 97
Declaraciones de ruptura de continuar 97
Capítulo 26: Desarrollando para múltiples plataformas con compilación condicional 99
Introducción 99
Sintaxis 99
Observaciones 99
Examples 100
Crear etiquetas 100
Sufijo de archivo 100
Definiendo comportamientos separados en diferentes plataformas. 100
Capítulo 27: E / S de consola 102
Examples 102
Leer entrada desde consola 102
Capítulo 28: El comando go 104
Introducción 104
Examples 104
Corre 104
Ejecutar varios archivos en el paquete 104
Ir a construir 104
Especifique el sistema operativo o la arquitectura en la construcción: 105
Construir múltiples archivos 105
Construyendo un paquete 105
Ir limpio 105
Ir fmt 105
Ir a buscar 106
Ve env 107
Capítulo 29: Enchufar 109
Introducción 109
Examples 109
Definir y usar un plugin. 109
Capítulo 30: Enviar / recibir correos electrónicos 110
Sintaxis 110
Examples 110
Enviando correo electrónico con smtp.SendMail () 110
Capítulo 31: Estructuras 112
Introducción 112
Examples 112
Declaración Básica 112
Campos exportados frente a no exportados (privado frente a público) 112
Composición e incrustación 113
Incrustación 113
Métodos 114
Estructura anónima 115
Etiquetas 116
Haciendo copias struct. 116
Literales de Struct 118
Estructura vacía 118
Capítulo 32: Expansión en línea 120
Observaciones 120
Examples 120
Deshabilitando la expansión en línea 120
Capítulo 33: Explotación florestal 123
Examples 123
Impresión básica 123
Iniciar sesión para archivar 123
Iniciar sesión en syslog 124
Capítulo 34: Fmt 125
Examples 125
Larguero 125
Fundamento básico 125
Funciones de formato 125
Impresión 126
Sprint 126
Huella 126
Escanear 126
Interfaz de largueros 126
Capítulo 35: Funciones 127
Introducción 127
Sintaxis 127
Examples 127
Declaración Básica 127
Parámetros 127
Valores de retorno 127
Valores de retorno nombrados 128
Funciones y cierres literales 129
Funciones variables 130
Capítulo 36: Goroutines 131
Introducción 131
Examples 131
Programa Básico Goroutines 131
Capítulo 37: Hora 133
Introducción 133
Sintaxis 133
Examples 133
Tiempo de retorno. Tiempo cero valor cuando la función tiene un error 133
Análisis de tiempo 133
Comparando el tiempo 134
Capítulo 38: Imágenes 136
Introducción 136
Examples 136
Conceptos básicos 136
Imagen relacionada con el tipo 137
Accediendo a la dimensión de la imagen y píxel. 137
Cargando y guardando imagen 138
Guardar en PNG 139
Guardar en JPEG 139
Guardar en GIF 140
Recortar imagen 140
Convertir imagen en color a escala de grises 141
Capítulo 39: Instalación 144
Examples 144Instalar en Linux o Ubuntu 144
Capítulo 40: Instalación 145
Observaciones 145
Descargando go 145
Extraer los archivos descargados. 145
Mac y Windows 145
Linux 145
Configuración de variables de entorno 146
Windows 146
Mac 146
Linux 146
¡Terminado! 147
Examples 147
Ejemplo .profile o .bash_profile 147
Capítulo 41: Interfaces 148
Observaciones 148
Examples 148
Interfaz simple 148
Determinación del tipo subyacente desde la interfaz 150
Verificación en tiempo de compilación si un tipo satisface una interfaz 150
Tipo de interruptor 151
Aserción de tipo 151
Ir interfaces de un aspecto matemático 152
Capítulo 42: Iota 154
Introducción 154
Observaciones 154
Examples 154
Uso simple de iota 154
Usando iota en una expresión 154
Valores de salto 155
Uso de iota en una lista de expresiones. 155
Uso de iota en una máscara de bits. 155
Uso de iota en const. 156
Capítulo 43: JSON 157
Sintaxis 157
Observaciones 157
Examples 157
Codificación JSON básica 157
Decodificación JSON básica 158
Decodificación de datos JSON de un archivo 159
Usando estructuras anónimas para decodificar 160
Configurando campos de estructura JSON 161
Ocultar / Omitir ciertos campos 162
Ignorar los campos vacíos 162
Estructuras de cálculo con campos privados. 162
Codificación / Decodificación utilizando Go structs 163
Codificación 163
Descodificación 164
Capítulo 44: Lectores 165
Examples 165
Usando bytes.Lector para leer desde una cadena 165
Capítulo 45: Los canales 166
Introducción 166
Sintaxis 166
Observaciones 166
Examples 166
Utilizando rango 166
Tiempos de espera 167
Coordinadores goroutines 167
Buffer vs vs no buffer 168
Bloqueo y desbloqueo de canales. 169
Esperando que el trabajo termine 170
Capítulo 46: Manejo de errores 171
Introducción 171
Observaciones 171
Examples 171
Creando un valor de error 171
Creando un tipo de error personalizado 172
Devolviendo un error 173
Manejando un error 174
Recuperándose del pánico 175
Capítulo 47: Mapas 177
Introducción 177
Sintaxis 177
Observaciones 177
Examples 177
Declarar e inicializar un mapa 177
Creando un mapa 179
Valor cero de un mapa 180
Iterando los elementos de un mapa. 181
Iterando las teclas de un mapa. 181
Eliminar un elemento del mapa 181
Contando elementos del mapa 182
Acceso concurrente de mapas 182
Creación de mapas con cortes como valores. 183
Verificar elemento en un mapa 184
Iterando los valores de un mapa. 184
Copiar un mapa 184
Usando un mapa como conjunto 185
Capítulo 48: Métodos 186
Sintaxis 186
Examples 186
Metodos basicos 186
Métodos de encadenamiento 187
Operadores de incremento-decremento como argumentos en los métodos 187
Capítulo 49: mgo 189
Introducción 189
Observaciones 189
Examples 189
Ejemplo 189
Capítulo 50: Middleware 191
Introducción 191
Observaciones 191
Examples 191
Función normal del manejador 191
Middleware Calcular el tiempo requerido para que handlerFunc se ejecute 191
CORS Middleware 192
Auth Middleware 192
Controlador de recuperación para evitar que el servidor se bloquee 192
Capítulo 51: Mutex 193
Examples 193
Bloqueo mutex 193
Capítulo 52: Pánico y Recuperación 194
Observaciones 194
Examples 194
Pánico 194
Recuperar 195
Capítulo 53: Paquetes 196
Examples 196
Inicialización de paquetes 196
Gestionando dependencias de paquetes. 196
Usando diferentes paquetes y nombres de carpetas 196
¿Para qué sirve esto? 197
Importando paquetes 197
Capítulo 54: Perfilado usando la herramienta go pprof 200
Observaciones 200
Examples 200
Perfil básico de cpu y memoria. 200
Memoria básica de perfiles 200
Establecer la tasa de perfil de CPU / bloque 201
Uso de puntos de referencia para crear perfil 201
Accediendo al archivo de perfil 201
Capítulo 55: Piscinas de trabajadores 203
Examples 203
Grupo de trabajadores simple 203
Cola de trabajos con grupo de trabajadores 204
Capítulo 56: Plantillas 207
Sintaxis 207
Observaciones 207
Examples 207
Los valores de salida de la estructura de la estructura a la salida estándar utilizando un 207
Definiendo funciones para llamar desde plantilla 208
Capítulo 57: Programación orientada a objetos 209
Observaciones 209
Examples 209
Estructuras 209
Estructuras embebidas 209
Métodos 210
Puntero Vs Valor receptor 211
Interfaz y polimorfismo 212
Capítulo 58: Protobuf en Go 214
Introducción 214
Observaciones 214
Examples 214
Usando Protobuf con Go 214
Capítulo 59: Pruebas 216
Introducción 216
Examples 216
Prueba basica 216
Pruebas de referencia 217
Pruebas unitarias de mesa 218
Pruebas de ejemplo (auto documentar pruebas) 219
Pruebas de solicitudes HTTP 221
Establecer / restablecer la función simulada en las pruebas 221
Pruebas usando la función setUp y tearDown 221
Ver cobertura de código en formato HTML 223
Capítulo 60: Punteros 224
Sintaxis 224
Examples 224
Punteros básicos 224
Puntero v. Métodos de valor 225
Métodos de puntero 225
Métodos de valor 225
Desreferenciación de punteros 227
Las rebanadas son punteros a segmentos de matriz 227
Punteros simples 228
Capítulo 61: Rebanadas 229
Introducción 229
Sintaxis 229
Examples 229
Anexando a rebanar 229
Sumando dos rebanadas juntas 229
Eliminando elementos / "rebanando" rodajas 229
Longitud y capacidad 231
Copiando contenidos de una rebanada a otra rebanada 232
Creando Rebanadas 232
Filtrando una rebanada 233
Valor cero de la rebanada 234
Capítulo 62: Reflexión 235
Observaciones 235
Examples 235
Básico reflejar.Valor de uso 235
Estructuras 235
Rebanadas 236
reflect.Value.Elem () 236
Tipo de valor - paquete "reflejar" 236
Capítulo 63: Seleccione y Canales 238
Introducción 238
Sintaxis 238
Examples 238
Simple Seleccione Trabajar con Canales 238
Usando seleccionar con tiempos de espera 239
Capítulo 64: Señales OS 241
Sintaxis 241
Parámetros 241
Examples 241
Asignar señales a un canal 241
Capítulo 65: Servidor HTTP 243
Observaciones 243
Examples 243
HTTP Hello World con servidor personalizado y mux 243
Hola Mundo 243
Usando una función de manejador 244
Crear un servidor HTTPS 246
Generar un certificado 246
El código Go necesario 247
Respondiendo a una solicitud HTTP usando plantillas 247
Sirviendo contenido usando ServeMux 249
Manejo del método http, acceso a cadenas de consulta y cuerpo de solicitud 249
Capítulo 66: SQL 252
Observaciones 252
Examples 252
Preguntando 252
MySQL 252
Abriendo una base de datos 253
MongoDB: conectar y insertar y eliminar y actualizar y consultar 253
Capítulo 67: Texto + HTML Plantillas 256
Examples 256
Plantilla de elemento único 256
Plantilla de elemento múltiple 256
Plantillas con lógica personalizada. 257
Plantillas con estructuras 258
Plantillas HTML 259
Cómo las plantillas HTML evitan la inyección de código malicioso 260
Capítulo 68: Tipo de conversiones 263
Examples 263
Conversión de tipo básico 263
Implementación de la interfaz de prueba 263
Implementar un sistema de unidades con tipos 263
Capítulo 69: trozo 265
Introducción 265
Examples 265
¿Cómo codificar los datos y escribir en un archivo con gob? 265
¿Cómo leer datos de archivo y decodificar con go? 265
¿Cómo codificar una interfaz con gob? 266
¿Cómo decodificar una interfaz con gob? 267
Capítulo 70: Valores cero 269
Observaciones 269
Examples 269
Valores básicos de cero 269
Valores de cero más complejos 269
Valores cero de Struct 270
Valores Cero Arreglos 270
Capítulo 71: Valores cero 271
Examples 271
Explicación 271
Capítulo 72: Variables 273
Sintaxis 273
Examples 273
Declaración Variable Básica 273
Asignación de variables múltiples 273
Identificador en blanco 274
Comprobando el tipo de una variable 274
Capítulo 73: Venta 276
Observaciones 276
Examples 276
Use govendor para agregar paquetes externos 276
Uso de basura para gestionar ./vendor 277
Usar golang / dep 278
Uso 278
vendor.json utilizando la herramienta Govendor 278
Capítulo 74: XML 280
Observaciones 280
Examples 280
Descodificación / no básica de elementos anidados con datos. 280
Capítulo 75: YAML 282
Examples 282
Creando un archivo de configuración en formato YAML 282
Hosting: Drive (Descarga Directa Para Desktop y Mobile)
Archivo: Pdf
Idioma: Español
Peso: (2 Mb)
